private static NavigatorTestingDetails <TNavigator> GetNavigatorToTest <TNavigator>( UrlPathDetails initialUrl, Assert assert, Func <IDispatcher, TNavigator> navigatorGenerator) where TNavigator : Navigator { if (initialUrl == null) { throw new ArgumentNullException("initialUrl"); } if (assert == null) { throw new ArgumentNullException("assert"); } if (navigatorGenerator == null) { throw new ArgumentNullException("navigatorGenerator"); } var dispatcher = new AppDispatcher(); var historyHandler = new MockHistoryHandler(initialUrl: new UrlDetails(NonNullList <NonBlankTrimmedString> .Empty, Optional <QueryString> .Missing)); var navigator = navigatorGenerator(dispatcher); RouteCombiner.StartListening(historyHandler, navigator.Routes, dispatcher); var navigatorTestingDetails = new NavigatorTestingDetails <TNavigator>(navigator, historyHandler, dispatcher, assert); historyHandler.RaiseNavigateToForCurrentLocation(); return(navigatorTestingDetails); }
public SimpleExampleStore(HTMLElement renderContainer, AppDispatcher dispatcher) { if (renderContainer == null) { throw new ArgumentNullException("renderContainer"); } if (dispatcher == null) { throw new ArgumentNullException("dispatcher"); } _renderContainer = renderContainer; _dispatcher = dispatcher; _viewModel = new ViewModel(lastUpdated: DateTime.Now, message: "Hi!", validationError: ""); RenderIfActive(); _dispatcher.Register(message => { var recordChange = message.Action as RecordChangeAction <ViewModel>; if (recordChange != null) { UserEdit(recordChange.Value); return; } if (message.Action is TimePassedAction) { _viewModel = new ViewModel(lastUpdated: DateTime.Now, message: _viewModel.Message, validationError: _viewModel.ValidationError); RenderIfActive(); return; } }); }
public SimpleExampleStore(AppDispatcher dispatcher) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher"); } _dispatcher = dispatcher; LastUpdated = DateTime.Now; Message = "Hi!"; ValidationError = ""; _dispatcher.Register(message => { message .If <MessageChangeAction>(action => { Message = action.Value; ValidationError = (action.Value.Trim() == "") ? "Why no message??" : ""; }) .Else <TimePassedAction>(action => LastUpdated = DateTime.Now) .IfAnyMatched(OnChange); }); }
static void Main() { // Configure your DI container var container = new UnityContainer(); container.RegisterType <IUserRepository, InMemoryUserRepository>(); container.RegisterType <ILogger, ConsoleLogger>(); container.RegisterType(typeof(IHandle <CreateUser>), typeof(UserService)); // Create common service locator adapter var unityServiceLocatorAdapter = new UnityServiceLocator(container); // Initilaize the AppDispatcher AppDispatcher.Initialize(app => { app.UseCommonServiceLocator(unityServiceLocatorAdapter); }); // Create a request var request = new CreateUser { Name = "Jane Smith" }; // Handle it using the dispatcher, if DI is configured correctly // the message handler in your application service will handle it. AppDispatcher.Handle(request); }
static void DoEvents() { DispatcherFrame frame = new DispatcherFrame(); AppDispatcher.Invoke(DispatcherPriority.ApplicationIdle, new DispatcherOperationCallback(ExitFrame), frame); Dispatcher.PushFrame(frame); }
public Task <TQuery> BuildAsync <TQuery>(AppDispatcher appDispatcher, TQuery query) where TQuery : IQuery { IQueryBuilder <TQuery> queryBuilder = _GetQueryBuilder <TQuery>(); var result = queryBuilder.BuildAsync(appDispatcher, query).ContinueWith(t => query); return(result); }
public virtual Task <ICommandResult> ExecuteAsync(AppDispatcher appDispatcher, ICommand command) { if (command is TCommand targetCommand) { return(ExecuteAsync(appDispatcher, targetCommand)); } throw new InvalidOperationException("Invalid command parameter"); }
public Task HandleAsync(AppDispatcher appDispatcher, IEvent @event) { if (!(@event is TEvent targetEvent)) { throw new InvalidOperationException("Invalid event parameter"); } return(HandleAsync(appDispatcher, targetEvent)); }
public Task <ICommandResult> SendAsync <TCommand>(AppDispatcher appDispatcher, TCommand command) where TCommand : ICommand { Task <ICommandResult> result = null; ICommandHandler <TCommand> handler = _GetHandler <TCommand>(); result = handler.ExecuteAsync(appDispatcher, command); return(result); }
public Task BuildAsync(AppDispatcher appDispatcher, IQuery query) { TQuery targetQuery = query as TQuery; if (targetQuery == null) { throw new InvalidOperationException("Invalid query parameter"); } return(BuildAsync(appDispatcher, targetQuery)); }
public override Task BuildAsync(AppDispatcher appDispatcher, EntityConvertQuery <TFrom, TTo> query) { var toObject = ConvertAsync(appDispatcher, query.Object); var resultTask = toObject.ContinueWith(t => { var result = QueryResult <TTo> .FromResult(t.Result); return(result); }); return(resultTask); }
private void HandleAnchorLocated(object sender, AnchorLocatedEventArgs args) { Debug.Log($"Anchor recognized as a possible Azure anchor"); if (args.Status == LocateAnchorStatus.Located || args.Status == LocateAnchorStatus.AlreadyTracked) { currentCloudAnchor = args.Anchor; AppDispatcher.Instance().Enqueue(() => { Debug.Log($"Azure anchor located successfully"); var indicator = Instantiate(anchorPositionPrefab); #if WINDOWS_UWP || UNITY_WSA indicator.gameObject.CreateNativeAnchor(); if (currentCloudAnchor == null) { return; } Debug.Log("Local anchor position successfully set to Azure anchor position"); indicator.GetComponent <UnityEngine.XR.WSA.WorldAnchor>().SetNativeSpatialAnchorPtr(currentCloudAnchor.LocalAnchor); #elif UNITY_ANDROID || UNITY_IOS Pose anchorPose = Pose.identity; anchorPose = currentCloudAnchor.GetPose(); Debug.Log($"Setting object to anchor pose with position '{anchorPose.position}' and rotation '{anchorPose.rotation}'"); indicator.transform.position = anchorPose.position; indicator.transform.rotation = anchorPose.rotation; // Create a native anchor at the location of the object in question indicator.gameObject.CreateNativeAnchor(); #endif indicator.Init(currentTrackedObject); anchorArrowGuide.SetTargetObject(indicator.transform); activeAnchors.Add(currentTrackedObject.SpatialAnchorId, indicator); // Notify subscribers OnFindAnchorSucceeded?.Invoke(this, EventArgs.Empty); currentWatcher?.Stop(); currentTrackedObject = null; }); } else { Debug.Log($"Attempt to locate Anchor with ID '{args.Identifier}' failed, locate anchor status was not 'Located' but '{args.Status}'"); } StopAzureSession(); }
static void Run() { var dispatcher = new AppDispatcher(); new SimpleExampleStore( Global.window.document.getElementById("main"), dispatcher ); Global.window.setInterval( (Action)(() => dispatcher.HandleServerAction(new TimePassedAction())), 500 ); }
/// <summary> /// Take a photo from the WebCam. Make sure the camera is active. /// </summary> /// <returns>Image data with a Texture for thumbnail.</returns> public Task <ImageThumbnail> TakePhotoWithThumbnail() { if (!IsCameraActive) { throw new Exception("Can't take photo when camera is not ready."); } return(Task.Run(() => { var completionSource = new TaskCompletionSource <ImageThumbnail>(); AppDispatcher.Instance().Enqueue(() => { Debug.Log("Starting photo capture."); #if UNITY_WSA photoCapture.TakePhotoAsync((photoCaptureResult, frame) => { Debug.Log("Photo capture done."); var buffer = new List <byte>(); frame.CopyRawImageDataIntoBuffer(buffer); var texture = new Texture2D(2, 2); var imageData = buffer.ToArray(); texture.LoadImage(imageData); var imageThumbnail = new ImageThumbnail { ImageData = imageData, Texture = texture }; completionSource.TrySetResult(imageThumbnail); }); #else var tex = new Texture2D(webCamTexture.width, webCamTexture.height); tex.SetPixels(webCamTexture.GetPixels()); tex.Apply(); var data = tex.EncodeToPNG(); var imageThumbnail = new ImageThumbnail { ImageData = data, Texture = tex }; completionSource.TrySetResult(imageThumbnail); #endif }); return completionSource.Task; })); }
public Props(SimpleExampleStore store, AppDispatcher dispatcher) { if (store == null) { throw new ArgumentNullException("store"); } if (dispatcher == null) { throw new ArgumentNullException("dispatcher"); } Store = store; Dispatcher = dispatcher; }
public AppUIStore(AppDispatcher dispatcher, IReadAndWriteMessages messageApi) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher"); } if (messageApi == null) { throw new ArgumentNullException("messageApi"); } NewMessage = GetEmptyNewMessage(); MessageHistory = NonNullList <SavedMessageDetails> .Empty; _saveActionRequestId = null; dispatcher.Receive(a => a .If <StoreInitialised>( condition: action => action.Store == this, work: action => { // When it's time for a Store to be initialised (to set its initial state and call OnChange to let any interested Components know // that it's ready), a StoreInitialised action will be dispatched that references the Store. In a more complicated app, a router // might choose an initial Store based upon the current URL. (We don't need to do anything within this callback, we just need to // match the StoreInitialised so that IfAnyMatched will fire and call OnChange). } ) .Else <MessageEditStateChanged>(action => NewMessage = UpdateValidationFor(action.NewState)) .Else <MessageSaveRequested>(action => { NewMessage = NewMessage.With(_ => _.IsSaveInProgress, true); _saveActionRequestId = messageApi.SaveMessage(action.Message); }) .Else <MessageSaveSucceeded>( condition: action => action.RequestId == _saveActionRequestId, work: action => { // The API's SaveMessage function will fire a MessageSaveSucceeded action when (if) the save is successful and then a subsequent // MessageHistoryUpdated action after it's automatically retrieved fresh data, including the newly-saved item (so we need only // reset the form here, a MessageHistoryUpdated should be along shortly containig the new item..) _saveActionRequestId = null; NewMessage = GetEmptyNewMessage(); } ) .Else <MessageHistoryUpdated>(action => MessageHistory = action.Messages) .IfAnyMatched(OnChange) ); }
public Task <uint> PublishAsync <TEvent>(AppDispatcher appDispatcher, TEvent @event) where TEvent : IEvent { uint numListeners = 0; var eventListeners = _serviceLocator.Get <IEventListener <TEvent> >() .ToList(); var tasks = new List <Task>(eventListeners.Count); foreach (var eventListener in eventListeners) { tasks.Add(eventListener.HandleAsync(appDispatcher, @event)); ++numListeners; } return(Task.WhenAll(tasks).ContinueWith(t => numListeners)); }
private async void CreateAsaAnchorEditor(Transform indicatorTransform) { var indicator = Instantiate(anchorPositionPrefab, indicatorTransform.position, indicatorTransform.rotation); anchorCreationController.StartProgressIndicatorSession(); await Task.Delay(2500); var mockAnchorId = Guid.NewGuid().ToString(); currentTrackedObject.SpatialAnchorId = mockAnchorId; activeAnchors.Add(currentTrackedObject.SpatialAnchorId, indicator); AppDispatcher.Instance().Enqueue(() => { indicator.Init(currentTrackedObject); OnCreateAnchorSucceeded?.Invoke(this, mockAnchorId); currentTrackedObject = null; }); }
public static void Go() { var dispatcher = new AppDispatcher(); var store = new AppUIStore(dispatcher, new MessageApi(dispatcher)); var container = Document.GetElementById("main"); container.ClassName = string.Join(" ", container.ClassName.Split().Where(c => c != "loading")); React.Render( new AppContainer(store, dispatcher), container ); // After the Dispatcher and the Store and the Container Component are all associated with each other, the Store needs to be told that // it's time to set its initial state, so that the Component can receive an OnChange event and draw itself accordingly. In a more // complicated app, this would probably be an event fired by the router - initialising the Store appropriate to the current URL, // but in this case there's only a single Store to initialise. dispatcher.Dispatch(new StoreInitialised(store)); }
private async void FindAsaAnchorEditor() { anchorCreationController.StartProgressIndicatorSession(); await Task.Delay(3000); var targetPosition = Camera.main.transform.position; targetPosition.z += 0.5f; var indicator = Instantiate(anchorPositionPrefab); indicator.transform.position = targetPosition; indicator.Init(currentTrackedObject); anchorArrowGuide.SetTargetObject(indicator.transform); // Notify subscribers activeAnchors.Add(currentTrackedObject.SpatialAnchorId, indicator); AppDispatcher.Instance().Enqueue(() => OnFindAnchorSucceeded?.Invoke(this, EventArgs.Empty)); currentTrackedObject = null; }
public static void Main() { var dispatcher = new AppDispatcher(); var store = new SimpleExampleStore(dispatcher); React.Render( new App(store, dispatcher), Document.GetElementById("main") ); // This action would usually be fired off by a router to inform the Store for the current URL that it needs to // wake up, but in this example there is only a single Store! Sending it the StoreInitialisedAction means that // it can fire its OnChange event which the App component is waiting for, to know that it's show time. dispatcher.HandleViewAction(new StoreInitialisedAction(store)); Window.SetInterval( () => dispatcher.HandleServerAction(new TimePassedAction()), 500 ); }
static void Main() { // Look ma, no DI container! var logger = new ConsoleLogger(); Func <IUserRepository> userRepositoryFactory = () => new InMemoryUserRepository(); AppDispatcher.Initialize(app => { app.RegisterHandler <CreateUser>(createUserRequest => { UserServiceModule.CreateUser(createUserRequest, userRepositoryFactory, logger); }); }); var request = new CreateUser { Name = "Jane Smith" }; AppDispatcher.Handle(request); }
static void Main() { var container = new Container(); container.Register <IUserRepository, InMemoryUserRepository>(); container.Register <ILogger, ConsoleLogger>(); container.RegisterManyForOpenGeneric(typeof(IHandle <>), AppDomain.CurrentDomain.GetAssemblies()); container.RegisterDecorator(typeof(IHandle <>), typeof(LoggingDecorator <>)); var simpleInjectorServiceLocatorAdapter = new SimpleInjectorServiceLocatorAdapter(container); AppDispatcher.Initialize(app => { // Decorating the pipline AND using IoC: you will see // the action pipleine below wraps any IoC decorators app.GlobalPipeline(pipeline => pipeline.Decorate(handler => { Console.WriteLine("before a"); handler(); Console.WriteLine("after a"); }).Decorate(handler => { Console.WriteLine("before b"); handler(); Console.WriteLine("after b"); }), true); app.UseCommonServiceLocator(simpleInjectorServiceLocatorAdapter); }); var request = new CreateUser { Name = "Jane Smith" }; AppDispatcher.Handle(request); Console.ReadLine(); }
public ExampleNavigator(AppDispatcher dispatcher) : base(dispatcher) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher"); } // Declare pairs of routes and actions which will send the user along these routes. Doing both halves of the route management (registering and // following) together keeps each route's code localised while still allowing a static navigation interface to be created. When the user needs // to be sent to the an "Accommodation" sub-page, there won't be code to send them to "/Accommodation/xyz", a call will instead to be made to // the "Accommodation" method of this class, providing the sub-page id, and the target URL will be returned. This ensures that there is no // chance of changes to routes here not being reflected in other code (if "Accommodation" was changed to "WhereToStay", for example, then // no other code need be changed since it will all be calling the "Accommodation" method; if the other code was manually trying to go to // "/Accommodation/xyz" then that code would also have to be changed to "/WhereToStay/xyz" in all places and any mistakes wouldn't be // caught until runtime). // Register home _getHome = AddRelativeRoute( segments: NonNullList <string> .Empty, routeAction: new NavigateToHome(), urlGenerator: () => GetPath() ); // Register "/Accommodation" _getAccommodation = AddRelativeRoute( segment: "Accommodation", routeAction: new NavigateToAccommodationList(), urlGenerator: () => GetPath("Accommodation") ); // Register "/Accommodation/{string}" _getAccommodationWithSegment = AddRelativeRoute( routeDetails: RouteBuilder.Empty.Fixed("Accommodation").String(), routeActionGenerator: matchedValue => new NavigateToAccommodationSection(matchedValue), urlGenerator: segment => GetPath("Accommodation", segment) ); }
public ICommandResult Send <TCommand>(AppDispatcher appDispatcher, TCommand command) where TCommand : ICommand { return(Task.Run(() => SendAsync(appDispatcher, command)).Result); }
public ToDoStore() { AppDispatcher.Register <CreateItemAction>( create => { var newText = create.Message.Trim(); if (string.IsNullOrWhiteSpace(newText)) { return; } Create(newText); text = ""; EmitChange(); }); AppDispatcher.Register <CheckedItemAction>( action => { if (items.ContainsKey(action.Id)) { var found = items[action.Id]; if (found.IsComplete) { System.Diagnostics.Debug.Fail("Item is not in a valid state for this action"); } found.IsComplete = true; EmitChange(); } }); AppDispatcher.Register <UncheckedItemAction>( action => { if (items.ContainsKey(action.Id)) { var found = items[action.Id]; if (!found.IsComplete) { System.Diagnostics.Debug.Fail("Item is not in a valid state for this action"); } found.IsComplete = false; EmitChange(); } }); AppDispatcher.Register <EditItemAction>( action => { if (items.ContainsKey(action.Id)) { var found = items[action.Id]; if (found.IsEditable) { System.Diagnostics.Debug.Fail("Item is not in a valid state for this action"); } found.IsEditable = true; EmitChange(); } }); AppDispatcher.Register <SaveItemAction>( action => { if (items.ContainsKey(action.Id)) { var found = items[action.Id]; if (!found.IsEditable) { System.Diagnostics.Debug.Fail("Item is not in a valid state for this action"); } found.Text = action.Text; found.IsEditable = false; EmitChange(); } }); AppDispatcher.Register <ToggleAllCompletedAction>( action => { foreach (var item in items) { item.Value.IsComplete = action.IsCompleted; } EmitChange(); }); AppDispatcher.Register <ClearCompletedTasksAction>( action => { foreach (var item in items.Where(x => x.Value.IsComplete).ToList()) { items.Remove(item.Key); } EmitChange(); }); }
public App(SimpleExampleStore store, AppDispatcher dispatcher) : base(new Props(store, dispatcher)) { }
public abstract Task <TTo> ConvertAsync(AppDispatcher appDispatcher, TFrom entity);
public abstract Task HandleAsync(AppDispatcher appDispatcher, TEvent @event);
public abstract Task BuildAsync(AppDispatcher appDispatcher, TQuery query);