private void ThreadUpdateApp(CancellationToken cancellationToken)
{
_state.Value = PatcherState.UpdatingApp;
_remoteVersionId.Value = _app.GetLatestVersionId();
if (_app.IsInstalled())
{
_localVersionId.Value = _app.GetInstalledVersionId();
}
_updateAppCancellationTokenSource = new CancellationTokenSource();
using (cancellationToken.Register(() => _updateAppCancellationTokenSource.Cancel()))
{
var appUpdater = new AppUpdater.AppUpdater(new AppUpdaterContext(_app, _configuration.AppUpdaterConfiguration));
appUpdater.Context.StatusMonitor.OverallStatusChanged += OnUpdateAppStatusChanged;
try
{
appUpdater.Update(_updateAppCancellationTokenSource.Token);
}
finally
{
appUpdater.Context.StatusMonitor.OverallStatusChanged -= OnUpdateAppStatusChanged;
_updateAppCancellationTokenSource = null;
}
}
}
private void ThreadUpdateApp(bool automatically, CancellationToken cancellationToken)
{
_state.Value = PatcherState.Connecting;
_updateAppCancellationTokenSource = new PatchKit.Unity.Patcher.Cancellation.CancellationTokenSource();
using (cancellationToken.Register(() => _updateAppCancellationTokenSource.Cancel()))
{
_appInfo.Value = _app.RemoteMetaData.GetAppInfo(!automatically, _updateAppCancellationTokenSource.Token);
_remoteVersionId.Value = _app.GetLatestVersionId(!automatically, _updateAppCancellationTokenSource.Token);
if (_app.IsFullyInstalled())
{
_localVersionId.Value = _app.GetInstalledVersionId();
}
var appUpdater = new AppUpdater.AppUpdater(new AppUpdaterContext(_app, _configuration.AppUpdaterConfiguration));
try
{
_updaterStatus.Value = appUpdater.Status;
using (_updaterStatus.Take(1).Subscribe((status) => _state.Value = PatcherState.UpdatingApp))
{
appUpdater.Update(_updateAppCancellationTokenSource.Token);
_wasUpdateSuccessfulOrNotNecessary = true;
}
}
catch (OperationCanceledException)
{
PatcherStatistics.DispatchSendEvent(PatcherStatistics.Event.PatcherCanceled);
throw;
}
finally
{
_state.Value = PatcherState.None;
_updaterStatus.Value = null;
_updateAppCancellationTokenSource = null;
}
}
}
protected void Display(PatchKit.Unity.Patcher.Cancellation.CancellationToken cancellationToken)
{
Assert.IsFalse(_unityThread == Thread.CurrentThread,
"Display dialog can be only used on separate thread.");
try
{
_isDisplaying = true;
_dialogDisplayed.Reset();
using (cancellationToken.Register(() => _dialogDisplayed.Set()))
{
cancellationToken.ThrowIfCancellationRequested();
_dialogDisplayed.WaitOne();
}
}
finally
{
_isDisplaying = false;
}
}
private void ThreadUpdateApp(CancellationToken cancellationToken)
{
_state.Value = PatcherState.UpdatingApp;
_updateAppCancellationTokenSource = new CancellationTokenSource();
using (cancellationToken.Register(() => _updateAppCancellationTokenSource.Cancel()))
{
var appUpdater = new AppUpdater.AppUpdater(_app, _configuration.AppUpdaterConfiguration);
appUpdater.Context.StatusMonitor.OverallStatusChanged += OnUpdateAppStatusChanged;
try
{
appUpdater.Update(_updateAppCancellationTokenSource.Token);
}
finally
{
appUpdater.Context.StatusMonitor.OverallStatusChanged -= OnUpdateAppStatusChanged;
_updateAppCancellationTokenSource = null;
}
}
}
private void ThreadWaitForUserDecision(CancellationToken cancellationToken)
{
try
{
DebugLogger.Log("Waiting for user decision...");
_state.Value = PatcherState.WaitingForUserDecision;
bool isInstalled = _app.IsFullyInstalled();
DebugLogger.LogVariable(isInstalled, "isInstalled");
bool canRepairApp = false; // not implemented
bool canInstallApp = !isInstalled;
bool canCheckForAppUpdates = isInstalled;
bool canStartApp = isInstalled;
_isAppInstalled.Value = isInstalled;
_canRepairApp.Value = false;
_canInstallApp.Value = false;
_canCheckForAppUpdates.Value = false;
_canStartApp.Value = false;
if (canInstallApp && _configuration.AutomaticallyInstallApp && !_hasAutomaticallyInstalledApp)
{
DebugLogger.Log("Automatically deciding to install app.");
_hasAutomaticallyInstalledApp = true;
_hasAutomaticallyCheckedForAppUpdate = true;
_userDecision = UserDecision.InstallAppAutomatically;
return;
}
if (canCheckForAppUpdates && _configuration.AutomaticallyCheckForAppUpdates &&
!_hasAutomaticallyCheckedForAppUpdate)
{
DebugLogger.Log("Automatically deciding to check for app updates.");
_hasAutomaticallyInstalledApp = true;
_hasAutomaticallyCheckedForAppUpdate = true;
_userDecision = UserDecision.CheckForAppUpdatesAutomatically;
return;
}
var updatesOnly = Environment.GetCommandLineArgs().Any(arg => arg.Equals("--updateOnly", StringComparison.OrdinalIgnoreCase));
if (canStartApp && updatesOnly)
{
_canStartApp.Value = true;
_userDecision = UserDecision.AppUpdatesOnly;
return;
}
else
{
if (canStartApp && _configuration.AutomaticallyStartApp && !_hasAutomaticallyStartedApp)
{
DebugLogger.Log("Automatically deciding to start app.");
_hasAutomaticallyStartedApp = true;
_userDecision = UserDecision.StartAppAutomatically;
return;
}
_canRepairApp.Value = canRepairApp;
_canInstallApp.Value = canInstallApp;
_canCheckForAppUpdates.Value = canCheckForAppUpdates;
_canStartApp.Value = canStartApp;
}
_userDecisionSetEvent.Reset();
using (cancellationToken.Register(() => _userDecisionSetEvent.Set()))
{
cancellationToken.ThrowIfCancellationRequested();
_userDecisionSetEvent.WaitOne();
}
_canRepairApp.Value = false;
_canInstallApp.Value = false;
_canCheckForAppUpdates.Value = false;
_canStartApp.Value = false;
cancellationToken.ThrowIfCancellationRequested();
DebugLogger.Log(string.Format("Waiting for user decision result: {0}.", _userDecision));
}
catch (OperationCanceledException)
{
DebugLogger.Log("Waiting for user decision cancelled.");
}
catch (ThreadInterruptedException)
{
DebugLogger.Log("Waiting for user decision interrupted: thread has been interrupted. Rethrowing exception.");
throw;
}
catch (ThreadAbortException)
{
DebugLogger.Log("Waiting for user decision aborted: thread has been aborted. Rethrowing exception.");
throw;
}
catch (Exception)
{
DebugLogger.LogWarning("Error while waiting for user decision: an exception has occured. Rethrowing exception.");
throw;
}
}
private void ThreadWaitForUserDecision(CancellationToken cancellationToken)
{
try
{
DebugLogger.Log("Waiting for user decision...");
_state.Value = PatcherState.WaitingForUserDecision;
bool isInstalled = _app.IsInstalled();
DebugLogger.LogVariable(isInstalled, "isInstalled");
_canRepairApp.Value = false; // not implemented
_canInstallApp.Value = !isInstalled;
_canCheckForAppUpdates.Value = isInstalled;
_canStartApp.Value = isInstalled;
if (_canInstallApp.Value && _configuration.AutomaticallyInstallApp && !_hasAutomaticallyInstalledApp)
{
DebugLogger.Log("Automatically deciding to install app.");
_hasAutomaticallyInstalledApp = true;
_userDecision = UserDecision.InstallAppAutomatically;
return;
}
if (_canCheckForAppUpdates.Value && _configuration.AutomaticallyCheckForAppUpdates &&
!_hasAutomaticallyCheckedForAppUpdate)
{
DebugLogger.Log("Automatically deciding to check for app updates.");
_hasAutomaticallyCheckedForAppUpdate = true;
_userDecision = UserDecision.CheckForAppUpdatesAutomatically;
return;
}
if (_canStartApp.Value && _configuration.AutomaticallyStartApp && !_hasAutomaticallyStartedApp)
{
DebugLogger.Log("Automatically deciding to start app.");
_hasAutomaticallyStartedApp = true;
_userDecision = UserDecision.StartAppAutomatically;
return;
}
_userDecisionSetEvent.Reset();
using (cancellationToken.Register(() => _userDecisionSetEvent.Set()))
{
cancellationToken.ThrowIfCancellationRequested();
_userDecisionSetEvent.WaitOne();
}
cancellationToken.ThrowIfCancellationRequested();
DebugLogger.Log(string.Format("Waiting for user decision result: {0}.", _userDecision));
}
catch (OperationCanceledException)
{
DebugLogger.Log("Waiting for user decision cancelled.");
}
catch (ThreadInterruptedException)
{
DebugLogger.Log("Waiting for user decision interrupted: thread has been interrupted. Rethrowing exception.");
throw;
}
catch (ThreadAbortException)
{
DebugLogger.Log("Waiting for user decision aborted: thread has been aborted. Rethrowing exception.");
throw;
}
catch (Exception)
{
DebugLogger.LogWarning("Error while waiting for user decision: an exception has occured. Rethrowing exception.");
throw;
}
}
