public ConnctionService(OmvServiceProvider omvServiceProvider, SshServiceProvider sshServiceProvider, SynoServiceProvider synoServiceProvider, WebminServiceProvider webminServiceProvider, IMessageBoxService messageBoxService, IDataProvider dataProvider, IMessagingCenter messagingCenter, IPreferences preferences) { _omvServiceProvider = omvServiceProvider; _sshServiceProvider = sshServiceProvider; _synoServiceProvider = synoServiceProvider; _webminServiceProvider = webminServiceProvider; _messageBoxService = messageBoxService; _dataProvider = dataProvider; _messagingCenter = messagingCenter; _preferences = preferences; _messagingCenter.Subscribe <string, string>( this, MessengerKeys.SessionExpired, async(sender, arg) => { await Init(); }); _messagingCenter.Subscribe <DataProvider, TableBase>( this, MessengerKeys.ItemChanged, async(sender, arg) => { if (arg is Host) { await Init(); } }); }
public SuperheroesViewModel(INavigationService navigation, IMessagingCenter messaging, IRestClient client) { _navigation = navigation; _messaging = messaging; _client = client; Title = "Browse"; LoadCommand = new Command(async() => await ExecuteLoadCommand(), () => !IsBusy); NewCommand = new Command(async() => await ExecuteNewCommand(), () => !IsBusy); ViewCommand = new Command(async() => await ExecuteViewCommand(), () => !IsBusy); _messaging.Subscribe <SuperheroCreateViewModel, SuperheroListDTO>(this, AddSuperhero, (obj, superhero) => { Items.Add(superhero); }); _messaging.Subscribe <SuperheroUpdateViewModel, SuperheroListDTO>(this, Message, (obj, superhero) => { var existing = Items.FirstOrDefault(h => h.Id == superhero.Id); if (existing != null) { Items.Remove(existing); } Items.Add(superhero); }); _messaging.Subscribe <SuperheroDetailsViewModel, int>(this, DeleteSuperhero, (obj, superheroId) => { var existing = Items.FirstOrDefault(h => h.Id == superheroId); if (existing != null) { Items.Remove(existing); } }); }
/// <inheritdoc /> public override bool FinishedLaunching(UIApplication uiApplication, NSDictionary launchOptions) { var result = base.FinishedLaunching(uiApplication, launchOptions); _messagingCenter = MessagingCenter.Instance; _messagingCenter.Subscribe <object>(this, ToBackgroundMessages.StartBackgroundService, OnStartBackgroundServiceMessage); _messagingCenter.Subscribe <object>(this, ToBackgroundMessages.StopBackgroundService, OnStopBackgroundServiceMessage); _messagingCenter.Subscribe <object>(this, ToBackgroundMessages.GetBackgroundServiceState, OnGetBackgroundServiceState); BackgroundService = new NativeBackgroundServiceHost(); return(result); }
private async void Startup() { _starting = true; try { BuildForegroundService(); using (var mre = new ManualResetEventSlim()) { await Task.Run(async() => { await StartInBackground(); mre.Set(); }); if (!mre.Wait(_startupTimeout)) { Log.Error(_builder.ServiceName, "Background service did not cleanup within timeout time"); return; } } IsStarted = true; _messagingCenter.Send <object, BackgroundServiceState>(this, FromBackgroundMessages.BackgroundServiceState, new BackgroundServiceState(true)); _messagingCenter.Subscribe <object, UpdateNotificationMessage>(this, ToBackgroundMessages.UpdateBackgroundServiceNotificationMessage, OnNotificationMessageUpdate); } finally { _starting = false; } }
/// <inheritdoc /> /// Note that the system calls this on your service's main thread. /// A service's main thread is the same thread where UI operations take place for Activities running in the same process. /// You should always avoid stalling the main thread's event loop. /// When doing long-running operations, network calls, or heavy disk I/O, you should kick off a new thread, or use AsyncTask`3. public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId) { var stopRequest = intent.GetBooleanExtra(StopServiceExtra, false); if (!stopRequest && (IsStarted || _starting)) // Not a stop request, already started or starting { return(StartCommandResult.Sticky); } Task.Factory.StartNew(async() => { if (!stopRequest) // Start request { _starting = true; BuildForegroundService(); await StartInBackground(); _starting = false; IsStarted = true; _messagingCenter.Send <object, BackgroundServiceState>(this, FromBackgroundMessages.BackgroundServiceState, new BackgroundServiceState(true)); _messagingCenter.Subscribe <object, UpdateNotificationMessage>(this, ToBackgroundMessages.UpdateBackgroundServiceNotificationMessage, OnNotificationMessageUpdate); } else // Stop request { await Cleanup(); } }); return(StartCommandResult.Sticky); }
public void Subscribe <T>(Action <T> action) { Action <EventAggregator, T> actionX = (_, t) => { action(t); }; messagingCenter.Subscribe(this, nameof(T), actionX); }
public BaseViewModel(IMessagingCenter messagingCenter, IGameService gameService, IGameHubService gameHubService, ILocalStorageService localStorageService) { MessagingCenter = messagingCenter; GameService = gameService; GameHubService = gameHubService; LocalStorageService = localStorageService; TryReconnectCommand = new Command(async() => await OnTryReconnectAsync(), CanTryReconnect); messagingCenter.Subscribe <GameHubService, ConnectionStateChangedMessage>(this, nameof(ConnectionStateChangedMessage), HandleConnectionStateChanged); }
public SuperheroDetailsViewModel(INavigationService navigation, IMessagingCenter messaging, IRestClient client) { _navigation = navigation; _messaging = messaging; _client = client; LoadCommand = new Command(async o => await ExecuteLoadCommand(o as SuperheroListDTO), _ => !IsBusy); EditCommand = new Command(async _ => await ExecuteEditCommand(), _ => !IsBusy); DeleteCommand = new Command(async _ => await ExecuteDeleteCommand(), _ => !IsBusy); _messaging.Subscribe <SuperheroUpdateViewModel, SuperheroDetailsDTO>(this, UpdateSuperhero, (obj, superhero) => { SetSuperhero(superhero); }); }
//XFMA - Dependency injection at work public ItemsViewModel(INavigationService navigationService, IDataStore <Item> dataStore, IMessagingCenter messagingCenter) { this.navigationService = navigationService; this.dataStore = dataStore; Title = "List"; Items = new ObservableRangeCollection <Item>(); //XFMA - With different design we can avoid having to use //MessagingCenter but this was a nice demonstration of //how you can use Interfaces and DI to make code testable messagingCenter.Subscribe <NewItemViewModel, Item>(this, "AddItem", async(obj, item) => { await dataStore.AddItemAsync(item); }); }
public MainPageViewModel(INavigationService navigationService, IUserDialogs userDialogs, IMessagingCenter messagingCenter, IRandomUploadService randomUploadService) : base(navigationService) { Title = "Main Page"; UserDialogs = userDialogs; MessagingCenter = messagingCenter; RandomUploadService = randomUploadService; PushRandomCommand = new Command(() => Push()); // TODO: It is obvious that I only need one of these. Please fixe, I started out with only 2 MessagingCenter.Subscribe <IUploadStateMessenger, string>(this, Constants.Running, async(sender, id) => { await UserDialogs.AlertAsync($"Message received {id}", Constants.Running, "OK"); }); MessagingCenter.Subscribe <IUploadStateMessenger, string>(this, Constants.Blocked, async(sender, id) => { await UserDialogs.AlertAsync($"Message received {id}", Constants.Blocked, "OK"); }); MessagingCenter.Subscribe <IUploadStateMessenger, string>(this, Constants.Enqueued, async(sender, id) => { await UserDialogs.AlertAsync($"Message received {id}", Constants.Enqueued, "OK"); }); MessagingCenter.Subscribe <IUploadStateMessenger, string>(this, Constants.Cancelled, async(sender, id) => { await UserDialogs.AlertAsync($"Message received {id}", Constants.Cancelled, "OK"); }); MessagingCenter.Subscribe <IUploadStateMessenger, string>(this, Constants.Failed, async(sender, id) => { await UserDialogs.AlertAsync($"Message received {id}", Constants.Failed, "OK"); }); MessagingCenter.Subscribe <IUploadStateMessenger, string>(this, Constants.Succeeded, async(sender, id) => { var imageUpload = ImageUploads.SingleOrDefault(x => x.TaskId == id); if (imageUpload != null) { await UserDialogs.AlertAsync($"Message received {id}", Constants.Succeeded, "OK"); } }); }
public void Init() { //_aimTimerNotificationService.Stop(); AimTimerListItemViewModels.CollectionChanged -= AimTimerItemViewModels_CollectionChanged; //_aimTimerNotificationService.OnStatusChanged -= AimTimerNotificationService_OnStatusChanged; _messagingCenter.Unsubscribe <IAimTimerItem>(this, MessagingCenterMessages.AimTimerUpdated); AimTimerListItemViewModels.Clear(); foreach (var aimTimerItem in _aimTimerService.GetActiveAimTimers()) { AimTimerListItemViewModels.Add(_aimTimerItemViewModelFactory.Create(aimTimerItem)); } //_aimTimerNotificationService.SetItemsToFollow(AimTimerListItemViewModels.Select(i => i.GetAimTimerItem()).ToList()); AimTimerListItemViewModels.CollectionChanged += AimTimerItemViewModels_CollectionChanged; //_aimTimerNotificationService.OnStatusChanged += AimTimerNotificationService_OnStatusChanged; //_aimTimerNotificationService.Start(); _messagingCenter.Subscribe <IAimTimerItem>(this, MessagingCenterMessages.AimTimerUpdated, OnItemUpdated); InitTimer(); OnPropertyChanged(nameof(Title)); }
public ComponentWithMessagingDependency(IMessagingCenter messagingCenter) { _messagingCenter = messagingCenter; _messagingCenter.Subscribe <ComponentWithMessagingDependency>(this, "test", dependency => Console.WriteLine("test")); }
public MyOrdersViewModel(IOrderService orderSvc, ICache <Models.Order> orderCache, ICache <PropertyModel> propertyCache, ICache <ImageModel> imageCache, ILogger <MyOrdersViewModel> logger, ICacheRefresher cacheRefresher, IOrderValidationService validator, IPageFactory pageFactory, ICurrentUserService userService, LaunchedFromPushModel pushModel, MainThreadNavigator nav, IMessagingCenter messagingCenter, Action <Action> uiInvoke, Action <BaseNavPageType> baseNavAction) { _orderService = orderSvc; _orderCache = orderCache; _propertyCache = propertyCache; _imageCache = imageCache; _logger = logger; _uiInvoke = uiInvoke; _cacheRefresher = cacheRefresher; _validationService = validator; _pageFactory = pageFactory; _userService = userService; _messagingCenter = messagingCenter; _nav = nav; _baseNavAction = baseNavAction; ExampleReportCommand = new Command(() => { try { var order = JsonConvert.DeserializeObject <Models.Order>(Examples.ExampleOrder); _imageCache.Put(order.OrderId, new ImageModel() { OrderId = order.OrderId, Image = Convert.FromBase64String(Examples.ExampleImage) }); _propertyCache.Put(order.OrderId, JsonConvert.DeserializeObject <PropertyModel>(Examples.ExampleProperty)); _nav.Push(_pageFactory.GetPage(PageType.OrderDetail, order)); } catch (Exception ex) { _logger.LogError($"An error occurred while trying to open example order.", ex); } }); Action refreshAction = async() => { try { OrderListRefreshing = true; var fresh = await _orderService.GetMemberOrders(_userService.GetLoggedInAccount()?.UserId); _orderCache.Put(fresh.ToDictionary(x => x.OrderId, x => x)); SetListViewSource(fresh.ToList()); OrderListRefreshing = false; } catch (Exception ex) { _logger.LogError($"Failed to refresh order list.", ex); } }; OrderListRefreshCommand = new Command(refreshAction); _messagingCenter.Subscribe <App>(this, "CacheInvalidated", async x => { await this.SetViewState(); }); OnAppearingBehavior = new Command(async() => { if (!_pmEventSubscribed) { _pmEventSubscribed = true; pushModel.PropertyChanged += async(s, e) => { if (!string.IsNullOrWhiteSpace(pushModel.OrderId)) { var order = await _orderService.GetOrder(pushModel.OrderId); _orderCache.Put(order.OrderId, order); _nav.Push(_pageFactory.GetPage(PageType.OrderDetail, order)); } }; } await SetViewState(); }); }
public MainPage() { InitializeComponent(); _messagingCenter = (BindingContext as MainViewModel)?.MessagingCenter; _messagingCenter.Subscribe <MainViewModel>(this, nameof(FileSetActiveMessage), FileSetActive); }
public void Subscribe <T>(Action <T> handler) { _messagingCenter.Subscribe <IMessageBus, T>(this, typeof(T).Name, (_, args) => handler(args)); }