public override async void ViewAppearing() { base.ViewAppearing(); _token = _messenger.Subscribe <SelectedOpChangedMessage>(async msg => { await LoadOperationCommand.ExecuteAsync(); if (_preferences.Get(UserSettingsKeys.ShowAgentsFromAnyTeam, false) is false) { // Force refresh agents pins to only show current OP agents Agents.Clear(); await RaisePropertyChanged(() => Agents); } await RefreshTeamsMembersPositionsCommand.ExecuteAsync(string.Empty); }); _tokenReload ??= _messenger.Subscribe <MessageFrom <OperationRootTabbedViewModel> >(async msg => await LoadOperationCommand.ExecuteAsync()); _tokenLiveLocation ??= _messenger.Subscribe <TeamAgentLocationUpdatedMessage>(async msg => await RefreshTeamAgentPositionCommand.ExecuteAsync(msg)); _tokenLinkUpdated ??= _messenger.Subscribe <LinkDataChangedMessage>(UpdateLink); _tokenMarkerUpdated ??= _messenger.Subscribe <MarkerDataChangedMessage>(UpdateMarker); _tokenRefreshAllAgentsLocations ??= _messenger.Subscribe <RefreshAllAgentsLocationsMessage>(async msg => await RefreshTeamsMembersPositionsCommand.ExecuteAsync(string.Empty)); await LoadOperationCommand.ExecuteAsync(); await RefreshTeamsMembersPositionsCommand.ExecuteAsync(string.Empty); }
public void Subscribe() { Debug.WriteLine("Starting subscribing tracking messages"); if (_tokenStart != null) { Debug.WriteLine("You are trying to subscribe, already subscribed"); return; } _tokenStart = _messenger.Subscribe <StartTrackingMessage>(m => { Debug.WriteLine("Started tracking"); StartTime = m.TimeStamp; Duration = m.Duration; Token = m.Token; IsTracking = true; }); _tokenStop = _messenger.Subscribe <StopTrackingMessage>(m => { Debug.WriteLine("Stopped tracking"); IsTracking = false; }); _tokenLocation = _messenger.Subscribe <LocationMessage>(m => { Debug.WriteLine($"Location(WP) tracking {m.Lat} {m.Lng}"); if (CheckIfNotExpired() && !m.IsError) { Debug.WriteLine("Sending position"); _sendPositionService.SendPosition(Token, new Position(m.Lat, m.Lng), m.Address, m.Accuracy); } }); }
public void Subscribe() { if (_tokenStart != null) { return; } _tokenStart = _messenger.Subscribe <StartTrackingMessage>(m => { _startTime = m.TimeStamp; _duration = m.Duration; _token = m.Token; IsTracking = true; }); _tokenStop = _messenger.Subscribe <StopTrackingMessage>(m => { IsTracking = false; }); _tokenLocation = _messenger.Subscribe <LocationMessage>(m => { if (CheckIfNotExpired() && !m.IsError) { _sendPositionService.SendPosition(_token, new Position(m.Lat, m.Lng), m.Address, m.Accuracy); } }); }
public TimerService(IMvxMessenger messageService) { _messageService = messageService; _stopTimerMessageToken = messageService.Subscribe <StopTimerServiceMessage <T> >(StopTimer); _startTimerMessageToken = messageService.Subscribe <StartTimerServiceMessage <T> >(StartTimer); }
public InventoryViewModel(IDataService dataService, IMvxMessenger messenger, IBackupService oneDriveService) : base(dataService, messenger, oneDriveService) { _dataService = dataService; _messenger = messenger; // Only register message once (prevents multiple calls) if (_messenger.CountSubscriptionsFor <ItemQuantityUpMessage>() == 0) { _upToken = _messenger.Subscribe <ItemQuantityUpMessage>(message => { ItemQuantityUpCommand.Execute(message.Item); }); } if (_messenger.CountSubscriptionsFor <ItemQuantityDownMessage>() == 0) { _downToken = _messenger.Subscribe <ItemQuantityDownMessage>(message => { ItemQuantityDownCommand.Execute(message.Item); }); } _refreshToken = _messenger.Subscribe <CollectionChangedMessage>(Refresh); Items = _dataService.AllItems(); }
public LiveCardPresenter() { _messenger = Mvx.Resolve<IMvxMessenger>(); _messenger.Subscribe<ServiceStartedMessage>(onServiceStart); _messenger.Subscribe<ServiceDestroyedMessage>(onServiceDestroyed); _messenger.Subscribe<GlassShowViewModelMessage>(onShowViewModel); }
public TestViewModel(IMvxMessenger messenger) { _messenger = messenger; _receivedTokenDisposable = _messenger.Subscribe<TokenChangedMessage>(msg => { if(msg == null) return; var token = msg.NewToken; if(token == null) return; Issuer = token.Issuer; Audience = token.Audience; IdentityProvider = token.IdentityProvider; ExpiresOn = token.ExpiresOn; RawToken = token.RawToken; }); _loggedInTokenDisposable = _messenger.Subscribe<LoggedInMessage>(async msg => { //Validate token here, i.e. call your Web Service await Task.Delay(2000); //Calling this immediately, can result in nothing happening //MvxAndroidTask might still be "showing". _messenger.Publish(new CloseSelfMessage(this) {Close = true}); }); }
public HomeViewModel(IDeviceService deviceService, IShareService shareService, ISettings settings, ILocationService locationService, IMvxMessenger messenger, ISendPositionService sendPositionService, IPopupService popupService, ITimerService timer) { _deviceService = deviceService; _shareService = shareService; _settings = settings; _locationService = locationService; _messenger = messenger; _sendPositionService = sendPositionService; _popupService = popupService; _timer = timer; Title = "TrackMe"; PossibleTimes = new PossibleTimeProvider().GetPossibleTimes().ToObservable(); SelectedTime = new PossibleTime(240); _deviceService.LocationStatusChanged += (sender, args) => { GpsStatus = args.Status; if (!_locationService.IsWatching && args.Status == LocationStatus.Started) { _locationService.StartWatching(); } }; GpsStatus = _deviceService.LocationStatus; _locationMessageToken = _messenger.Subscribe <LocationMessage>(GotLocation); _requestStartTrackingToken = _messenger.Subscribe <RequestStartTrackingMessage>(OnRequestStartTracking); _messenger.Subscribe <CloseAppMessage>(message => { _messenger.Publish(new StopTrackingMessage(this, true, Token, PrivateToken, _timeEnd)); }); TrackConnectionStatus(); }
public override void ViewAppeared() { base.ViewAppeared(); _token ??= _messenger.Subscribe <NewOpAvailableMessage>(msg => RefreshAvailableOpsCommand.Execute()); _tokenDebug ??= _messenger.SubscribeOnMainThread <MessageFrom <SettingsViewModel> >(msg => { if (MenuItems.Any(x => x.ViewModelType == typeof(LogsViewModel))) { return; } MenuItems.Add(new MenuItem() { Icon = "mdi-record", Title = "Live FCM Logs", ViewModelType = typeof(LogsViewModel) }); RaisePropertyChanged(() => MenuItems); _preferences.Set(UserSettingsKeys.DevModeActivated, true); }); _tokenOps ??= _messenger.Subscribe <MessageFrom <OperationsListViewModel> >(msg => RefreshAvailableOpsCommand.Execute()); RefreshAvailableOpsCommand.Execute(); }
public SplitDetailViewModel(IActivityService activityService, ITwilioService twilioService, IDialogService dialogService, IMvxPhoneCallTask phoneCallTask, IMvxMessenger messenger, IProspectService prospectService, IMvxNavigationService navigationService) { Messenger = messenger; _prospectService = prospectService; _navigationService = navigationService; _phoneCallTask = phoneCallTask; _dialogService = dialogService; _twilioService = twilioService; _activityService = activityService; Phones = new ObservableCollection <KeyValuePair <string, string> >(); Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong); Messenger.Subscribe <ProspectChangedMessage>(message => Prepare(new KeyValuePair <Prospect, User>(message.UpdatedProspect, User)), MvxReference.Strong); Messenger.Subscribe <UserLogoutMessage>(message => UserLogout(), MvxReference.Strong); Messenger.Subscribe <ActivityAddedMessage>(message => ActivityAdded(message.AddedActivity), MvxReference.Strong); Messenger.Subscribe <ProspectChangedMessage>(message => { RaisePropertyChanged(() => EmailEntered); RaisePropertyChanged(() => StreetAddressEntered); RaisePropertyChanged(() => MobilePhoneEntered); RaisePropertyChanged(() => HomePhoneEntered); RaisePropertyChanged(() => WorkPhoneEntered); RaisePropertyChanged(() => AllowCalling); RaisePropertyChanged(() => AllowEmailing); RaisePropertyChanged(() => AllowTexting); }, MvxReference.Strong); }
public MainViewModel(IOctoService octoService, IWebsocketService websocketService, IMvxNavigationService navigationService, IMvxMessenger messenger) { _token_octo_message = messenger.Subscribe <OctoMessage>(OnOctoMessage); _token_currrent_message = messenger.Subscribe <CurrentMessage>(OnCurrentMessage); _octoService = octoService; _websocketService = websocketService; _navigationService = navigationService; }
public override async void ViewAppearing() { base.ViewAppearing(); _token ??= _messenger.Subscribe <SelectedOpChangedMessage>(async msg => await RefreshCommand.ExecuteAsync()); _tokenFromMap ??= _messenger.Subscribe <MessageFor <AssignmentsListViewModel> >(async msg => await RefreshCommand.ExecuteAsync()); _tokenRefresh ??= _messenger.Subscribe <MessageFrom <OperationRootTabbedViewModel> >(async msg => await RefreshCommand.ExecuteAsync()); await RefreshCommand.ExecuteAsync(); }
public BrowseImagesViewModel(IMvxMessenger messenger, IBooruPostsProviderFactory postsProviderFactory) { _messenger = messenger; _settingsUpdatedToken = _messenger.Subscribe <SettingsUpdatedMessage>(SettingsUpdated); _resetToken = _messenger.Subscribe <ResetBooruImagesMessage>(DropImages); _booruPostsProvider = postsProviderFactory.Create(); BindingOperations.EnableCollectionSynchronization(BooruImages, _booruImagesLockObj); }
public override async void ViewAppearing() { base.ViewAppearing(); _token ??= _messenger.Subscribe <MessageFrom <OperationRootTabbedViewModel> >(async msg => await RefreshCommand.ExecuteAsync()); _tokenRefreshLink ??= _messenger.Subscribe <LinkDataChangedMessage>(msg => RefreshLinkCommand.Execute(msg.LinkData)); _tokenRefreshMarker ??= _messenger.Subscribe <MarkerDataChangedMessage>(msg => RefreshMarkerCommand.Execute(msg.MarkerData)); await RefreshCommand.ExecuteAsync(); }
public TrafficCardViewModel(IMvxMessenger messenger, ITrafficCardResponseService trafficCardResponseService, IMvxNavigationService navigationService, IUserService userService) { Messenger = messenger; _trafficCardResponseService = trafficCardResponseService; _navigationService = navigationService; _userService = userService; Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong); Messenger.Subscribe <UserLogoutMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong); Messenger.Subscribe <TrafficCardResponseChangedMessage>(message => ResponseUpdated(message.ChangedResponse), MvxReference.Strong); }
public LandingViewModel(IMvxNavigationService navigationService, IDialogService dialogService, IAuthenticator authService, IMvxMessenger messenger, IUserService userService) { _navigationService = navigationService; _dialogService = dialogService; _authService = authService; _userService = userService; Messenger = messenger; Messenger.Subscribe <SMSReceivedMessage>(message => Process(message.SMSActivityReceived), MvxReference.Strong); Messenger.Subscribe <ExtendReloadTime>(message => Extend(message.ExtendMinutes), MvxReference.Strong); }
public EnterResultsViewModel(ITeamsService service, IMvxMessenger messenger, IGAService gaService) { _teamsService = service; _messenger = messenger; _gaService = gaService; _teamsChangedToken = messenger.Subscribe<TeamsChangedMessage> (OnTeamsChanged); _resultsChangedToken = messenger.Subscribe<ResultsChangedMessage> (OnResultsChanged); DataLoader = new DataLoader (); }
public EnterResultsViewModel(ITeamsService service, IMvxMessenger messenger, IGAService gaService) { _teamsService = service; _messenger = messenger; _gaService = gaService; _teamsChangedToken = messenger.Subscribe <TeamsChangedMessage> (OnTeamsChanged); _resultsChangedToken = messenger.Subscribe <ResultsChangedMessage> (OnResultsChanged); DataLoader = new DataLoader(); }
public DailyToDoViewModel(IMvxMessenger messenger, IAuthenticator authService, IUserDefinedCodeService userDefinedCodeService, IActivityService activityService, IIncrementalCollectionFactory collectionFactory, IMvxNavigationService navigationService) { Messenger = messenger; _authService = authService; _activityService = activityService; _collectionFactory = collectionFactory; _navigationService = navigationService; _userDefinedCodeService = userDefinedCodeService; dismissedMessengerToken = Messenger.Subscribe <TaskDismissedMessage>(message => RemoveTask(message.Activity)); completedMessengerToken = Messenger.Subscribe <TaskCompletedMessage>(message => RemoveTask(message.Activity)); }
public SMSInboxViewModel(IUserService userService, IMvxMessenger messenger, IAuthenticator authService, IProspectService prospectService, IActivityService activityService, IIncrementalCollectionFactory collectionFactory, IMvxNavigationService navigationService) { Messenger = messenger; _authService = authService; _activityService = activityService; _collectionFactory = collectionFactory; _navigationService = navigationService; _prospectService = prospectService; _userService = userService; messengerToken = Messenger.Subscribe <SMSReceivedMessage>(message => AddMessage(message)); messengerSentToken = Messenger.Subscribe <SMSSentMessage>(message => AddSentMessage(message)); }
public DirectMethodCommunicationViewModel(IDeviceService deviceService, ITranslationsService translationsService, IDeviceSettingDataService deviceSettingDataService, IMvxMessenger messageService) { _deviceService = deviceService; _translationsService = translationsService; _deviceSettingDataService = deviceSettingDataService; _directMethodStatusChangedMessageToken = messageService.Subscribe <DirectMethodStatusUpdatedMessage>(HandleDirectMethodStatusChanged); _deviceConnectionStatusChangedMessageToken = messageService.Subscribe <DeviceConnectionChangedMessage>(HandleDeviceConnectionStatus); }
public CobuyerViewModel(IMvxMessenger messenger, ICobuyerService cobuyerService, IMvxNavigationService navigationService, IUserService userService) { Messenger = messenger; _cobuyerService = cobuyerService; _navigationService = navigationService; _userService = userService; Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong); Messenger.Subscribe <UserLogoutMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong); Messenger.Subscribe <CobuyerChangedMessage>(message => CobuyerUpdated(message.UpdatedCobuyer), MvxReference.Strong); Messenger.Subscribe <CobuyerAddedMessage>(message => CobuyerAdded(message.AddedCobuyer), MvxReference.Strong); }
public ActivitiesViewModel(IMvxMessenger messenger, IActivityService activitiesService, IMvxNavigationService navigationService, IUserService userService) { Messenger = messenger; _activitiesService = activitiesService; _navigationService = navigationService; _userService = userService; Messenger.Subscribe <RefreshMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong); Messenger.Subscribe <UserLogoutMessage>(message => _clearDetailsInteraction.Raise(), MvxReference.Strong); Messenger.Subscribe <ActivityAddedMessage>(message => ActivityAdded(message.AddedActivity), MvxReference.Strong); Messenger.Subscribe <ProspectChangedMessage>(message => ProspectChanged(message.UpdatedProspect), MvxReference.Strong); }
static void Initialize(IMvxMessenger messenger) { Gai.SharedInstance.DispatchInterval = 60; Gai.SharedInstance.TrackUncaughtExceptions = true; Gai.SharedInstance.GetTracker(TrackingId); screenNameToken = messenger.Subscribe <GaScreenNameMessage>((m) => SetScreenName(m)); int count = messenger.CountSubscriptionsFor <GaScreenNameMessage>(); eventToken = messenger.Subscribe <GaEventMessage>(CreateEvent); exceptionToken = messenger.Subscribe <GaExceptionMessage>(CreateException); performanceToken = messenger.Subscribe <GaPerformanceTimingMessage>(CreatePerformanceMetric); publishToken = messenger.Subscribe <GaPublishMessage>(PublishAll); }
/// <summary> /// Initializes a new instance of the <see cref="RouteViewModel" /> class. /// </summary> /// <param name="logFactory">The log provider.</param> /// <param name="navigationService">The navigation service.</param> public RouteViewModel(ILoggerFactory logFactory, IMvxNavigationService navigationService, IRideService rideService, ILocationService locationService, IMvxMessenger messenger) : base(logFactory, navigationService) { this._rideService = rideService; this._locationService = locationService; this._messenger = messenger; this._token = messenger.Subscribe <MvxLocationMessage>(this.OnLocationUpdated); this._token = messenger.Subscribe <MvxTabIndexMessenger>(this.OnTabIndexUpdated); stopwatch = new Stopwatch(); stopwatch.Reset(); Loader = new TaskLoaderNotifier <SessionMap>(); }
public SplitMasterViewModel(IUserService userService, IMvxMessenger messenger, IDialogService dialogService, IAuthenticator authService, ICommunityService communityService, IProspectService prospectService, IIncrementalCollectionFactory collectionFactory, IMvxNavigationService navigationService) { Messenger = messenger; _dialogService = dialogService; _authService = authService; _communityService = communityService; _prospectService = prospectService; _collectionFactory = collectionFactory; _navigationService = navigationService; _userService = userService; Messenger.Subscribe <ProspectChangedMessage>(message => ProspectUpdated(message.UpdatedProspect), MvxReference.Strong); Messenger.Subscribe <ProspectAssignedMessage>(message => ProspectAssigned(message.AssignedProspect), MvxReference.Strong); Messenger.Subscribe <ActivityAddedMessage>(message => ActivityAdded(message.AddedActivity), MvxReference.Strong); }
public AddressMapViewModel(IMvxNavigationService navigationService, IConnection connection, IMvxMessenger messenger, IPermissionDependency permissionDependency, IGoogleMapsApiService googleMapsApiService, IGoogleMapTableAccess googleMapTableAccess, IQuickMessageDependency quickMessageDependency) { _navigationService = navigationService; _connection = connection; _messenger = messenger; _permissionDependency = permissionDependency; _googleMapsApiService = googleMapsApiService; _googleMapTableAccess = googleMapTableAccess; _quickMessageDependency = quickMessageDependency; Title = "Address Book"; Init(); _token = _messenger.Subscribe <AddressResult>((addr) => { try { if (addr != null) { if (!AddedAddresses.Any(x => x.PlaceId == addr.Address.PlaceId)) { _googleMapTableAccess.Insert(addr.Address); AddedAddresses.Add(addr.Address); ExecuteSelect(addr.Address); } } } catch (Exception ex) { _quickMessageDependency.ShowToastMessage(ex.Message); } }); }
public FolderControllerViewModel(IFolderObserver observer, IMvxMessenger hub) { this.observer = observer; this.hub = hub; this.files = new Dictionary<string, DateTime>(64); this.mvxSubscriptionToken = hub.Subscribe<NewFileMessage>(this.NewFileReceived); }
public MessagesViewModel(IMessageService messageService, IChatService chatService, IMvxMessenger messenger) { _messageService = messageService; _chatService = chatService; _chatMessageSubscriptionToken = messenger.Subscribe <ChatMessage>(OnNewMessage); MessageItemViewModels = new MvxObservableCollection <MessageItemViewModel>(); }
public MenuViewModel(IMvxNavigationService navigationService, IMvxMessenger messenger) { _navigationService = navigationService; _token = messenger.Subscribe <UpdateLanguageMessage>(OnUpdateLanguageMessage); MenuItemList = new MvxObservableCollection <CommonMenuItem>() { new CommonMenuItem { Icon = "\uf015", Code = "Home", Name = AppResources.Menu_Home }, new CommonMenuItem { Icon = "\uf201", Code = "Chart", Name = AppResources.Menu_Chart }, //new CommonMenuItem{Icon = "\uf03a", Name = "Edit"}, new CommonMenuItem { Icon = "\uf013", Code = "Settings", Name = AppResources.Menu_Settings }, //new CommonMenuItem{Icon = "\uf1e0", Name = "Share" }, //new CommonMenuItem{Icon = "\uf118", Name = "Like Me!" }, //new CommonMenuItem{Icon = "\uf0e0", Name = "Feedback" }, //new CommonMenuItem{Icon = "\uf4c4", Name = "Help" }, new CommonMenuItem { Icon = "\uf129", Code = "About", Name = AppResources.Menu_About }, }; }
public ScanViewModel(IMvxMessenger mvxMessenger) { _mvxMessenger = mvxMessenger; _scanSubscriptionTokenToken = _mvxMessenger.Subscribe<ScanMessage>(OnScan); }
public RestaurantDetailViewModel() { IMvxMessenger messenger = Mvx.Resolve <IMvxMessenger>(); _token = messenger.Subscribe <RatingChangeMessage>(RatingChangeHandler); _dataService = Mvx.Resolve <IDataService>(); }
public void LogIn( string url, Action<RequestSecurityTokenResponse> onLoggedIn, Action assumeCancelled, string identityProviderName = null) { var root = Application.Current.RootVisual as Frame; _messageHub = Mvx.Resolve<IMvxMessenger>(); _subscriptionToken = _messageHub.Subscribe<RequestTokenMessage>(message => { _response = message.TokenResponse; if (_response != null) { onLoggedIn(_response); } else { assumeCancelled(); } if (root == null) return; if (root.CanGoBack) root.GoBack(); }); if (root != null) { root.Navigate( new Uri( string.Format( "/Cheesebaron.MvxPlugins.AzureAccessControl.WindowsPhone;component/Views/AccessControlWebAuthView.xaml?url={0}&name={1}", WebUtility.UrlEncode(url), WebUtility.UrlEncode(identityProviderName)), UriKind.Relative)); } }
public DataViewModel(IMvxMessenger hub, IDataStorage<DataSample> data) { this.hub = hub; this.data = data; this.mvxSubscriptionToken = hub.Subscribe<NewDataMessage>(a => this.RaisePropertyChanged(() => this.DataList)); }
public MainViewModel(ISampleAppService sampleappservice, IMvxMessenger messenger) { _sampleAppService = sampleappservice; ReloadList(); _messenger = messenger; _listChangedToken = _messenger.Subscribe<SampleAppChangedMessage>(OnListChanged); }
public GoalEditViewModel() { //this.DefaultViewModel["Lebensmittel"] = ds.CurrentLebensmittel; //this.DefaultViewModel["Items"] = ds.LebensmittelConsumed; //this.DefaultViewModel["SelectedConsumed"] = ds.SelectedConsumed; //this.DefaultViewModel["Search"] = ds.LebensmittelResult; //this.DefaultViewModel["CurrentLebensmittel"] = ds.CurrentLebensmittel; //this.DefaultViewModel["SummaryConsumedDay"] = ds.SummaryConsumedDay; //this.DefaultViewModel["SummaryConsumedDaytime"] = ds.SummaryConsumedDaytime; //SelectedConsumed = null; _messenger = Mvx.Resolve<IMvxMessenger>(); //_logintoken = _messenger.Subscribe<LoggedInEvent>(a => LoginChanged(a.LoggedIn)); _synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync")); SaveDailyCommand = new MvxCommand(SaveDaily, canSaveDaily); NewRecord = false; WorkoutMinutes = new ObservableCollection<int>() { 20, 40, 60 }; WorkoutDays = new ObservableCollection<int>() { 1, 3, 5 }; _goal_Endurance = CurrentGoal.Goal_Endurance; _goal_FatLoss = CurrentGoal.Goal_FatLoss; _goal_Muscle = CurrentGoal.Goal_Muscle; OnPropertyChanged("Goal_Muscle"); OnPropertyChanged("Goal_Endurance"); OnPropertyChanged("Goal_FatLoss"); ; }
public HomeViewModel(IServicioDatos servicioDatos, IMvxMessenger messenger) { _servicioDatos = servicioDatos; CmdNuevo = new MvxCommand(RunNuevo); _token = messenger.Subscribe <ViewModelMessage>(OnViewModelMessage); Task.Run(CargarLista); }
public SessionListingViewModel(ISessionService sessionService, IMvxMessenger mvxMessenger) { SessionService = sessionService; _messageToken = mvxMessenger.Subscribe <RefreshRequestMessage>(OnRefreshRequested); Title = "Sessions"; }
public BaseViewModel(IMvxMessenger messenger) : base() { _messenger = messenger; _token = _messenger.Subscribe<ReloadDataMessage>(async _ => await ReloadDataAsync()); }
/// <summary> /// Konstruktor /// </summary> /// <param name="nav"></param> /// <param name="events"></param> /// <param name="sync"></param> public BettrFitDataSource() { _sync = new SyncDataViewModel(); Server = "https://www.bettrfit.com"; UserData = new UserVM(); UserGoals = new ObservableCollection<UserGoalVM>(); Auth = new WebAccess.ServiceReference.AuthData(); UserDaily = new ObservableCollection<UserDailyVM>(); NutritionPlanFavorites = new ObservableCollection<NutritionPlanFavoriteVM>(); NutritionPlanLeb = new ObservableCollection<LebensmittelVM>(); SummaryConsumedDaytime = new WebAccess.ServiceReference.SummaryData(); SummaryConsumedDay = new WebAccess.ServiceReference.SummaryData(); _messenger = Mvx.Resolve<IMvxMessenger>(); _mapper = new InitMapper(); _messenger.Subscribe<NetworkEvent>(m => IsNetworkAvailable = m.IsAvailable); LoadAll(); CheckLogin(); //if (ret == 0) //{ // _EventAggregator = Container.Resolve<IEventAggregator>(); // _EventAggregator.GetEvent<LoggedInEvent>().Publish(true); // _ds._loggedIn = true; //} }
public void LogIn(string url, Action<RequestSecurityTokenResponse> onLoggedIn, Action assumeCancelled, string identityProviderName = null) { var webAuthController = new AccessControlWebAuthController { RawUrl = url, IdentityProviderName = identityProviderName }; _messageHub = Mvx.Resolve<IMvxMessenger>(); _subscriptionToken = _messageHub.Subscribe<RequestTokenMessage>(message => { webAuthController.OnCancel(); if (message.TokenResponse != null) onLoggedIn(message.TokenResponse); else assumeCancelled(); }); var navControl = new UINavigationController(webAuthController) { Title = identityProviderName, NavigationBarHidden = false, }; webAuthController.NavigationItem.LeftBarButtonItem = new UIBarButtonItem("Cancel", UIBarButtonItemStyle.Done, (sender, args) => { webAuthController.OnCancel(); assumeCancelled(); }); var modalHost = Mvx.Resolve<IMvxTouchModalHost>(); modalHost.PresentModalViewController(navControl, true); }
public MyRidesViewModel( IMyShuttleClient myShuttleClient, IApplicationSettingServiceSingleton applicationSettingService, IMvxMessenger messenger) { if (myShuttleClient == null) { throw new ArgumentNullException("myShuttleClient"); } if (applicationSettingService == null) { throw new ArgumentNullException("applicationSettingService"); } if (messenger == null) { throw new ArgumentNullException("messenger"); } _myShuttleClient = myShuttleClient; _applicationSettingService = applicationSettingService; _messenger = messenger; _token = _messenger.Subscribe <ReloadDataMessage>(_ => InitializeActions()); InitializeActions(); InitializeCommands(); }
public FlashCardSetListViewModel(IFlashCardManager flashCardManager, IMvxMessenger messenger, IStudySettingsService settingsService) { _flashCardManager = flashCardManager; _messenger = messenger; _settingsService = settingsService; GetFlashCardSetList(); _flashCardSetSubscriptionToken = _messenger.Subscribe<FlashCardSetListChangedMessage>(OnListChanged); }
public FirstViewModel(IMvxMessenger messenger, IMvxNFCReadTask readTask, IMvxNFCWatcher watcher) { _messenger = messenger; _nfcReadTask = readTask; _watcher = watcher; _messageToken = messenger.Subscribe<MvxNFCMessageReceived>(MessageRecieved); }
public MainViewModel(IOCRService ocrService, IMvxPictureChooserTask pictureChooser, IMvxMessenger messenger) { OCRService = ocrService; PictureChooser = pictureChooser; Messenger = messenger; Messenger.Subscribe<PictureMessage>(async msg => await OnPictureReceivedAsync(msg)); }
public AlertsViewModel() { _messenger = Mvx.Resolve<IMvxMessenger>(); _service = Mvx.Resolve<IAlertService>(); _fileService = Mvx.Resolve<IMvxFileStore>(); _localDbService = Mvx.Resolve<ILocalDataService>(); // NetworkConnectionHelper = Mvx.Resolve<IConnectivity> (); _messenger.Subscribe<FollowsChanged>( async x => await ExecuteRefreshCommand(), MvxReference.Strong); }
public NutritionPlanOverviewViewModel() { _ds = BettrFitDataSource.Instance; _messenger = Mvx.Resolve<IMvxMessenger>(); _synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync")); CurrentDate = DateTime.Now; NutritionPlanCreateCommand = new MvxCommand(OnCreateNutritionPlan); }
public MainViewModel() { _ds = BettrFitDataSource.Instance; _messenger = Mvx.Resolve<IMvxMessenger>(); _mapNav = new Dictionary<string, Type>(); _mapNav.Add(menuNutritionPlan, typeof(NutritionPlanOverviewViewModel)); _mapNav.Add(menuNutritiondiary, typeof(NutritionPlanMainViewModel)); _mapNav.Add(menuGoals, typeof(GoalOverviewViewModel)); _mapNav.Add(menuNutrition, typeof(NutritionPlanMainViewModel)); _mapNav.Add(menuWeight, typeof(DailyDataOverviewViewModel)); _mapNav.Add("Login", typeof(LoginViewModel)); _mapNav.Add("Login mit Facebook", typeof(FirstViewModel)); _mapNav.Add(CultureHelper.GetLocalString("Register|Registrieren"), typeof(RegisterViewModel)); NavCommands = new ObservableCollection<NavEntry>(); NavCommand = new MvxCommand<string>(OnNavCommand); LogoffCommand = new MvxCommand(OnLogoffCommand); RefreshCommand = new MvxCommand(OnRefreshCommand); ShowInfoCommand = new MvxCommand(OnShowInfo); FeedbackCommand = new MvxCommand(OnFeedbackCommand); ShakeCommand = new MvxCommand(()=>_messenger.Publish(new ShakeEvent(this))); ShowAGBCommand = new MvxCommand(OnShowAGB); _logintoken = _messenger.Subscribe<LoggedInEvent>(a => LoginChanged(a.LoggedIn)); _synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync")); _nonetworktoken = _messenger.SubscribeOnMainThread<NetworkEvent>(m => { IsNetworkAvailable = m.IsAvailable; }); LoginChanged(_ds.IsLoggedIn()); //var client = WebService.Instance.WS; RaisePropertyChanged("Sync"); IsNotRefreshing = true; }
public FollowsViewModel(IFollowService service, IMvxMessenger messenger) { _messenger = messenger; _service = service; RefleshFollows(); _messenger.Subscribe<FollowsChanged>(x => { RefleshFollows(); }, MvxReference.Strong); }
public SideMenuViewModel(IAuthenticationService authService, IMvxMessenger messenger, ILocalizationService localizationService ) :base(authService, messenger) { this.ShouldSubscribeToSessionChange = true; this._localizationService = localizationService; _languageChangeToken = messenger.Subscribe<LanguageChangedMessage>((message) => { RaisePropertyChanged(() => NewLanguage); }); PropertyChanged += propertyChanged; }
/// <summary> /// Creates a Statistic ViewModel with custom start and end date /// </summary> /// <param name="startDate">Start date to select data from.</param> /// <param name="endDate">End date to select date from.</param> protected StatisticViewModel(DateTime startDate, DateTime endDate, IMvxMessenger messenger) { StartDate = startDate; EndDate = endDate; this.messenger = messenger; token = messenger.Subscribe<DateSelectedMessage>(message => { StartDate = message.StartDate; EndDate = message.EndDate; Load(); }); }
public BootstrapViewModel(IMvxMessenger messenger) : base() { _messenger = messenger; _sendMessageClickedToken = _messenger.Subscribe<SendMessageClicked> (msg => { Click (); }); Items = new ObservableCollection<ItemViewModel> (); Items.Add (new ItemViewModel ()); Items.Add (new ItemViewModel ()); }
public InboxViewModel(IInboxService inboxService, IMvxMessenger mvxMessenger) { _inboxService = inboxService; _mvxMessenger = mvxMessenger; // fill our Inbox up with Items of Stuff from IInboxService ReloadInbox(); // subscribe to Inbox Changed messages to react to changes in inbox service _inboxChangedSubToken = _mvxMessenger.Subscribe<InboxChangedMessage>(OnInboxChanged); }
public FirstViewModel(IKittenGenesisService service, IMvxMessenger messenger) { _messenger = messenger; var newList = new List<Kitten>(); for (var i = 0; i < 100; i++) { var newKitten = service.CreateNewKitten(i.ToString()); newList.Add(newKitten); } _messenger.Subscribe<KittenAcceptedMessage>(message => KittenAcceptedCommand.Execute(message.Kitten)); Kittens = newList; }
public ProductSearchViewModel( IProductCodeDataService productCodeDataService, IProductDataService productDataService, IMvxMessenger messenger, IBarCodeScanner scanner) { _scanner = scanner; _productCodeDataService = productCodeDataService; _productDataService = productDataService; _messenger = messenger; _messenger.Subscribe<EntityMessage<Product>>(ProductChange); }
public void LogIn(string url, Action<RequestSecurityTokenResponse> onLoggedIn, Action assumeCancelled, string identityProviderName = null) { _onLoggedIn = onLoggedIn; _assumeCancelled = assumeCancelled; _messageHub = Mvx.Resolve<IMvxMessenger>(); _subscriptionToken = _messageHub.Subscribe<RequestTokenMessage>(message => { _response = message.TokenResponse; }); var intent = new Intent(Mvx.Resolve<IMvxAndroidGlobals>() .ApplicationContext, typeof(AccessControlWebAuthActivity)); intent.PutExtra("cheesebaron.mvxplugins.azureaccesscontrol.droid.Url", url); StartActivityForResult(LoginIdentityRequestCode, intent); }
public ModifyPaymentViewModel(IPaymentRepository paymentRepository, IAccountRepository accountRepository, IDialogService dialogService, IPaymentManager paymentManager, ISettingsManager settingsManager, IMvxMessenger messenger, IBackupManager backupManager) { this.dialogService = dialogService; this.paymentManager = paymentManager; this.settingsManager = settingsManager; this.backupManager = backupManager; this.paymentRepository = paymentRepository; this.accountRepository = accountRepository; token = messenger.Subscribe<CategorySelectedMessage>(ReceiveMessage); }
public MakeStuffActionableViewModel(IMvxMessenger mvxMessenger, IInboxService inboxService, IProjectService projectService, IActionService actionService) { _mvxMessenger = mvxMessenger; _inboxService = inboxService; _projectService = projectService; _actionService = actionService; ReloadProjects(); // subscribe to Projects Changed messages to react to changes in project service _projectsChangedSubToken = _mvxMessenger.Subscribe<ProjectsChangedMessage>(OnProjectsChanged); _isSingleActionProject = true; }
public DailyDataEditViewModel() { //this.DefaultViewModel["Lebensmittel"] = ds.CurrentLebensmittel; //this.DefaultViewModel["Items"] = ds.LebensmittelConsumed; //this.DefaultViewModel["SelectedConsumed"] = ds.SelectedConsumed; //this.DefaultViewModel["Search"] = ds.LebensmittelResult; //this.DefaultViewModel["CurrentLebensmittel"] = ds.CurrentLebensmittel; //this.DefaultViewModel["SummaryConsumedDay"] = ds.SummaryConsumedDay; //this.DefaultViewModel["SummaryConsumedDaytime"] = ds.SummaryConsumedDaytime; //SelectedConsumed = null; _messenger = Mvx.Resolve<IMvxMessenger>(); //_logintoken = _messenger.Subscribe<LoggedInEvent>(a => LoginChanged(a.LoggedIn)); _synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync")); SaveDailyCommand = new MvxCommand(SaveDaily, canSaveDaily); NewRecord = false; }
public NutritionPlanCreateViewModel() { _ds = BettrFitDataSource.Instance; _messenger = Mvx.Resolve<IMvxMessenger>(); _synctoken = _messenger.Subscribe<SyncEvent>(a => RaisePropertyChanged("Sync")); CurrentDate = DateTime.Now; NutritionPlanCreateCommand = new MvxCommand(OnCreateNutritionPlan); SelectedDate = DateTime.Now; PlanList = new ObservableCollection<string>(); AllPlans = new ObservableCollection<NutritionPlanVM>(); fillPlanlist(); _ds.CalcBMR(_ds.UserData, ref _bmr, ref _act, ref _weight,ref _calcString); SelectedCalories = (int)(ACT*0.9d); }