protected DownloadFileTask(Account account, string accountName, int priority, AsyncTask[] parent,
string destFolder, AccountFile file)
: base(account, accountName, priority, parent)
{
DestFolder = destFolder;
File = file;
}
private void EnumerateFilesRecursiveAsync(DirectoryInfo folder, AccountFile destDirectory, AsyncTask task, CancellationToken token)
{
foreach (var file in folder.EnumerateFiles())
{
if (token.IsCancellationRequested)
return;
//var newTask = task == null
// ? new UploadFileTask(Account, AccountName, 0, null, file.FullName, destDirectory)
// : new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null);
var newTask = new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null);
AddTask(newTask);
lastTask.AddParent(newTask);
}
foreach (var dir in folder.EnumerateDirectories())
{
if (token.IsCancellationRequested)
return;
//var newTask = task == null
// ? new CreateFolderTask(Account, AccountName, 0, null, dir.Name, destDirectory)
// : new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null);
var newTask = new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null);
AddTask(newTask);
lastTask.AddParent(newTask);
EnumerateFilesRecursiveAsync(dir, destDirectory, newTask, token);
}
OnProgress(new AsyncTaskProgressEventArgs(0, null));
}
public void SimpleTest()
{
var Result = new AsyncTask<String>(delegate()
{
return "Hello";
});
Assert.AreEqual("Hello", Result.Result);
}
public void Complex2Test()
{
var Result = new AsyncTask<String>(delegate()
{
Thread.Yield();
return "Test";
});
Assert.AreEqual("Test", Result.Result);
Assert.IsTrue(Result.Ready);
}
public void Complex1Test()
{
var Result = new AsyncTask<String>(delegate()
{
Thread.Yield();
return "Test";
});
Assert.IsFalse(Result.Ready);
Thread.Sleep(2);
Assert.IsTrue(Result.Ready);
}
/// <summary>
/// Runs <paramref name="method"/> on the worker thread.
/// </summary>
/// <param name="method">The method to run.</param>
/// <returns>IAsyncResult that gets completed when the action has executed.</returns>
public IAsyncResult Enqueue(Action method)
{
if (method == null)
throw new ArgumentNullException("method");
AsyncTask task = new AsyncTask(method);
lock (lockObject) {
taskQueue.Enqueue(task);
Monitor.Pulse(lockObject);
}
return task;
}
private void btnTruncateSelected_Click(object sender, EventArgs e)
{
AsyncTask<string,string, string> task = new AsyncTask<string,string,string>(this);
TextBox LogTxt = null;
Trunc.OnProgress += new TableTruncator.TableItemTruncateEventHandler(
delegate(string TableName, string Operation)
{
task.PublishProgress(string.Format("{0} -> {1}", Operation, TableName));
}
);
task.doInBackground = delegate(string[] param)
{
task.PublishProgress("Truncating tables...");
Trunc.TruncateTable(param);
return "Done";
};
task.onProgressUpdate = delegate(string[] param)
{
lblStatus.Text = param[0];
LogTxt.AppendText(param[0] + "\r\n");
LogTxt.SelectionStart = LogTxt.Text.Length;
};
task.onPostExecute = delegate(string result)
{
lblStatus.Text = result;
LogTxt.AppendText(result + "\r\n");
LogTxt.SelectionStart = LogTxt.Text.Length;
LogTxt.AppendText("Disconnecting\r\n");
if (chkShowScript.Checked)
{
frmScriptViewer ScriptViewDlg = new frmScriptViewer(Trunc.ToString());
ScriptViewDlg.ShowDialog();
}
Trunc.Release();
};
Trunc.OnlyGenerateSQLScript = chkOnlyGenScript.Checked;
LogTxt = PassProgressMode();
task.Execute(GetCheckedTables());
}
private void NotifyTaskStateChanged(AsyncTask task, TaskStateChangedEventArgs.State state)
{
var stateChangedHandler = TaskStateChanged;
if (stateChangedHandler == null)
return; // No event handler, bail.
var e = new TaskStateChangedEventArgs(task, state);
stateChangedHandler(this, e);
if (state == TaskStateChangedEventArgs.State.Discarded)
{
task.HandleTaskDiscarded();
}
}
protected override TaskMergeInstruction CanMergeWithCore(AsyncTask otherTask)
{
var theOtherTask = otherTask as NotifyRenderPackagesReadyAsyncTask;
if (theOtherTask == null)
return base.CanMergeWithCore(otherTask);
// Comparing to another NotifyRenderPackagesReadyAsyncTask, the one
// that gets scheduled more recently stay, while the earlier one
// gets dropped. If this task has a higher tick count, keep this.
//
if (ScheduledTime.TickCount > theOtherTask.ScheduledTime.TickCount)
return TaskMergeInstruction.KeepThis;
return TaskMergeInstruction.KeepOther; // Otherwise, keep the other.
}
protected override async Task OnStartAsync()
{
lastTask = new EmptyTask(Account, AccountName, Priority, null);
var folder = new DirectoryInfo(Path);
OnProgress(new AsyncTaskProgressEventArgs(0, null));
var createFolderTask = new CreateFolderTask(Account, AccountName, 0, null, FolderName, DestFolder);
AddTask(createFolderTask);
lastTask.AddParent(createFolderTask);
//CreatedFolder = await Account.CreateFolderAsync(System.IO.Path.GetFileName(Path), DestFolder, CancellationTokenSource.Token);
EnumerateFilesRecursiveAsync(folder, CreatedFolder, createFolderTask, CancellationTokenSource.Token);
AddTask(lastTask);
await Task.Run(async () =>
{
while (lastTask.State == AsyncTaskState.Running || lastTask.State == AsyncTaskState.Waiting)
{
await Task.Delay(500);
}
});
}
/// <summary>
/// Creates tasks percentage.
/// </summary>
/// <param name="asyncTaskUId">The task UId to be updated</param>
/// <param name="currentActivity">The current activity</param>
/// <param name="pct">The current percentage</param>
public void CreateTask(string asyncTaskUId, string type, string requiredRole, string currentActivity, string description, string fileName, string contentType, string mimeType)
{
AsyncTask asyncTask = new AsyncTask();
asyncTask.AsyncTaskUId = asyncTaskUId;
asyncTask.Type = type;
asyncTask.CurrentAtivity = currentActivity;
asyncTask.RequiredRole = requiredRole;
asyncTask.Description = description;
asyncTask.CurrentPercentage = 0;
asyncTask.StartDate = DateTime.Now.ToUniversalTime();
asyncTask.FileName = fileName;
asyncTask.ResultContentType = contentType;
asyncTask.ResultMimeType = mimeType;
using (Data.CoreContext context = new Data.CoreContext()) {
context.AsyncTasks.Add(asyncTask);
context.SaveChanges();
}
}
public static void LogUnhandledException(this AsyncTask task, string prefix, Exception ex)
{
LogUnhandledException((code, message) => task.LogCodedError(code, message), prefix, ex);
}
public void Login()
{
if (log.IsDebugEnabled)
{
log.DebugFormat("login start. username:{0} password:{1}", this.username, this.password);
}
this.account = null;
this.loginCommand.Enabled = false;/*by databinding, auto set button.interactable = false. */
AsyncTask <Account> task;
if (!(this.ValidateUsername() && this.ValidatePassword()))
{
task = new AsyncTask <Account>(() => { return(null); });
}
else
{
task = new AsyncTask <Account>(() =>
{
IAsyncResult <Account> result = this.accountService.Login(this.username, this.password);
Account account = result.Synchronized().WaitForResult();
if (account != null)
{
Context.GetApplicationContext().GetMainLoopExcutor().RunOnMainThread(() =>
{
globalPreferences.SetString(LAST_USERNAME_KEY, this.username);
globalPreferences.Save();
});
}
return(account);
});
}
task.OnPostExecute(account =>
{
if (account != null)
{
/* login success */
this.account = account;
this.interactionFinished.Raise();/* Interaction completed, request to close the login window */
}
else
{
/* Login failure */
var tipContent = this.localization.GetText("login.failure.tip", "Login failure.");
this.toastRequest.Raise(new Notification(tipContent));/* show toast */
}
}).OnError(e =>
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("OnError:{0}", e);
}
var tipContent = this.localization.GetText("login.exception.tip", "Login exception.");
this.toastRequest.Raise(new Notification(tipContent));/* show toast */
}).OnFinish(() =>
{
this.loginCommand.Enabled = true;/*by databinding, auto set button.interactable = true. */
}).Start();
}
public _Runnable_381(AsyncTask function, Database database)
{
this.function = function;
this.database = database;
}
public IEnumerator LoadLevelCoroutine(Package.Asset asset, string playerScene, string uiScene, SimulationMetaData ngs)
{
string scene;
int i;
yield return(null);
Util.InvokeVoid(LoadingManager.instance, "PreLoadLevel");
if (!LoadingManager.instance.LoadingAnimationComponent.AnimationLoaded)
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading("LoadingAnimation");
yield return(SceneManager.LoadSceneAsync("LoadingAnimation", LoadSceneMode.Additive));
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
AsyncTask task = Singleton <SimulationManager> .instance.AddAction("Loading", (IEnumerator)Util.Invoke(LoadingManager.instance, "LoadSimulationData", asset, ngs));
LoadSaveStatus.activeTask = task;
if (LoadingManager.instance.m_loadedEnvironment == null) // loading from main menu
{
knownFailedAssets.Clear();
fastLoad = false;
}
else // loading from in-game (the pause menu)
{
while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_139
{
yield return(null);
}
if (SimulationManager.instance.m_metaData == null)
{
SimulationManager.instance.m_metaData = new SimulationMetaData();
SimulationManager.instance.m_metaData.m_environment = "Sunny";
SimulationManager.instance.m_metaData.Merge(ngs);
}
Util.InvokeVoid(LoadingManager.instance, "MetaDataLoaded"); // No OnCreated
string mapThemeName = SimulationManager.instance.m_metaData.m_MapThemeMetaData?.name;
fastLoad = SimulationManager.instance.m_metaData.m_environment == LoadingManager.instance.m_loadedEnvironment && mapThemeName == LoadingManager.instance.m_loadedMapTheme;
// The game is nicely optimized when loading from the pause menu. We must specifically address the following situation:
// - environment (biome) stays the same
// - map theme stays the same
// - 'load used assets' is enabled
// - not all assets used in the save being loaded are currently in memory.
if (fastLoad)
{
if (Settings.settings.loadUsed && !IsKnownFastLoad(asset))
{
i = Profiling.Millis;
while (Profiling.Millis - i < 5000 && !IsSaveDeserialized())
{
yield return(null);
}
fastLoad = AllAssetsAvailable();
}
if (fastLoad) // optimized load
{
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded"));
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady"));
Util.DebugPrint("fast load at", Profiling.Millis);
}
else // fallback to full load
{
DestroyLoadedPrefabs();
LoadingManager.instance.m_loadedEnvironment = null;
LoadingManager.instance.m_loadedMapTheme = null;
Util.DebugPrint("not fast load at", Profiling.Millis);
}
}
else // full load
{
// Notice that there is a race condition in the base game at this point: DestroyAllPrefabs ruins the simulation
// if its deserialization has progressed far enough. Typically there is no problem.
Util.InvokeVoid(LoadingManager.instance, "DestroyAllPrefabs");
LoadingManager.instance.m_loadedEnvironment = null;
LoadingManager.instance.m_loadedMapTheme = null;
Util.DebugPrint("full load at", Profiling.Millis);
}
}
if (LoadingManager.instance.m_loadedEnvironment == null) // IL_27C
{
AsyncOperation op;
knownFastLoads.Clear();
fullLoadTime = DateTime.Now;
loadingLock = Util.Get(LoadingManager.instance, "m_loadingLock");
if (!string.IsNullOrEmpty(playerScene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(playerScene);
op = SceneManager.LoadSceneAsync(playerScene, LoadSceneMode.Single);
while (!op.isDone) // IL_2FF
{
LoadingManager.instance.SetSceneProgress(op.progress * 0.01f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_33C
{
yield return(null);
}
if (SimulationManager.instance.m_metaData == null)
{
SimulationManager.instance.m_metaData = new SimulationMetaData();
SimulationManager.instance.m_metaData.m_environment = "Sunny";
SimulationManager.instance.m_metaData.Merge(ngs);
}
Util.InvokeVoid(LoadingManager.instance, "MetaDataLoaded"); // OnCreated if loading from the main manu
KeyValuePair <string, float>[] levels = SetLevels();
float currentProgress = 0.10f;
for (i = 0; i < levels.Length; i++)
{
scene = levels[i].Key;
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive);
while (!op.isDone)
{
LoadingManager.instance.SetSceneProgress(currentProgress + op.progress * (levels[i].Value - currentProgress));
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
currentProgress = levels[i].Value;
}
Queue <IEnumerator> mainThreadQueue;
// Some major mods (Network Extensions 1 & 2, Single Train Track, Metro Overhaul) have a race condition issue
// in their NetInfo Installer. Everything goes fine if LoadCustomContent() below is NOT queued before the
// said Installers have finished. This is just a workaround for the issue. The actual fix should be in
// the Installers. Notice that the built-in loader of the game is also affected.
do
{
yield return(null);
yield return(null);
lock (loadingLock)
{
mainThreadQueue = (Queue <IEnumerator>)queueField.GetValue(LoadingManager.instance);
i = mainThreadQueue.Count;
}
}while (i > 0);
LoadingManager.instance.QueueLoadingAction(AssetLoader.instance.LoadCustomContent());
RenderManager.Managers_CheckReferences();
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded"));
RenderManager.Managers_InitRenderData();
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady"));
simulationFailed = HasFailed(task);
// Performance optimization: do not load scenes while custom assets are loading.
while (!AssetLoader.instance.hasFinished)
{
yield return(null);
}
scene = SimulationManager.instance.m_metaData.m_environment + "Properties";
if (!string.IsNullOrEmpty(scene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive);
while (!op.isDone) // IL_C47
{
LoadingManager.instance.SetSceneProgress(0.85f + op.progress * 0.05f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if (!simulationFailed)
{
simulationFailed = HasFailed(task);
}
if (!string.IsNullOrEmpty(uiScene)) // IL_C67
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(uiScene);
op = SceneManager.LoadSceneAsync(uiScene, LoadSceneMode.Additive);
while (!op.isDone) // IL_CDE
{
LoadingManager.instance.SetSceneProgress(0.90f + op.progress * 0.08f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
LoadingManager.instance.m_loadedEnvironment = SimulationManager.instance.m_metaData.m_environment; // IL_CFE
LoadingManager.instance.m_loadedMapTheme = SimulationManager.instance.m_metaData.m_MapThemeMetaData?.name;
}
else
{
scene = (string)Util.Invoke(LoadingManager.instance, "GetLoadingScene");
if (!string.IsNullOrEmpty(scene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
yield return(SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive));
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
}
LoadingManager.instance.SetSceneProgress(1f); // IL_DBF
if (!simulationFailed)
{
simulationFailed = HasFailed(task);
}
while (!task.completedOrFailed) // IL_DED
{
yield return(null);
}
LoadingManager.instance.m_simulationDataLoaded = LoadingManager.instance.m_metaDataLoaded;
LoadingManager.SimulationDataReadyHandler SimDataReady = Util.Get(LoadingManager.instance, "m_simulationDataReady") as LoadingManager.SimulationDataReadyHandler;
SimDataReady?.Invoke();
SimulationManager.UpdateMode mode = SimulationManager.UpdateMode.Undefined;
if (ngs != null)
{
mode = ngs.m_updateMode;
}
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "LoadLevelComplete", mode)); // OnLevelLoaded
if (Singleton <TelemetryManager> .exists)
{
Singleton <TelemetryManager> .instance.StartSession(asset?.name, playerScene, mode, SimulationManager.instance.m_metaData);
}
LoadingManager.instance.QueueLoadingAction(LoadingComplete());
knownFastLoads.Add(asset.fullName);
AssetLoader.instance.PrintMem();
}
/// <summary>
/// Checks if all parts of the craft are installed.
/// </summary>
/// <param name="partList">The list of installed parts.</param>
private static void Parts_ScanComplete(List <PartNode> partList)
{
View.ShowProcessingIcon = true;
EventDistributor.InvokeAsyncTaskStarted(Instance);
AsyncTask <bool> .DoWork(() =>
{
Messenger.AddInfo(Messages.MSG_CRAFT_VALIDATION_STARTED);
View.InvokeIfRequired(() => model.Nodes.Clear());
foreach (CraftNode craft in allCrafts)
{
Messenger.AddInfo(string.Format(Messages.MSG_VALIDATING_CRAFT_0, craft.Name));
Dictionary <string, CraftNode> alreadyCheckedParts = new Dictionary <string, CraftNode>();
foreach (CraftNode part in craft.Nodes)
{
string partName = part.Name.Substring(0, part.Name.IndexOf(" ("));
string count = part.Name.Substring(partName.Length);
if (alreadyCheckedParts.ContainsKey(part.Name))
{
if (alreadyCheckedParts[part.Name] != null)
{
part.RelatedPart = alreadyCheckedParts[part.Name].RelatedPart;
part.Name = part.RelatedPart.Title + count;
craft.AddMod(part.RelatedPart.Mod);
}
continue;
}
else
{
bool found = false;
foreach (PartNode instPart in partList)
{
if (instPart.Name.Replace("_", ".") == partName)
{
if (!alreadyCheckedParts.ContainsKey(instPart.Name))
{
alreadyCheckedParts.Add(instPart.Name, part);
}
part.Name = instPart.Title + count;
part.RelatedPart = instPart;
part.AddMod(instPart.Mod);
View.InvokeIfRequired(() => part.RelatedPart.AddRelatedCraft(craft));
craft.AddMod(instPart.Mod);
found = true;
break;
}
}
if (!found)
{
alreadyCheckedParts.Add(part.Name, null);
}
}
}
if (craft.IsInvalidOrHasInvalidChilds)
{
Messenger.AddInfo(string.Format(Messages.MSG_VALIDATING_CRAFT_0_FAILED, craft.Name));
}
else
{
Messenger.AddInfo(string.Format(Messages.MSG_VALIDATING_CRAFT_0_SUCCESSFUL, craft.Name));
}
////craft.SortPartsByDisplayText();
}
return(true);
},
(result, ex) =>
{
View.ShowProcessingIcon = false;
EventDistributor.InvokeAsyncTaskDone(Instance);
PartsTabViewController.ScanComplete -= Parts_ScanComplete;
if (ex != null)
{
MessageBox.Show(View.ParentForm, string.Format(Messages.MSG_ERROR_DURING_CRAFT_VALIDATION_0, ex.Message));
}
else
{
RefreshTreeView();
}
Messenger.AddInfo(Messages.MSG_CRAFT_VALIDATION_DONE);
});
}
public SynchronizeDriveEmptyFolderTask(Account account, string accountName, int priority,
AsyncTask[] parents, AccountFile folder)
: base(account, accountName, priority, parents)
{
Folder = folder;
}
private void Update()
{
//Permission Module Depende On This
AsyncTask.OnUpdate();
}
// creates new user and adds it to the user group
private IEnumerator AddUserToGroup(Face face, string userName, string userInfo)
{
CloudUserManager userManager = CloudUserManager.Instance;
if (texCamShot && userManager && face != null && userName != null && userName.Trim() != string.Empty)
{
SetHintText("Wait...");
yield return(null);
FaceRectangle faceRect = face.faceRectangle;
byte[] imageBytes = texCamShot.EncodeToJPG();
yield return(null);
AsyncTask <Person> task = new AsyncTask <Person>(() => {
return(userManager.AddUserToGroup(userName.Trim(), userInfo, imageBytes, faceRect));
});
task.Start();
yield return(null);
while (task.State == TaskState.Running)
{
yield return(null);
}
// get the resulting person
Person person = task.Result;
if (!string.IsNullOrEmpty(task.ErrorMessage))
{
SetHintText(task.ErrorMessage);
Debug.LogError(task.ErrorMessage);
}
else if (person != null && person.persistedFaceIds != null && person.persistedFaceIds.Length > 0)
{
string faceId = face.faceId;
bool bFaceFound = false;
for (int i = 0; i < faces.Length; i++)
{
if (faces[i].faceId == faceId)
{
if (faces[i].candidate == null || faces[i].candidate.person == null)
{
faces[i].candidate = new Candidate();
faces[i].candidate.personId = person.personId;
faces[i].candidate.confidence = 1f;
faces[i].candidate.person = person;
}
bFaceFound = true;
break;
}
}
if (!bFaceFound)
{
Debug.Log(string.Format("Face {0} not found.", faceId));
}
SetHintText(string.Format("'{0}' created successfully.", userName.Trim()));
ShowIdentityResult();
}
else
{
SetHintText("User could not be created.");
}
}
yield return(null);
}
public void SimpleTest()
{
var Result = new AsyncTask <string>(delegate() { return("Hello"); });
Assert.Equal("Hello", Result.Result);
}
public SynchronizeFileTask(Account account, string accountName, int priority, AsyncTask[] parent, AccountFile sourceFile)
: base(account, accountName, priority, parent)
{
SourceFile = sourceFile;
}
public async AsyncTask StartMonitor(string taskName)
{
await AsyncTask.Run(() => { });
}
void Application_End()
{
_hostClient.Dispose();
AsyncTask.Shutdown();
DependencyResolver.GlobalDispose();
}
/// <summary>
/// Starts a asynchrony download.
/// </summary>
/// <param name="url">Download link</param>
/// <param name="downloadPath">Path and filename to download to.</param>
/// <param name="finished">The finished callback function. (A function with the signature "void FunctionName<bool>(bool result, Exception ex)")</param>
/// <param name="progressChanged">The progress change callback function. (A function with the signature "void FunctionName(int percentage)")</param>
public static void RunDownload(string url, string downloadPath, AsyncResultHandler <bool> finished = null, AsyncProgressChangedHandler progressChanged = null)
{
AsyncTask <bool> asyncTask = new AsyncTask <bool>(url, downloadPath, finished, progressChanged);
asyncTask.RunDownload();
}
public override void Update()
{
if (m_SessionManager == null)
{
return;
}
AsyncTask.OnUpdate();
if (Frame.TrackingState != TrackingState.Tracking)
{
return;
}
if (m_ARCoreSessionConfig.EnablePlaneFinding)
{
Frame.GetPlanes(m_TrackedPlaneBuffer);
foreach (var trackedPlane in m_TrackedPlaneBuffer)
{
BoundedPlane boundedPlane;
if (m_TrackedPlanes.TryGetValue(trackedPlane, out boundedPlane))
{
// remove any subsumed planes
if (trackedPlane.SubsumedBy != null)
{
OnPlaneRemoved(boundedPlane);
m_TrackedPlanes.Remove(trackedPlane);
}
// update any planes with changed extents
else if (PlaneUpdated(trackedPlane, boundedPlane))
{
boundedPlane.center = trackedPlane.Position;
boundedPlane.rotation = trackedPlane.Rotation;
boundedPlane.extents.x = trackedPlane.ExtentX;
boundedPlane.extents.y = trackedPlane.ExtentZ;
m_TrackedPlanes[trackedPlane] = boundedPlane;
OnPlaneUpdated(boundedPlane);
}
}
// add any new planes
else
{
boundedPlane = new BoundedPlane()
{
id = Guid.NewGuid().ToString(),
center = trackedPlane.Position,
rotation = trackedPlane.Rotation,
extents = new Vector2(trackedPlane.ExtentX, trackedPlane.ExtentZ)
};
m_TrackedPlanes.Add(trackedPlane, boundedPlane);
OnPlaneAdded(boundedPlane);
}
}
// Check for planes that were removed from the tracked plane list
List <TrackedPlane> planesToRemove = new List <TrackedPlane>();
foreach (var kvp in m_TrackedPlanes)
{
var trackedPlane = kvp.Key;
if (!m_TrackedPlaneBuffer.Exists(x => x == trackedPlane))
{
OnPlaneRemoved(kvp.Value);
planesToRemove.Add(trackedPlane);
}
}
foreach (var plane in planesToRemove)
{
m_TrackedPlanes.Remove(plane);
}
}
//Update Anchors
foreach (var anchor in m_Anchors)
{
anchor.Key.transform.position = anchor.Value.transform.position;
anchor.Key.transform.rotation = anchor.Value.transform.rotation;
}
}
public DeleteFolderTask(Account account, string accountName, int priority, AsyncTask[] parent, AccountFile folder)
: base(account, accountName, priority, parent, folder)
{
}
public _Runnable_639(Database _enclosing, AsyncTask asyncTask)
{
this._enclosing = _enclosing;
this.asyncTask = asyncTask;
}
public DeleteFileTask(Account account, string accountName, int priority, AsyncTask[] parents, AccountFile file)
: base(account, accountName, priority, parents, file, false)
{
}
private void OnPreviewGraphCompleted(AsyncTask asyncTask)
{
var updateTask = asyncTask as PreviewGraphAsyncTask;
if (updateTask != null)
{
var nodeGuids = updateTask.previewGraphData;
var deltaComputeStateArgs = new DeltaComputeStateEventArgs(nodeGuids,graphExecuted);
OnSetNodeDeltaState(deltaComputeStateArgs);
}
}
/// <summary>
/// This callback method is invoked in the context of ISchedulerThread
/// when UpdateGraphAsyncTask is completed.
/// </summary>
/// <param name="task">The original UpdateGraphAsyncTask instance.</param>
private void OnUpdateGraphCompleted(AsyncTask task)
{
var updateTask = (UpdateGraphAsyncTask)task;
var messages = new Dictionary <Guid, string>();
// Runtime warnings take precedence over build warnings.
foreach (var warning in updateTask.RuntimeWarnings)
{
var message = string.Join(Environment.NewLine, warning.Value.Select(w => w.Message));
messages.Add(warning.Key, message);
}
foreach (var warning in updateTask.BuildWarnings)
{
// If there is already runtime warnings for
// this node, then ignore the build warnings.
// But for cyclic dependency warnings, it is
// easier to understand to report a build warning.
string message = string.Empty;
if (messages.ContainsKey(warning.Key))
{
if (!warning.Value.Any(w => w.ID == ProtoCore.BuildData.WarningID.InvalidStaticCyclicDependency))
{
continue;
}
messages.Remove(warning.Key);
message = string.Join("\n", warning.Value.
Where(w => w.ID == ProtoCore.BuildData.WarningID.InvalidStaticCyclicDependency).
Select(w => w.Message));
}
else
{
message = string.Join("\n", warning.Value.Select(w => w.Message));
}
if (!string.IsNullOrEmpty(message))
{
messages.Add(warning.Key, message);
}
}
var workspace = updateTask.TargetedWorkspace;
foreach (var message in messages)
{
var guid = message.Key;
var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid);
if (node == null)
{
continue;
}
using (node.PropertyChangeManager.SetPropsToSuppress(nameof(NodeModel.ToolTipText), nameof(NodeModel.State)))
{
node.Warning(message.Value); // Update node warning message.
}
}
// Notify listeners (optional) of completion.
RunSettings.RunEnabled = true; // Re-enable 'Run' button.
executingTask = false; // setting back to false
//set the node execution preview to false;
OnSetNodeDeltaState(new DeltaComputeStateEventArgs(new List <Guid>(), graphExecuted));
// This method is guaranteed to be called in the context of
// ISchedulerThread (for Revit's case, it is the idle thread).
// Dispatch the failure message display for execution on UI thread.
//
EvaluationCompletedEventArgs e = task.Exception == null || IsTestMode
? new EvaluationCompletedEventArgs(true, messages.Keys, null)
: new EvaluationCompletedEventArgs(true, messages.Keys, task.Exception);
EvaluationCount++;
OnEvaluationCompleted(e);
if (EngineController.IsDisposed)
{
return;
}
EngineController.ReconcileTraceDataAndNotify();
// Refresh values of nodes that took part in update.
var nodes = new HashSet <NodeModel>(updateTask.ExecutedNodes.Concat(updateTask.ModifiedNodes));
foreach (var executedNode in nodes)
{
executedNode.RequestValueUpdate(EngineController);
}
scheduler.Tasks.AllComplete(_ =>
{
OnRefreshCompleted(e);
});
}
public EmptyTask(Account account, string accountName, int priority, AsyncTask[] parents, AsyncTaskParentsMode parentsMode = AsyncTaskParentsMode.CancelIfAnyErrorOrCanceled)
: base(account, accountName, priority, parents, parentsMode)
{
}
public static void Issue(AsyncTask task)
{
AsyncTaskRunner(task);
}
public virtual Stream ProcessAsynchronously(Stream requestStream)
{
DateTime now = DateTime.Now;
string asyncToken = now.Ticks.ToString(CultureInfo.InvariantCulture);
AsyncTask asyncTask = null;
if (requestStream == null)
{
asyncTask = new AsyncTask(this, this.CreateRequestMessage(null), now.AddSeconds(AsyncTask.DefaultDuration));
}
else
{
StreamPipe requestPipe = new StreamPipe();
using (requestPipe.WriteStream)
{
requestStream.CopyTo(requestPipe.WriteStream); // read the input stream to memory
}
var requestMessage = this.CreateRequestMessage(requestPipe.ReadStream);
asyncTask = new AsyncTask(this, requestMessage, now.AddSeconds(AsyncTask.DefaultDuration));
}
AsyncTask.AddTask(asyncToken, asyncTask);
StreamPipe responsePipe = new StreamPipe();
var responseMessage = new ODataResponseMessage(responsePipe.WriteStream, 202); //202 Accepted
responseMessage.PreferenceAppliedHeader().RespondAsync = true;
ResponseWriter.WriteAsyncPendingResponse(responseMessage, asyncToken);
return responsePipe.ReadStream;
}
/// <summary>
/// Scans the KSP install directory and sub directories for *.craft files.
/// </summary>
private static void ScanDir()
{
allModFilter.Clear();
allModFilter.Add(All);
allModFilter.Add(Squad);
View.SelectedModFilter = All;
model.Nodes.Clear();
View.ShowProcessingIcon = true;
EventDistributor.InvokeAsyncTaskStarted(Instance);
AsyncTask <bool> .DoWork(() =>
{
Messenger.AddInfo(Messages.MSG_PART_SCAN_STARTED);
// Get part.cfg files from GameData folder.
string gameDatePath = KSPPathHelper.GetPath(KSPPaths.GameData);
string[] files = Directory.GetFiles(gameDatePath, EXTENSION_CFG, SearchOption.AllDirectories);
// Get part.cfg files from additional folders.
string partsPath = KSPPathHelper.GetPath(KSPPaths.Parts);
string[] addPaths = new[] { partsPath };
foreach (var path in addPaths)
{
string[] files2 = Directory.GetFiles(path, EXTENSION_CFG, SearchOption.AllDirectories);
int oldLength = files.Length;
Array.Resize <string>(ref files, oldLength + files2.Length);
Array.Copy(files2, 0, files, oldLength, files2.Length);
}
// Create PartNodes from each file.
var nodes = new List <PartNode>();
if (files.Length > 0)
{
foreach (string file in files)
{
Messenger.AddInfo(string.Format(Messages.MSG_SCAN_FILE_0_FOR_PARTS, file));
var newNodes = CreatePartNodes(file);
foreach (var newNode in newNodes)
{
if (newNode != null && !string.IsNullOrEmpty(newNode.Name) && !nodes.Contains(newNode))
{
nodes.Add(newNode);
}
}
}
}
else
{
Messenger.AddInfo(string.Format(Messages.MSG_NO_PARTCFG_FOUND_0, gameDatePath));
}
allNodes.Clear();
foreach (PartNode node in nodes)
{
allNodes.Add(node);
}
Messenger.AddInfo(Messages.MSG_PART_SCAN_DONE);
return(true);
},
(result, ex) =>
{
View.ShowProcessingIcon = false;
EventDistributor.InvokeAsyncTaskDone(Instance);
if (ex != null)
{
Messenger.AddError(string.Format(Messages.MSG_ERROR_DURING_PART_READING_0, ex.Message), ex);
}
else
{
RefreshTreeView();
}
if (ScanComplete != null)
{
ScanComplete(Parts);
}
});
}
/// <summary>
/// This function calls the passed task function asynchronously.
/// </summary>
/// <param name="task">The task function to execute asynchrony. (A function with the signature "T_RETURN_VALUE FunctionName<T_RETURN_VALUE>()")</param>
/// <param name="finished">The finished callback function. (A function with the signature "void FunctionName<T_RETURN_VALUE>(T_RETURN_VALUE result, Exception ex)")</param>
/// <param name="progressChanged">The progress change callback function. (A function with the signature "void FunctionName(int percentage)")</param>
public static void DoWork(AsyncHandler <T_RETURN_VALUE> task, AsyncResultHandler <T_RETURN_VALUE> finished = null, AsyncProgressChangedHandler progressChanged = null)
{
AsyncTask <T_RETURN_VALUE> asyncTask = new AsyncTask <T_RETURN_VALUE>(task, finished, progressChanged);
asyncTask.Run();
}
private void test()
{
Debug.Log("begin test");
/*
AStarPathFinder pathFinder = new AStarPathFinder(mapData, new GameMoveCost(),
new AStarHCostHuffman()
//new AStarHCostEuclidean()
//new AStarHCostChebyshev()
);
IList<Vec2<short>> path = new List<Vec2<short>>();
Vec2<short> startPos = new Vec2<short>(3, 55), endPos = new Vec2<short>(70, 25);
int err = (int)pathFinder.findPath(0, ref startPos, ref endPos, path);
Debug.Log("found path with err=" + err);
if (err == 0)
printPath(path);
//*/
//*
_num = 10000;
for (int i = 0; i < _num; ++i)
{
AStarPathFinder pathFinder = new AStarPathFinder(mapData, new GameMoveCost(),
new AStarHCostHuffman()
//new AStarHCostEuclidean()
//new AStarHCostChebyshev()
);
AsyncTask task = new AsyncTask(i + 1);
task.getParamDict().Add(0, pathFinder);
task.getParamDict().Add(1, i);
task.onHandleTask = new OnHandleTask(onHandleTestTask);
task.onCompleteTask = new OnCompleteTask(onCompleteTestTask);
_dispatcher.dispatch(task);
}
//*/
Debug.Log("end test");
}
protected override TaskMergeInstruction CanMergeWithCore(AsyncTask otherTask)
{
var theOtherTask = otherTask as UpdateRenderPackageAsyncTask;
if (theOtherTask == null)
return base.CanMergeWithCore(otherTask);
// If the two UpdateRenderPackageAsyncTask are for different nodes,
// then there is no comparison to be made, keep both the tasks.
//
if (nodeGuid != theOtherTask.nodeGuid)
return TaskMergeInstruction.KeepBoth;
// Comparing to another NotifyRenderPackagesReadyAsyncTask, the one
// that gets scheduled more recently stay, while the earlier one
// gets dropped. If this task has a higher tick count, keep this.
//
if (ScheduledTime.TickCount > theOtherTask.ScheduledTime.TickCount)
return TaskMergeInstruction.KeepThis;
return TaskMergeInstruction.KeepOther; // Otherwise, keep the other.
}
public override void Update()
{
if (m_ARCoreSession == null)
{
return;
}
AsyncTask.OnUpdate();
if (Session.Status != SessionStatus.Tracking)
{
return;
}
if (m_ARCoreSessionConfig.EnablePlaneFinding)
{
Session.GetTrackables <DetectedPlane>(m_DetectedPlaneBuffer, TrackableQueryFilter.All);
foreach (var detectedPlane in m_DetectedPlaneBuffer)
{
BoundedPlane boundedPlane;
if (m_DetectedPlanes.TryGetValue(detectedPlane, out boundedPlane))
{
// remove any subsumed planes
if (detectedPlane.SubsumedBy != null)
{
OnPlaneRemoved(boundedPlane);
m_DetectedPlanes.Remove(detectedPlane);
}
// update any planes with changed extents
else if (PlaneUpdated(detectedPlane, boundedPlane))
{
boundedPlane.center = detectedPlane.CenterPose.position;
boundedPlane.rotation = detectedPlane.CenterPose.rotation;
boundedPlane.extents.x = detectedPlane.ExtentX;
boundedPlane.extents.y = detectedPlane.ExtentZ;
m_DetectedPlanes[detectedPlane] = boundedPlane;
OnPlaneUpdated(boundedPlane);
}
}
// add any new planes
else
{
boundedPlane = new BoundedPlane()
{
id = Guid.NewGuid().ToString(),
center = detectedPlane.CenterPose.position,
rotation = detectedPlane.CenterPose.rotation,
extents = new Vector2(detectedPlane.ExtentX, detectedPlane.ExtentZ)
};
m_DetectedPlanes.Add(detectedPlane, boundedPlane);
OnPlaneAdded(boundedPlane);
}
}
// Check for planes that were removed from the detected plane list
List <DetectedPlane> planesToRemove = new List <DetectedPlane>();
foreach (var kvp in m_DetectedPlanes)
{
var detectedPlane = kvp.Key;
if (!m_DetectedPlaneBuffer.Exists(x => x == detectedPlane))
{
OnPlaneRemoved(kvp.Value);
planesToRemove.Add(detectedPlane);
}
}
foreach (var plane in planesToRemove)
{
m_DetectedPlanes.Remove(plane);
}
}
//Update Anchors
foreach (var anchor in m_Anchors)
{
anchor.Key.transform.position = anchor.Value.transform.position;
anchor.Key.transform.rotation = anchor.Value.transform.rotation;
}
}
// performs face detection
private IEnumerator DoFaceDetection()
{
// get the image to detect
Face[] faces = null;
Texture2D texCamShot = null;
if (cameraShot)
{
texCamShot = (Texture2D)cameraShot.texture;
SetHintText("Wait...");
}
// get the face manager instance
CloudFaceManager faceManager = CloudFaceManager.Instance;
if (!faceManager)
{
SetHintText("Check if the FaceManager component exists in the scene.");
}
else if (texCamShot)
{
byte[] imageBytes = texCamShot.EncodeToJPG();
yield return(null);
//faces = faceManager.DetectFaces(texCamShot);
AsyncTask <Face[]> taskFace = new AsyncTask <Face[]>(() => {
return(faceManager.DetectFaces(imageBytes));
});
taskFace.Start();
yield return(null);
while (taskFace.State == TaskState.Running)
{
yield return(null);
}
if (string.IsNullOrEmpty(taskFace.ErrorMessage))
{
faces = taskFace.Result;
if (faces != null && faces.Length > 0)
{
// stick to detected face rectangles
FaceRectangle[] faceRects = new FaceRectangle[faces.Length];
for (int i = 0; i < faces.Length; i++)
{
faceRects[i] = faces[i].faceRectangle;
}
yield return(null);
// get the emotions of the faces
if (recognizeEmotions)
{
//Emotion[] emotions = faceManager.RecognizeEmotions(texCamShot, faceRects);
AsyncTask <Emotion[]> taskEmot = new AsyncTask <Emotion[]>(() => {
return(faceManager.RecognizeEmotions(imageBytes, faceRects));
});
taskEmot.Start();
yield return(null);
while (taskEmot.State == TaskState.Running)
{
yield return(null);
}
if (string.IsNullOrEmpty(taskEmot.ErrorMessage))
{
Emotion[] emotions = taskEmot.Result;
int matched = faceManager.MatchEmotionsToFaces(ref faces, ref emotions);
if (matched != faces.Length)
{
Debug.Log(string.Format("Matched {0}/{1} emotions to {2} faces.", matched, emotions.Length, faces.Length));
}
}
else
{
SetHintText(taskEmot.ErrorMessage);
}
}
CloudFaceManager.DrawFaceRects(texCamShot, faces, FaceDetectionUtils.FaceColors);
//SetHintText("Click on the camera image to make a shot");
SetHintText(hintMessage);
SetResultText(faces);
}
else
{
SetHintText("No face(s) detected.");
}
}
else
{
SetHintText(taskFace.ErrorMessage);
}
}
yield return(null);
}
//网络初始化
public override void fullfillByNetwork(BaseResponse response)
{
if (response != null && response.status != BaseResponse.ERROR)
{
LoginResponse loginResp = response as LoginResponse;
if (loginResp != null && loginResp.data != null && loginResp.data.floor != null)
{
InitData();
lastFloorId = loginResp.data.floor.end;
if (lastFloorId == 0)
{
lastFloorId = startFloorID;
}
DungeonsInfo dungeonse = loginResp.data.floor;
if (dungeonse != null && dungeonse.pro != null)
{
foreach (int[] oneFloor in dungeonse.pro)
{
int floorId = oneFloor[0];
int star = oneFloor[1];
NewFloor floor = null;
if (FloorList.TryGetValue(floorId, out floor))
{
floor.star = star;
}
}
}
//设置各个小关卡的状态
NewFloor floordata = null;
int floorid = startFloorID;
for (; floorid <= lastFloorId; floorid++)
{
if (FloorList.TryGetValue(floorid, out floordata))
{
floordata.state = NewFloorState.Pass;
}
}
Debug.Log("CurrentID=" + floorid.ToString());
//设置开启的下一关<当前关卡>
if (FloorList.TryGetValue(floorid, out floordata))
{
floordata.state = NewFloorState.Current;
}
//开启PVE副本倒计时
if (loginResp.data.explorDoors != null)
{
explorDoors = loginResp.data.explorDoors;
AsyncTask.QueueOnMainThread(() =>
{
JCPVETimerManager.Instance.AutoOpenPVESystemTimer();
});
}
Analysis();
// AnaylizeFloor();
}
//挑战次数和重置次数
if (loginResp != null && loginResp.data != null && loginResp.data.doorDayStatus != null)
{
for (int i = 0; i < loginResp.data.doorDayStatus.Length; i++)
{
DoorDayStatus doorStatus = loginResp.data.doorDayStatus [i];
NewFloor newflr = GetFloorData(doorStatus.doorId);
if (newflr != null)
{
newflr.passTimes = doorStatus.passCount;
newflr.resetTimes = doorStatus.resetCount;
}
else
{
RED.LogWarning(doorStatus.doorId + "not find floor data");
}
}
}
}
//更新招募和位置2是否解锁
PlayerManager playerMgr = Core.Data.playerManager;
if (playerMgr.RTData != null && playerMgr.RTData.curTeam != null)
{
Core.Data.BuildingManager.ZhaoMuUnlock = (playerMgr.RTData.curTeam.getMember(1) != null); //|| lastFloorId >= 60104);
}
}
public WaitForAsynTaskCompletionYieldInstruction(AsyncTask <T> task)
{
m_task = task;
}
/// <summary>
/// This callback method is invoked in the context of ISchedulerThread
/// when UpdateGraphAsyncTask is completed.
/// </summary>
/// <param name="task">The original UpdateGraphAsyncTask instance.</param>
private void OnUpdateGraphCompleted(AsyncTask task)
{
var updateTask = (UpdateGraphAsyncTask)task;
var messages = new Dictionary <Guid, string>();
// Runtime warnings take precedence over build warnings.
foreach (var warning in updateTask.RuntimeWarnings)
{
var message = string.Join("\n", warning.Value.Select(w => w.Message));
messages.Add(warning.Key, message);
}
foreach (var warning in updateTask.BuildWarnings)
{
// If there is already runtime warnings for
// this node, then ignore the build warnings.
if (messages.ContainsKey(warning.Key))
{
continue;
}
var message = string.Join("\n", warning.Value.Select(w => w.Message));
messages.Add(warning.Key, message);
}
var workspace = updateTask.TargetedWorkspace;
foreach (var message in messages)
{
var guid = message.Key;
var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid);
if (node == null)
{
continue;
}
node.Warning(message.Value); // Update node warning message.
}
// Refresh values of nodes that took part in update.
foreach (var modifiedNode in updateTask.ModifiedNodes)
{
modifiedNode.RequestValueUpdateAsync(scheduler, EngineController);
}
foreach (var node in Nodes)
{
node.ClearDirtyFlag();
}
// Notify listeners (optional) of completion.
RunSettings.RunEnabled = true; // Re-enable 'Run' button.
//set the node execution preview to false;
OnSetNodeDeltaState(new DeltaComputeStateEventArgs(new List <Guid>(), graphExecuted));
// This method is guaranteed to be called in the context of
// ISchedulerThread (for Revit's case, it is the idle thread).
// Dispatch the failure message display for execution on UI thread.
//
EvaluationCompletedEventArgs e = task.Exception == null || IsTestMode
? new EvaluationCompletedEventArgs(true)
: new EvaluationCompletedEventArgs(true, task.Exception);
EvaluationCount++;
OnEvaluationCompleted(e);
}
public Future RunAsync(AsyncTask asyncTask)
{
return GetManager().RunAsync(new _Runnable_639(this, asyncTask));
}
private void frmApplication_Shown(object sender, EventArgs e)
{
lblName.Text = lblRelatedColumn.Text = lblRelatedTo.Text = lblRelationState.Text = "";
Trunc = new TableTruncator(Connection);
AsyncTask<string, string, string> task = new AsyncTask<string, string, string>(this);
task.doInBackground = delegate(string[] param)
{
task.PublishProgress("Connecting to the SQL Server");
Connection.Connect();
task.PublishProgress("Gathering & inspecting tables...");
Trunc.Initialize();
return "Ready";
};
task.onProgressUpdate = delegate(string[] param)
{
lblStatus.Text = param[0];
};
task.onPostExecute = delegate(string result)
{
lblStatus.Text = result;
List<string> Tables = Trunc.GetTables();
TreeNode Root = tvTables.Nodes.Add(Setting.Database);
foreach (string table in Tables)
{
Root.Nodes.Add(table);
}
};
task.Execute();
}
// performs user recognition
private IEnumerator DoUserRecognition()
{
// get the image to detect
faces = null;
texCamShot = null;
if (cameraShot)
{
texCamShot = (Texture2D)cameraShot.texture;
SetHintText("Wait...");
}
// get the user manager instance
CloudUserManager userManager = CloudUserManager.Instance;
if (!userManager)
{
if (hintText)
{
hintText.text = "Check if the CloudFaceManager and CloudUserManager components exist in the scene.";
}
}
else if (texCamShot)
{
byte[] imageBytes = texCamShot.EncodeToJPG();
yield return(null);
AsyncTask <bool> taskIdentify = new AsyncTask <bool>(() => {
bool bSuccess = userManager.IdentifyUsers(imageBytes, ref faces, ref results);
return(bSuccess);
});
taskIdentify.Start();
yield return(null);
while (taskIdentify.State == TaskState.Running)
{
yield return(null);
}
if (string.IsNullOrEmpty(taskIdentify.ErrorMessage))
{
if (taskIdentify.Result)
{
CloudFaceManager.DrawFaceRects(texCamShot, faces, FaceDetectionUtils.FaceColors);
yield return(null);
SetHintText("Select user to login:"******"No users detected.");
}
// show the identified users
ShowIdentityResult();
}
else
{
SetHintText(taskIdentify.ErrorMessage);
}
}
yield return(null);
}
/// <inheritdoc />
public void EndProcessRequest(IAsyncResult result)
{
AsyncTask task = (AsyncTask)result;
task.EndTask();
}
/// <summary>
/// This callback method is invoked in the context of ISchedulerThread
/// when UpdateGraphAsyncTask is completed.
/// </summary>
/// <param name="task">The original UpdateGraphAsyncTask instance.</param>
private void OnUpdateGraphCompleted(AsyncTask task)
{
var updateTask = (UpdateGraphAsyncTask)task;
var messages = new Dictionary<Guid, string>();
// Runtime warnings take precedence over build warnings.
foreach (var warning in updateTask.RuntimeWarnings)
{
var message = string.Join("\n", warning.Value.Select(w => w.Message));
messages.Add(warning.Key, message);
}
foreach (var warning in updateTask.BuildWarnings)
{
// If there is already runtime warnings for
// this node, then ignore the build warnings.
// But for cyclic dependency warnings, it is
// easier to understand to report a build warning.
string message = string.Empty;
if (messages.ContainsKey(warning.Key))
{
if (!warning.Value.Any(w => w.ID == ProtoCore.BuildData.WarningID.kInvalidStaticCyclicDependency))
continue;
messages.Remove(warning.Key);
message = string.Join("\n", warning.Value.
Where(w => w.ID == ProtoCore.BuildData.WarningID.kInvalidStaticCyclicDependency).
Select(w => w.Message));
}
else
{
message = string.Join("\n", warning.Value.Select(w => w.Message));
}
if (!string.IsNullOrEmpty(message))
{
messages.Add(warning.Key, message);
}
}
var workspace = updateTask.TargetedWorkspace;
foreach (var message in messages)
{
var guid = message.Key;
var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid);
if (node == null)
continue;
node.Warning(message.Value); // Update node warning message.
}
// Notify listeners (optional) of completion.
RunSettings.RunEnabled = true; // Re-enable 'Run' button.
//set the node execution preview to false;
OnSetNodeDeltaState(new DeltaComputeStateEventArgs(new List<Guid>(), graphExecuted));
// This method is guaranteed to be called in the context of
// ISchedulerThread (for Revit's case, it is the idle thread).
// Dispatch the failure message display for execution on UI thread.
//
EvaluationCompletedEventArgs e = task.Exception == null || IsTestMode
? new EvaluationCompletedEventArgs(true)
: new EvaluationCompletedEventArgs(true, task.Exception);
EvaluationCount ++;
OnEvaluationCompleted(e);
if (EngineController.IsDisposed) return;
EngineController.ReconcileTraceDataAndNotify();
// Refresh values of nodes that took part in update.
foreach (var modifiedNode in updateTask.ModifiedNodes)
{
modifiedNode.RequestValueUpdateAsync(scheduler, EngineController);
}
scheduler.Tasks.AllComplete(_ =>
{
OnRefreshCompleted(e);
});
}
public IEnumerator LoadLevelCoroutine(Package.Asset asset, string playerScene, string uiScene, SimulationMetaData ngs)
{
string scene;
yield return(null);
LoadingManager.instance.SetSceneProgress(0f);
Util.InvokeVoid(LoadingManager.instance, "PreLoadLevel");
AsyncTask task = Singleton <SimulationManager> .instance.AddAction("Loading", (IEnumerator)Util.Invoke(LoadingManager.instance, "LoadSimulationData", asset, ngs));
LoadSaveStatus.activeTask = task;
if (!LoadingManager.instance.LoadingAnimationComponent.AnimationLoaded)
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading("LoadingAnimation");
yield return(Application.LoadLevelAdditiveAsync("LoadingAnimation"));
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if (LoadingManager.instance.m_loadedEnvironment != null) // loading from in-game
{
while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_158
{
yield return(null);
}
if (Singleton <SimulationManager> .instance.m_metaData == null)
{
Singleton <SimulationManager> .instance.m_metaData = new SimulationMetaData();
Singleton <SimulationManager> .instance.m_metaData.m_environment = "Sunny";
Singleton <SimulationManager> .instance.m_metaData.Merge(ngs);
}
string mapThemeName = Singleton <SimulationManager> .instance.m_metaData.m_MapThemeMetaData?.name;
if (Singleton <SimulationManager> .instance.m_metaData.m_environment == LoadingManager.instance.m_loadedEnvironment && mapThemeName == LoadingManager.instance.m_loadedMapTheme)
{
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded"));
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady"));
}
else
{
Util.InvokeVoid(LoadingManager.instance, "DestroyAllPrefabs");
LoadingManager.instance.m_loadedEnvironment = null;
LoadingManager.instance.m_loadedMapTheme = null;
}
}
if (LoadingManager.instance.m_loadedEnvironment == null) // IL_290
{
AsyncOperation op;
if (!string.IsNullOrEmpty(playerScene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(playerScene);
op = Application.LoadLevelAsync(playerScene);
while (!op.isDone) // IL_312
{
LoadingManager.instance.SetSceneProgress(op.progress * 0.1f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_34F
{
yield return(null);
}
if (Singleton <SimulationManager> .instance.m_metaData == null)
{
Singleton <SimulationManager> .instance.m_metaData = new SimulationMetaData();
Singleton <SimulationManager> .instance.m_metaData.m_environment = "Sunny";
Singleton <SimulationManager> .instance.m_metaData.Merge(ngs);
}
LoadingManager.instance.m_supportsExpansion[0] = (bool)Util.Invoke(LoadingManager.instance, "DLC", 369150u);
LoadingManager.instance.m_supportsExpansion[1] = (bool)Util.Invoke(LoadingManager.instance, "DLC", 420610u);
bool isWinter = Singleton <SimulationManager> .instance.m_metaData.m_environment == "Winter";
if (isWinter && !LoadingManager.instance.m_supportsExpansion[1])
{
Singleton <SimulationManager> .instance.m_metaData.m_environment = "Sunny";
isWinter = false;
}
scene = (string)Util.Invoke(LoadingManager.instance, "GetLoadingScene");
if (!string.IsNullOrEmpty(scene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_4D0
{
LoadingManager.instance.SetSceneProgress(0.1f + op.progress * 0.03f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
scene = Singleton <SimulationManager> .instance.m_metaData.m_environment + "Prefabs"; // IL_4F0
if (!string.IsNullOrEmpty(scene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_585
{
LoadingManager.instance.SetSceneProgress(0.13f + op.progress * 0.5f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if ((bool)Util.Invoke(LoadingManager.instance, "DLC", 1u)) // IL_5A5
{
scene = isWinter ? "WinterLoginPackPrefabs" : "LoginPackPrefabs";
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_63C
{
LoadingManager.instance.SetSceneProgress(0.63f + op.progress * 0.02f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if ((bool)Util.Invoke(LoadingManager.instance, "DLC", 340160u)) // IL_65C
{
scene = isWinter ? "WinterPreorderPackPrefabs" : "PreorderPackPrefabs";
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_6F8
{
LoadingManager.instance.SetSceneProgress(0.65f + op.progress * 0.02f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
scene = isWinter ? "WinterSignupPackPrefabs" : "SignupPackPrefabs"; // IL_718
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_79F
{
LoadingManager.instance.SetSceneProgress(0.67f + op.progress * 0.01f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
if ((bool)Util.Invoke(LoadingManager.instance, "DLC", 346791u))
{
scene = "DeluxePackPrefabs";
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_846
{
LoadingManager.instance.SetSceneProgress(0.68f + op.progress * 0.02f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if (Steam.IsAppOwned(238370u)) // IL_866
{
scene = "MagickaPackPrefabs";
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_8ED
{
LoadingManager.instance.SetSceneProgress(0.7f + op.progress * 0.01f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if (LoadingManager.instance.m_supportsExpansion[0]) // IL_90D
{
scene = isWinter ? "WinterExpansion1Prefabs" : "Expansion1Prefabs";
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_9A6
{
LoadingManager.instance.SetSceneProgress(0.71f + op.progress * 0.02f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if (LoadingManager.instance.m_supportsExpansion[1]) // IL_9C6
{
scene = "Expansion2Prefabs";
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_A4A
{
LoadingManager.instance.SetSceneProgress(0.73f + op.progress * 0.02f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
Package.Asset europeanStyles = PackageManager.FindAssetByName("System." + DistrictStyle.kEuropeanStyleName); // IL_A6A
if (europeanStyles != null && europeanStyles.isEnabled)
{
if (Singleton <SimulationManager> .instance.m_metaData.m_environment.Equals("Europe"))
{
scene = "EuropeNormalPrefabs";
}
else
{
scene = "EuropeStylePrefabs";
}
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_B45
{
LoadingManager.instance.SetSceneProgress(0.75f + op.progress * 0.02f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
// LoadingManager.instance.QueueLoadingAction((IEnumerator) Util.Invoke(LoadingManager.instance, "LoadCustomContent")); // IL_B65
LoadingManager.instance.QueueLoadingAction(AssetLoader.instance.LoadCustomContent());
RenderManager.Managers_CheckReferences();
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded"));
RenderManager.Managers_InitRenderData();
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady"));
simulationFailed = HasFailed(task);
// Performance optimization: do not load scenes while custom assets are loading.
while (!AssetLoader.instance.hasFinished)
{
yield return(null);
}
scene = Singleton <SimulationManager> .instance.m_metaData.m_environment + "Properties";
if (!string.IsNullOrEmpty(scene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
op = Application.LoadLevelAdditiveAsync(scene);
while (!op.isDone) // IL_C47
{
LoadingManager.instance.SetSceneProgress(0.77f + op.progress * 0.11f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
if (!simulationFailed)
{
simulationFailed = HasFailed(task);
}
if (!string.IsNullOrEmpty(uiScene)) // IL_C67
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(uiScene);
op = Application.LoadLevelAdditiveAsync(uiScene);
while (!op.isDone) // IL_CDE
{
LoadingManager.instance.SetSceneProgress(0.88f + op.progress * 0.11f);
yield return(null);
}
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
LoadingManager.instance.m_loadedEnvironment = Singleton <SimulationManager> .instance.m_metaData.m_environment; // IL_CFE
LoadingManager.instance.m_loadedMapTheme = Singleton <SimulationManager> .instance.m_metaData.m_MapThemeMetaData?.name;
}
else
{
scene = (string)Util.Invoke(LoadingManager.instance, "GetLoadingScene");
if (!string.IsNullOrEmpty(scene))
{
LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene);
yield return(Application.LoadLevelAdditiveAsync(scene));
LoadingManager.instance.m_loadingProfilerScenes.EndLoading();
}
}
LoadingManager.instance.SetSceneProgress(1f); // IL_DBF
if (!simulationFailed)
{
simulationFailed = HasFailed(task);
}
while (!task.completedOrFailed) // IL_DED
{
yield return(null);
}
LoadingManager.instance.m_simulationDataLoaded = LoadingManager.instance.m_metaDataLoaded;
LoadingManager.SimulationDataReadyHandler SimDataReady = Util.Get(LoadingManager.instance, "m_simulationDataReady") as LoadingManager.SimulationDataReadyHandler;
SimDataReady?.Invoke();
SimulationManager.UpdateMode mode = SimulationManager.UpdateMode.Undefined;
if (ngs != null)
{
mode = ngs.m_updateMode;
}
LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "LoadLevelComplete", mode));
if (Singleton <TelemetryManager> .exists)
{
Singleton <TelemetryManager> .instance.StartSession(asset?.name, playerScene, mode, Singleton <SimulationManager> .instance.m_metaData);
}
}
/// <summary>
/// Scans the KSP install directory and sub directories for *.craft files.
/// </summary>
private static void ScanDir()
{
View.ShowProcessingIcon = true;
EventDistributor.InvokeAsyncTaskStarted(Instance);
ResetView();
AsyncTask <bool> .DoWork(() =>
{
Messenger.AddInfo(Messages.MSG_CRAFT_SCAN_STARTED);
// Get *.craft files from GameData folder.
string gameDatePath = KSPPathHelper.GetPath(KSPPaths.GameData);
string[] files = Directory.GetFiles(gameDatePath, EXTENSION_CRAFT, SearchOption.AllDirectories);
// Get *.craft files from additional folders.
string path1 = KSPPathHelper.GetPath(KSPPaths.VAB);
string path2 = KSPPathHelper.GetPath(KSPPaths.SPH);
string[] addPaths = new[] { path1, path2 };
foreach (var path in addPaths)
{
string[] files2 = Directory.GetFiles(path, EXTENSION_CRAFT, SearchOption.AllDirectories);
int oldLength = files.Length;
Array.Resize <string>(ref files, oldLength + files2.Length);
Array.Copy(files2, 0, files, oldLength, files2.Length);
}
// Create CraftNodes from each file.
var nodes = new List <CraftNode>();
if (files.Length > 0)
{
foreach (string file in files)
{
Messenger.AddInfo(string.Format(Messages.MSG_SCAN_FILE_0_FOR_CRAFTS, file));
var newNodes = CreateCraftEntry(file);
foreach (var newNode in newNodes)
{
if (newNode != null && !string.IsNullOrEmpty(newNode.Name) && !nodes.Contains(newNode))
{
nodes.Add(newNode);
}
}
}
}
else
{
Messenger.AddInfo(string.Format(Messages.MSG_NO_CRAFTCFG_FOUND_0, gameDatePath));
}
allCrafts.Clear();
foreach (CraftNode node in nodes)
{
allCrafts.Add(node);
}
Messenger.AddInfo(Messages.MSG_CRAFT_SCAN_DONE);
return(true);
},
(bool result, Exception ex) =>
{
View.ShowProcessingIcon = false;
EventDistributor.InvokeAsyncTaskDone(Instance);
if (ex != null)
{
Messenger.AddError(string.Format(Messages.MSG_ERROR_DURING_CRAFT_READING_0, ex.Message), ex);
}
else
{
RefreshTreeView();
ValidateCrafts();
}
});
}
private void ConfigAsyncTask()
{
mAsyncTask = new AsyncTask(this);
}
/// <summary>
/// Starts a async download of a mod from KSP Spaceport.
/// </summary>
/// <param name="modInfo"></param>
/// <param name="finished"></param>
/// <param name="progressChanged"></param>
public static void DownloadModAsync(string downloadURL, ref ModInfo modInfo, AsyncResultHandler<bool> finished = null, AsyncProgressChangedHandler progressChanged = null)
{
// get save path
int start = downloadURL.LastIndexOf("/") + 1;
string filename = downloadURL.Substring(start, downloadURL.Length - start);
modInfo.LocalPath = Path.Combine(downloadURL, filename);
AsyncTask<bool> asyncJob = new AsyncTask<bool>();
asyncJob.SetDownloadCallbackFunctions(modInfo.SpaceportURL, modInfo.LocalPath, finished, progressChanged);
asyncJob.RunDownload(); ;
}
public Future RunAsync(string databaseName, AsyncTask function)
{
Database database = GetDatabase(databaseName);
return(RunAsync(new _Runnable_342(function, database)));
}
protected override TaskMergeInstruction CanMergeWithCore(AsyncTask otherTask)
{
var theOtherTask = otherTask as UpdateGraphAsyncTask;
if (theOtherTask == null)
return base.CanMergeWithCore(otherTask);
if (theOtherTask.IsScheduledAfter(this) && theOtherTask.Contains(this))
return TaskMergeInstruction.KeepOther;
else if (this.IsScheduledAfter(theOtherTask) && this.Contains(theOtherTask))
return TaskMergeInstruction.KeepThis;
else
return TaskMergeInstruction.KeepBoth;
}
public _Runnable_342(AsyncTask function, Database database)
{
this.function = function;
this.database = database;
}
public override void Update()
{
if (m_ARCoreSession == null)
{
return;
}
AsyncTask.OnUpdate();
if (lastFrameTrackingState == SessionStatus.Tracking && Session.Status != SessionStatus.Tracking && !_trackingLostCountdownInProgress)
{
//Debounce - if we regain tracking within a second, just send it as a TrackingJumped event - less disruptive that completely losing tracking.
Mapbox.Unity.Utilities.Console.Instance.Log("Tracking lost (changed from " + lastFrameTrackingState + " to " + Session.Status + "), starting countdown timer", "yellow");
_trackingLostCountdownInProgress = true;
_trackingLostLastPose = Frame.Pose;
_trackingLostTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
}
if (Session.Status != lastFrameTrackingState && Session.Status == SessionStatus.Tracking)
{
if (!_trackingLostCountdownInProgress)
{
OnTrackingStarted(Frame.Pose);
}
else
{
//Regained tracking within a second, send a jump.
long timeNow = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
Mapbox.Unity.Utilities.Console.Instance.Log("Tracking recovered after " + (timeNow - _trackingLostTime) + "ms, sending a TrackingJump instead of TrackingLost & TrackingStart. ", "yellow");
OnTrackingJumped(Frame.Pose, lastFramePose);
_trackingLostCountdownInProgress = false;
_trackingLostLastPose = new Pose();
_trackingLostTime = 0;
}
}
if (lastFrameTrackingState == SessionStatus.Tracking && //Do not fire "OnTrackingJumped" on the first frame when tracking just started (OnTrackingStarted will fire instead, see above).
Session.Status == SessionStatus.Tracking &&
((Frame.Pose.position - lastFramePose.position).magnitude > 1 ||
Quaternion.Angle(Frame.Pose.rotation, lastFramePose.rotation) > 30)
)
{
Mapbox.Unity.Utilities.Console.Instance.Log(string.Format("Jump strength: position: {0}m, rotation: {1} degrees ", (Frame.Pose.position - lastFramePose.position).magnitude, Quaternion.Angle(Frame.Pose.rotation, lastFramePose.rotation)), "yellow");
OnTrackingJumped(Frame.Pose, lastFramePose);
}
//Check if trackingLost timer expired
if (Session.Status != SessionStatus.Tracking && _trackingLostCountdownInProgress)
{
long timeNow = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
if (timeNow - _trackingLostTime >= 1000)
{
Mapbox.Unity.Utilities.Console.Instance.Log("Tracking lost timer expired after " + (timeNow - _trackingLostTime) + "ms, sending TrackingLost", "yellow");
OnTrackingLost(_trackingLostLastPose);
_trackingLostCountdownInProgress = false;
_trackingLostLastPose = new Pose();
_trackingLostTime = 0;
}
}
//Save frameTrackingState so we can compare on next frame & detect changes.
lastFrameTrackingState = Session.Status;
if (Session.Status == SessionStatus.Tracking)
{
lastFramePose = Frame.Pose;
}
if (Session.Status != SessionStatus.Tracking)
{
return;
}
if (m_ARCoreSessionConfig.EnablePlaneFinding)
{
Session.GetTrackables <TrackedPlane>(m_TrackedPlaneBuffer, TrackableQueryFilter.All);
foreach (var trackedPlane in m_TrackedPlaneBuffer)
{
BoundedPlane boundedPlane;
if (m_TrackedPlanes.TryGetValue(trackedPlane, out boundedPlane))
{
// remove any subsumed planes
if (trackedPlane.SubsumedBy != null)
{
OnPlaneRemoved(boundedPlane);
m_TrackedPlanes.Remove(trackedPlane);
}
// update any planes with changed extents
else if (PlaneUpdated(trackedPlane, boundedPlane))
{
boundedPlane.center = trackedPlane.CenterPose.position;
boundedPlane.rotation = trackedPlane.CenterPose.rotation;
boundedPlane.extents.x = trackedPlane.ExtentX;
boundedPlane.extents.y = trackedPlane.ExtentZ;
m_TrackedPlanes[trackedPlane] = boundedPlane;
OnPlaneUpdated(boundedPlane);
}
}
// add any new planes
else
{
boundedPlane = new BoundedPlane()
{
id = Guid.NewGuid().ToString(),
center = trackedPlane.CenterPose.position,
rotation = trackedPlane.CenterPose.rotation,
extents = new Vector2(trackedPlane.ExtentX, trackedPlane.ExtentZ)
};
m_TrackedPlanes.Add(trackedPlane, boundedPlane);
OnPlaneAdded(boundedPlane);
}
}
// Check for planes that were removed from the tracked plane list
List <TrackedPlane> planesToRemove = new List <TrackedPlane>();
foreach (var kvp in m_TrackedPlanes)
{
var trackedPlane = kvp.Key;
if (!m_TrackedPlaneBuffer.Exists(x => x == trackedPlane))
{
OnPlaneRemoved(kvp.Value);
planesToRemove.Add(trackedPlane);
}
}
foreach (var plane in planesToRemove)
{
m_TrackedPlanes.Remove(plane);
}
}
//Update Anchors
foreach (var anchor in m_Anchors)
{
anchor.Key.transform.position = anchor.Value.transform.position;
anchor.Key.transform.rotation = anchor.Value.transform.rotation;
}
}
internal void WriteExecutionLog(AsyncTask asyncTask)
{
var name = asyncTask.GetType().Name;
Results.Add(string.Format("{0}: {1}", name, serialNumber));
}
public Future RunAsync(string databaseName, AsyncTask function)
{
Database database = GetDatabase(databaseName);
return RunAsync(new _Runnable_381(function, database));
}
public void TestTaskStateChangedEventHandling()
{
var observer = new TaskEventObserver();
var schedulerThread = new SampleSchedulerThread();
var scheduler = new DynamoScheduler(schedulerThread, TaskProcessMode.Asynchronous);
scheduler.TaskStateChanged += observer.OnTaskStateChanged;
// Start scheduling a bunch of tasks.
var asyncTasks = new AsyncTask[]
{
new ErrorProneAsyncTask(scheduler, 7),
new InconsequentialAsyncTask(scheduler, 100),
new PrioritizedAsyncTask(scheduler, 1),
new PrioritizedAsyncTask(scheduler, 5),
new ErrorProneAsyncTask(scheduler, 3),
new InconsequentialAsyncTask(scheduler, 500),
new InconsequentialAsyncTask(scheduler, 300),
new PrioritizedAsyncTask(scheduler, 3),
new ErrorProneAsyncTask(scheduler, 5),
};
foreach (SampleAsyncTask asyncTask in asyncTasks)
{
scheduler.ScheduleForExecution(asyncTask);
}
schedulerThread.GetSchedulerToProcessTasks();
// Drops all InconsequentialAsyncTask and leave behind one.
// Kept all PrioritizedAsyncTask instances and sorted them.
var expected = new List <string>
{
// Scheduling notifications...
"Scheduled: ErrorProneAsyncTask: 7",
"Scheduled: InconsequentialAsyncTask: 100",
"Scheduled: PrioritizedAsyncTask: 1",
"Scheduled: PrioritizedAsyncTask: 5",
"Scheduled: ErrorProneAsyncTask: 3",
"Scheduled: InconsequentialAsyncTask: 500",
"Scheduled: InconsequentialAsyncTask: 300",
"Scheduled: PrioritizedAsyncTask: 3",
"Scheduled: ErrorProneAsyncTask: 5",
// Task discarded notifications...
"Discarded: InconsequentialAsyncTask: 100",
"Discarded: InconsequentialAsyncTask: 300",
// Execution of remaining tasks...
"ExecutionStarting: ErrorProneAsyncTask: 7",
"ExecutionFailed: ErrorProneAsyncTask: 7",
"CompletionHandled: ErrorProneAsyncTask: 7",
"ExecutionStarting: PrioritizedAsyncTask: 1",
"ExecutionCompleted: PrioritizedAsyncTask: 1",
"CompletionHandled: PrioritizedAsyncTask: 1",
"ExecutionStarting: PrioritizedAsyncTask: 5",
"ExecutionCompleted: PrioritizedAsyncTask: 5",
"CompletionHandled: PrioritizedAsyncTask: 5",
"ExecutionStarting: ErrorProneAsyncTask: 3",
"ExecutionFailed: ErrorProneAsyncTask: 3",
"CompletionHandled: ErrorProneAsyncTask: 3",
"ExecutionStarting: PrioritizedAsyncTask: 3",
"ExecutionCompleted: PrioritizedAsyncTask: 3",
"CompletionHandled: PrioritizedAsyncTask: 3",
"ExecutionStarting: ErrorProneAsyncTask: 5",
"ExecutionFailed: ErrorProneAsyncTask: 5",
"CompletionHandled: ErrorProneAsyncTask: 5",
// Execution of InconsequentialAsyncTask last...
"ExecutionStarting: InconsequentialAsyncTask: 500",
"ExecutionCompleted: InconsequentialAsyncTask: 500",
"CompletionHandled: InconsequentialAsyncTask: 500"
};
Assert.AreEqual(expected.Count, observer.Results.Count());
int index = 0;
foreach (var actual in observer.Results)
{
Assert.AreEqual(expected[index++], actual);
}
}
public static void Issue(AsyncTask task)
{
AsyncTaskRunner(task);
}
private void onCompleteTestTask(AsyncTask task, int errCode, IDictionary<int, object> result)
{
//Debug.Log("onCompleteTestTask, taskID=" + task.getTaskID());
Debug.Log("soldier-" + task.taskID + " has found path with errCode=" + errCode);
IList<AStarNode> path = result[0] as IList<AStarNode>;
if (++_i >= _num && errCode == 0)
{
printPath(path);
}
}
