private static IPromise WaitForRequest <T>(AsyncOperationHandle <T> request, string message)
    {
        var p = Promise.Create();

        CoroutineExtensions.WaitUntil(() => request.IsDone)
        .ThenDo(() => {
            if (!request.IsValid())     // request was auto-collected
            {
                Debug.Log(message);
                p.Resolve();
                return;
            }

            if (request.Status == AsyncOperationStatus.Succeeded)
            {
                Debug.Log(message);
                p.Resolve(request.Result);
            }
            else if (request.Status == AsyncOperationStatus.Failed)
            {
                Debug.LogException(request.OperationException);
                p.Reject(request.OperationException);
            }
        });

        return(p);
    }
        protected override IPromise <string> OnCreate()
        {
            Promise <string> result = Promise <string> .Create();

            Type linkType = fieldInfo.GetChildValueType();

            if (fieldInfo != null)
            {
                LinkFilterAttribute filter = fieldInfo.GetCustomAttribute <LinkFilterAttribute>();
                if (filter != null)
                {
                    if (filter.interfaceType.IsInterface)
                    {
                        TypeSelectorWindow.Open(filter.interfaceType, "Choose implementation").Done(selectedType =>
                        {
                            result.Resolve(CreateAsset(selectedType, linkType, fieldInfo));
                        });
                    }
                    else
                    {
                        result.Resolve(CreateAsset(filter.interfaceType, linkType, fieldInfo));
                    }
                }
                else
                {
                    result.Resolve(CreateAsset(type, linkType, fieldInfo));
                }
            }
            else
            {
                result.Resolve(CreateAsset(type, linkType, fieldInfo));
            }

            return(result);
        }
Exemple #3
0
        protected override IPromise <string> OnCreate()
        {
            Promise <string> promise = Promise <string> .Create();

            Type interfaceToImplement = fieldInfo != null
                ? fieldInfo.GetCustomAttribute <LinkFilterAttribute>()?.interfaceType
                : null;

            List <System.Type> typesToChoose = new List <System.Type>(Util.GetAllTypes(t =>
                                                                                       t.IsGenericType == false &&
                                                                                       t.IsAbstract == false &&
                                                                                       t != type &&
                                                                                       type.IsAssignableFrom(t) &&
                                                                                       typeof(Object).IsAssignableFrom(t)));

            if (interfaceToImplement != null)
            {
                typesToChoose.RemoveAll(t => interfaceToImplement.IsAssignableFrom(t) == false);
            }

            TypeSelectorWindow.Open(typesToChoose, $"Choose {type.Name} implementation").Done(selectedType =>
            {
                promise.Resolve(CreateAsset(selectedType, fieldInfo.GetChildValueType(), fieldInfo));
            });

            return(promise);
        }
Exemple #4
0
        public static IPromise <string> GetAdvertisingId()
        {
            Promise <string> result = Promise <string> .Create();

            if (Application.isEditor)
            {
                result.Resolve(SystemInfo.deviceUniqueIdentifier);
                return(result);
            }

            Application.RequestAdvertisingIdentifierAsync((string advertisingId, bool trackingEnabled, string error) =>
            {
                if (string.IsNullOrEmpty(advertisingId) == false)
                {
                    result.Resolve(advertisingId);
                }
                else
                {
                    Debug.LogError("Cannot get Advertising Identifier: " + error);
                    result.Resolve(SystemInfo.deviceUniqueIdentifier);
                }
            });
            Promise <string> timeout = Promise <string> .Create();

            App.Core.Timer.WaitForUnscaled(5).Done(() => timeout.Resolve(SystemInfo.deviceUniqueIdentifier));
            return(Promise <string> .Race(result, timeout));
        }
Exemple #5
0
        public void PromiseShouldHaveHasValueFalseWhenCreated()
        {
            Action <int> setAction;
            var          actual = Promise <int> .Create(out setAction);

            Assert.IsFalse(actual.HasValue);
        }
Exemple #6
0
        public void PromiseShouldImplicitlyCastToType()
        {
            Action <int> setAction;
            var          actual = Promise <int> .Create(out setAction);

            setAction(42);
            Assert.AreEqual(42, actual);
        }
        public IPromise <bool> ShowDialog(string messageKey, string yesKey = "#yes", string cancelKey = "#cancel")
        {
            promise = Promise <bool> .Create();

            messageText.Text = App.Core.Local.GetText(messageKey);
            cancelText.Text  = App.Core.Local.GetText(cancelKey);
            yesText.Text     = App.Core.Local.GetText(yesKey);
            return(promise);
        }
Exemple #8
0
        public void PromiseShouldHaveValueAfterSetActionIsCalled()
        {
            Action <int> setAction;
            var          actual = Promise <int> .Create(out setAction);

            setAction(42);
            Assert.IsTrue(actual.HasValue);
            Assert.AreEqual(42, actual.Value);
        }
Exemple #9
0
        public void PromiseShouldSpinWhenValueAccessedButNotSet()
        {
            Action <int> setAction;
            var          actual = Promise <int> .Create(out setAction);

            using (new Timer(_ => setAction(42), null, 100, Timeout.Infinite))
            {
                Assert.AreEqual(42, actual.Value);
            }
        }
Exemple #10
0
 public void createsSuccessfully()
 {
     Assert.DoesNotThrow(() =>
     {
         Promise <bool> .Create(() =>
         {
             return(true);
         });
     });
     Console.WriteLine("Promise was created successfully");
 }
Exemple #11
0
        public IPromise Animate()
        {
            Promise promise = Promise.Create();

            if (gameObject.activeSelf == false)
            {
                gameObject.SetActive(true);
            }
            StartCoroutine(AnimationRoutine(promise));
            return(promise);
        }
Exemple #12
0
        public static IPromise <Type> Open(IEnumerable <Type> types, string title)
        {
            TypeSelectorWindow win = GetWindow <TypeSelectorWindow>(true, title, true);

            win.MoveToCenter();

            win.types = types;

            win.promise = Promise <Type> .Create();

            return(win.promise);
        }
Exemple #13
0
    public static IPromise UnloadAll()
    {
        if (!Loaded)
        {
            return(Promise.Resolved());
        }

        return(Promise.All(AssetDictionary.Values.Select(o => o.OnAssetsUnloaded()))
               .ThenDo(() =>
        {
            LoadedPromise = Promise.Create();
        }));
    }
Exemple #14
0
 public void waits()
 {
     Assert.That(() =>
     {
         return(Promise <bool> .Create(() =>
         {
             for (int i = 1; i <= 1000; i++)
             {
                 Console.WriteLine(i);
             }
             return true;
         }).Wait().promiseStates.Contains(Promise <bool> .State.Waiting));
     });
     Console.WriteLine("This waited successfully");
 }
    public static IPromise LoadAsync <T>(string address)
    {
#if UNITY_EDITOR
        if (!Application.isPlaying)
        {
            var promise = Promise.Create();
            var load    = Addressables.LoadAssetAsync <T>(address);
            load.Completed += (result) => promise.Resolve(result);
            return(promise);
        }
#endif

        var request = Addressables.LoadAssetAsync <T>(address);
        return(WaitForRequest(request, "Loaded addressable at: " + address));
    }
Exemple #16
0
        public static IPromise <Type> Open(Type interfaceType, string title)
        {
            TypeSelectorWindow win = GetWindow <TypeSelectorWindow>(true, title, true);

            win.MoveToCenter();

            win.types = new List <Type>(Util.GetAllTypes(t =>
                                                         t.IsGenericType == false &&
                                                         t.IsAbstract == false &&
                                                         interfaceType.IsAssignableFrom(t) &&
                                                         typeof(UnityEngine.Object).IsAssignableFrom(t)));;

            win.promise = Promise <Type> .Create();

            return(win.promise);
        }
        /// <summary>
        /// Returns a <see cref="Promise"/> that resolves when this <see cref="MenuScreen"/> finishes transitioning in.
        /// </summary>
        public IPromise TransitionIn(bool abInstant = false)
        {
            if (transitionInPromise != null)
            {
                return(transitionInPromise);
            }
            transitionInPromise = Promise.Create();
            IPromise result = transitionInPromise;

            gameObject.SetActive(true);
            MenuHandler.CursorLocked = !showCursor;
            // TBH: This is where the pause time logic was.
            Interactable   = false;
            BlocksRaycasts = false;
            OnStateChangedEvent?.Invoke(State, MenuScreenState.TransitioningIn);
            State = MenuScreenState.TransitioningIn;
            OnWillAppear();
            OnWillAppearEvent?.Invoke();
            if (transition != null)
            {
                transition.Play(MenuTransitionMode.Forward, abInstant).Done(() =>
                {
                    // TBH: This is where the standard resume time logic was.
                    Interactable   = true;
                    BlocksRaycasts = true;
                    if (DefaultSelection != null)
                    {
                        MenuHandler.EventSystem.SetSelectedGameObject(DefaultSelection.gameObject);
                    }
                    OnStateChangedEvent?.Invoke(State, MenuScreenState.In);
                    State = MenuScreenState.In;
                    OnDidAppear();
                    OnDidAppearEvent?.Invoke();
                    IPromise promise    = transitionInPromise;
                    transitionInPromise = null;
                    promise.Resolve();
                });
            }
            else
            {
                // TBH: This is where the non-transitioned resume time logic was.
                Interactable   = true;
                BlocksRaycasts = true;
                result.Resolve();
            }
            return(result);
        }
Exemple #18
0
 public void throwsErrorIfErrorNotSpecified()
 {
     Console.WriteLine("This should throw an exception");
     try
     {
         Assert.Throws <Exception>(() =>
         {
             Promise <bool> .Create(() =>
             {
                 throw new Exception("Test Exception");
             });
         });
     }
     catch
     {
         Console.WriteLine("Exception thrown successfully");
     }
 }
        /// <summary>
        /// Returns a <see cref="Promise"/> that resolves when this <see cref="MenuScreen"/> finishes transitioning out.
        /// </summary>
        public IPromise TransitionOut(bool abInstant = false)
        {
            if (transitionOutPromise != null)
            {
                return(transitionOutPromise);
            }
            transitionOutPromise = Promise.Create();
            IPromise result = transitionOutPromise;

            if (rememberSelection && EventSystem.current.currentSelectedGameObject != null)
            {
                DefaultSelection = EventSystem.current.currentSelectedGameObject.GetComponent <Selectable>();
            }
            else
            {
                DefaultSelection = defaultSelection;
            }
            EventSystem.current.SetSelectedGameObject(null);
            Interactable   = false;
            BlocksRaycasts = false;
            OnStateChangedEvent?.Invoke(State, MenuScreenState.TransitioningOut);
            State = MenuScreenState.TransitioningOut;
            OnWillDisappear();
            OnWillDisappearEvent?.Invoke();
            if (transition != null)
            {
                transition.Play(MenuTransitionMode.Reverse, abInstant).Done(() =>
                {
                    gameObject.SetActive(false);
                    OnStateChangedEvent?.Invoke(State, MenuScreenState.Out);
                    State = MenuScreenState.Out;
                    OnDidDisappear();
                    OnDidDisappearEvent?.Invoke();
                    IPromise promise     = transitionOutPromise;
                    transitionOutPromise = null;
                    promise.Resolve();
                });
            }
            else
            {
                result.Resolve();
            }
            return(result);
        }
Exemple #20
0
        private static void runTrvPaddy()
        {
            var baseQuery = Models.TrvPaddy.Query.GetSampleData();

            Console.WriteLine("Base Query: " + baseQuery.ToJson(true));
            Console.WriteLine("Local or International Flight?");
            Console.WriteLine("1\tLocal");
            Console.WriteLine("2\tInternational");
            int option = Convert.ToInt32(Console.ReadLine());

            switch (option)
            {
            case 1:
                var localQuery = Models.TrvPaddy.Local.Query.GetQuery(baseQuery);
                Promise <string> .Create(() =>
                {
                    Clipboard.SetText(localQuery.ToJson());
                    return(null);
                });

                Console.WriteLine("Local Query: " + localQuery.ToJson(true));
                Console.WriteLine("Search Url: " + localQuery.ToString());
                Models.TrvPaddy.Local.Scrapper scrapper = new Models.TrvPaddy.Local.Scrapper();
                var flights = scrapper.GetFlights(localQuery);
                Console.WriteLine(flights.ToJson(true));
                break;

            case 2:
                var internationalQuery = Models.TrvPaddy.International.Query.GetQuery(baseQuery);
                Promise <string> .Create(() =>
                {
                    Clipboard.SetText(internationalQuery.ToJson());
                    return(null);
                });

                Console.WriteLine("International Query: " + internationalQuery.ToJson(true));
                Console.WriteLine("Search Url: " + internationalQuery.ToString());
                break;

            default:
                break;
            }
        }
Exemple #21
0
        static void Main(string[] args)
        {
            Promises.Promise.Create(() =>
            {
                Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] starting");
            })
            .Then((resolve, reject) =>
            {
                Task.Run(() =>
                {
                    Thread.Sleep(2000);
                    Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] done1");
                    resolve();
                });
            })
            .Then(() =>
            {
                Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] done2");
            })
            .Then((resolve, reject) =>
            {
                Task.Run(() =>
                {
                    Thread.Sleep(2000);
                    Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] done3");
                    resolve();
                });
            })
            .Then(() =>
            {
                Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] done4");
            })
            .Catch((ex) =>
            {
                Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] error: {ex.Message}");
            });

            Promise.All(new Promise[]
            {
                Promise.Create(() =>
                {
                    Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] starting task #1");
                })
                .Then((resolve, reject) =>
                {
                    Thread.Sleep(5000);
                    Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] done task #1");
                    resolve();
                }),
                Promise.Create(() =>
                {
                    Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] starting task #2");
                })
                .Then((resolve, reject) =>
                {
                    Thread.Sleep(5000);
                    Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] done task #2");
                    resolve();
                })
            })
            .Then(() =>
            {
                Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] done with all tasks");
            });

            Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] what are you waiting for?");
            Console.ReadLine();
        }
Exemple #22
0
        public void CreateNewResultPromise()
        {
            resultPromise = Promise <R> .Create();

            Resolved = false;
        }