/// <summary> /// Convenience-Method: Call an action either immedately or queue it to MainThread /// </summary> /// <param name="act">the action</param> /// <param name="usingCoroutine">queue action to async-main-queue</param> /// <returns>Future that tells when or if the action is called</returns> public override AsyncFuture Call(Action act, bool usingCoroutine) { if (usingCoroutine) { // queue to async-queue return(_asyncManager.AddToMainThread(act)); } else { var result = new AsyncFuture() { finished = true }; // immediately call act(); return(result); } }
/// <summary> /// Add an action to be executated queued making sure to not take more time than set in MAIN_THREAD_MAX_MS (more or less) /// </summary> /// <param name="act"></param> public override AsyncFuture AddToMainThread(Action act) { var result = new AsyncFuture() { finished = false }; workerMainThread.actions.Enqueue(act); workerMainThread.actions.Enqueue(() => { result.finished = true; }); // start the worker to process the queue if not running if (disposableMainThreadWorker == null) { disposableMainThreadWorker = Observable.FromMicroCoroutine((cToken) => CoRoutineMainThreadWorker()).Subscribe(_ => { disposableMainThreadWorker = null; }); } return(result); }
/// <summary> /// Add an action and its callback /// </summary> /// <param name="act"></param> /// <param name="onFinished"></param> public override AsyncFuture AddToWorkerThread(Action act, Action onFinished) { var result = new AsyncFuture() { finished = false }; workerWorkerThread.actions.Enqueue(act); workerWorkerThread.actions.Enqueue(() => { result.finished = true; }); if (onFinished != null) { workerWorkerThread.actions.Enqueue(onFinished); } if (disposableWorker == null) { disposableWorker = Observable.Start(ThreadWorkerAction).ObserveOnMainThread().Subscribe(_ => { disposableWorker = null; }); } return(result); }
/// <summary> /// Add an action and its callback /// </summary> /// <param name="act"></param> /// <param name="onFinished"></param> public override AsyncFuture AddToWorkerThread(Action act, Action onFinished, bool global = false) { if (workerThreadRemoveNotGlobalActions && global == false) { Debug.LogWarning("AsyncManager doesn't accept non global actions atm. Skipping"); return(new AsyncFuture() { finished = true }); } AsyncFuture result = new AsyncFuture() { finished = false }; workerWorkerThread.actions.Enqueue(new AsyncAction() { action = act, global = global }); workerWorkerThread.actions.Enqueue(new AsyncAction() { action = () => { result.finished = true; }, global = global }); if (onFinished != null) { workerWorkerThread.actions.Enqueue(new AsyncAction() { action = onFinished, global = global }); } if (disposableWorker == null) { disposableWorker = Observable.Start(ThreadWorkerAction).ObserveOnMainThread().Subscribe(_ => { disposableWorker.Dispose(); disposableWorker = null; }); } return(result); }
/// <summary> /// Convenience-Method: Call an action either immedately or queue it to MainThread /// </summary> /// <param name="act">the action</param> /// <param name="usingCoroutine">queue action to async-main-queue</param> /// <returns>Future that tells when or if the action is called</returns> public override AsyncFuture Call(Action act, bool usingCoroutine, bool global) { if (usingCoroutine) { // queue to async-queue return(_asyncManager.AddToMainThread(act, global)); } else { AsyncFuture result = new AsyncFuture() { finished = true }; // immediately call try { act(); } catch (Exception e) { Debug.LogError("Catched AsyncManager.Call(Mainthread-immediate)-Exception:" + e + "\n" + e.StackTrace); } return(result); } }