public async override void Start()
{
if (await synchronisationService.AuthorizeTokenSynchronisationAsync())
{
await Task.Run(RefreshToolRoadsAsync);
}
else
{
Close(this);
if (IsBound)
{
_track.StopServices();
}
ShowViewModel <LoginViewModel>();
return;
}
base.Start();
_tokens.Add(_messenger.SubscribeOnMainThread <GeoWatcherStatusMessage>((s) => IsBound = s.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <LocationMessage>(x => Location = x.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <StatusMessage>(x => StatusString = x.Data.ToString(), MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <TollRoadChangedMessage>((s) => TollRoadString = s.Data?.Name, MvxReference.Strong));
await synchronisationService.DataSynchronisationAsync();
StatusString = _track.TollStatus.ToString();
TollRoadString = WaypointChecker.TollRoad?.Name;
if (_geoWatcher.Location != null)
{
Location = _geoWatcher.Location;
WaypointChecker.DetectWeAreInsideSomeTollPoint(Location);
}
}
public ListsViewModel(IMvxMessenger messenger, IStateService stateService)
{
_messenger = messenger;
_stateService = stateService;
SelectedListChangedCommand = new MvxCommand <DataList>(SelectedListChangedAction);
_listsChangedToken = _messenger.SubscribeOnMainThread <ListsChangedMessage>(ListsChangedMessageAction);
_selectedListChangedToken = _messenger.SubscribeOnMainThread <SelectedListChangedMessage>(SelectedListChangedMessageAction);
Lists = _stateService.Lists;
SelectedList = _stateService.SelectedList;
}
public CustomersListViewModel(Services.IErpService service, IMvxNavigationService navigationService, IMvxMessenger messenger)
{
this.service = service;
this.navigationService = navigationService;
this.messenger = messenger;
this.customerUpdatedMessageToken = messenger.SubscribeOnThreadPoolThread <CustomerUpdatedMessage>(OnCustomerUpdated);
this.customerDeletedMessageToken = messenger.SubscribeOnMainThread <CustomerDeletedMessage>(OnCustomerDeleted);
this.customerSearchMessageToken = messenger.SubscribeOnMainThread <CustomerSearchMessage>(OnCustomerSearch);
this.CreateCustomerCommand = new MvxCommand(OnCreateCustomer);
this.SearchCommand = new MvxAsyncCommand(OnSearch);
this.AboutCommand = new MvxCommand(ShowAboutPage);
this.listDescription = "All Customers";
}
protected override void OnAppearing()
{
base.OnAppearing();
_loginStartSubscriptionToken =
_messenger.SubscribeOnMainThread <StartLoginMessage>(async x => await SignalStart());
_loginSuccessSubscriptionToken =
_messenger.SubscribeOnMainThread <LoginSuccessMessage>(async x => await SignalSuccess(x.ActionToExecute));
_loginFailureSubscriptionToken =
_messenger.SubscribeOnMainThread <LoginFailureMessage>(async x => await SignalFailure(x.ErrorMessage));
}
public AddViewModel(ICollectionService collectionService, ILocationService locationService, IMvxMessenger messenger)
{
_collectionService = collectionService;
_locationService = locationService;
_token = messenger.SubscribeOnMainThread<LocationMessage>(OnLocation);
GetInitialLocation();
}
public AddViewModel(ICollectionService collectionService, ILocationService locationService, IMvxMessenger messenger)
{
_collectionService = collectionService;
_locationService = locationService;
_token = messenger.SubscribeOnMainThread <LocationMessage>(OnLocation);
GetInitialLocation();
}
public void Start(IMvxMessenger messenger)
{
IsObserving = true;
subscriptionToken = _shouldSubscribeOnThreadPool
? messenger.SubscribeOnThreadPoolThread <TMessage>(HandleMessage)
: messenger.SubscribeOnMainThread <TMessage>(HandleMessage);
}
public HomeViewModel(IDescriptionService descriptionService, IMvxMessenger messenger)
{
_token = messenger.SubscribeOnMainThread <TickMessage>(OnTick);
Descriptions = descriptionService.Descriptions
.Select(x => new DescriptionViewModel(x))
.ToList();
}
public RecipeViewModel(
IRecipeRepo recipeRepo
, IMvxShareTask shareTask
, IMvxMessenger messenger)
{
_recipeRepo = recipeRepo;
_shareTask = shareTask;
_messenger = messenger;
var isIdle = this.WhenAny(x => x.IsCountingDown, x => !x.Value);
_addActivityCommand = ReactiveCommand.Create(() => AddActivity());
_openCommand = ReactiveCommand.Create(() => Open());
_resetTimersCommand = ReactiveCommand.Create(() => ResetTimers());
_saveCommand = ReactiveCommand.Create(() => Save());
_shareCommand = ReactiveCommand.Create(() => Share());
_token = messenger.SubscribeOnMainThread <LoadRecipeMessage>(OnLoadRecipe);
int nr = new Random().Next(0, 200);
LoadRecipe(new Recipe {
Name = "Stampot #" + nr
});
}
public HomeViewModel(IDescriptionService descriptionService, IMvxMessenger messenger)
{
_token = messenger.SubscribeOnMainThread<TickMessage>(OnTick);
Descriptions = descriptionService.Descriptions
.Select(x => new DescriptionViewModel(x))
.ToList();
}
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 CountersViewModel(ICountersService service,
IMvxMessenger messenger)
{
this.service = service;
Counters = new ObservableCollection <CounterViewModel>();
token = messenger.SubscribeOnMainThread <CountersChangedMessage>
(async m => await LoadCounters());
}
public MainView()
{
InitializeComponent();
_messenger = Mvx.Resolve <IMvxMessenger>();
_alert_token = _messenger.SubscribeOnMainThread <AlertMessage>(OnAlertMessage);
_title_token = _messenger.Subscribe <ViewTitleMessage>(OnViewTitleMessage);
}
public GenerateViewModel(IMvxMessenger messenger, IDisplayDimensionsService displayDimensionsService,
IMandelbrotTaskGenerator mandelbrotTaskGenerator)
{
_displayDimensionsService = displayDimensionsService;
_mandelbrotTaskGenerator = mandelbrotTaskGenerator;
_mvxSubscriptionToken = messenger.SubscribeOnMainThread<TickMessage>(OnTick);
_autoPlay = true;
}
public MvxSubscriptionToken SubscribeOnMainThread <TMessage>(Action <TMessage> action, string tag = null)
where TMessage : MvxMessage
{
var token = MvxMessenger.SubscribeOnMainThread <TMessage>(action, MvxReference.Weak, tag);
AddDisposable(token);
return(token);
}
public CountersViewModel(ICountersService service, IMvxMessenger messenger, IMvxNavigationService navigationService)
{
token = messenger.SubscribeOnMainThread <CountersChangedMessage> (async m => await LoadCounters());
this.service = service;
Counters = new ObservableCollection <CounterViewModel>();
this.navigationService = navigationService;
ShowAddNewCounterCommand = new MvxAsyncCommand(ShowAddNewCounter);
}
public GenerateViewModel(IMvxMessenger messenger, IDisplayDimensionsService displayDimensionsService,
IMandelbrotTaskGenerator mandelbrotTaskGenerator)
{
_displayDimensionsService = displayDimensionsService;
_mandelbrotTaskGenerator = mandelbrotTaskGenerator;
_mvxSubscriptionToken = messenger.SubscribeOnMainThread <TickMessage>(OnTick);
_autoPlay = true;
}
public AddItemViewModel(ILocationService locationService, IMvxMessenger messenger, IMvxPictureChooserTask pictureChooserTask, IItemService itemService, IImageStorageService imageStore)
{
_locationService = locationService;
_pictureChooserTask = pictureChooserTask;
_itemService = itemService;
_imageStore = imageStore;
_token = messenger.SubscribeOnMainThread <LocationMessage>(OnLocationMessage);
GetInitialLocation();
}
public ProductsViewModel(IMvxNavigationService navigationService, IErpService service, IMvxMessenger messenger, IAuthenticationService authenticationService)
{
this.navigationService = navigationService;
this.service = service;
this.CurrentUserName = authenticationService.UserName;
this.productUpdatedMessageToken = messenger.SubscribeOnThreadPoolThread <ProductUpdatedMessage>(OnProductUpdated);
this.productDeletedMessageToken = messenger.SubscribeOnMainThread <ProductDeletedMessage>(OnProductDeleted);
this.ProductStockCount = 12800;
ExpectedStockQuantitues = new NameValuePair[]
{
new NameValuePair(DateTime.Today.AddMonths(-2).ToString("MMMM"), 1500),
new NameValuePair(DateTime.Today.AddMonths(-1).ToString("MMMM"), 1400),
new NameValuePair(DateTime.Today.ToString("MMMM"), 1600),
};
ActualStockQuantitues = new NameValuePair[]
{
new NameValuePair(DateTime.Today.AddMonths(-2).ToString("MMMM"), 1723),
new NameValuePair(DateTime.Today.AddMonths(-1).ToString("MMMM"), 1413),
new NameValuePair(DateTime.Today.ToString("MMMM"), 2313),
};
TopStockProducts = new NameValuePair[]
{
new NameValuePair("A", 1423),
new NameValuePair("B", 2621),
new NameValuePair("C", 1724),
new NameValuePair("D", 2223),
new NameValuePair("E", 1383)
};
TopSoldProducts = new NameValuePair[]
{
new NameValuePair("A", 14100),
new NameValuePair("B", 12200),
new NameValuePair("C", 11300)
};
StorageLocations = new NameValuePair[]
{
new NameValuePair("New York", 0.35),
new NameValuePair("Ohio", 0.30),
new NameValuePair("California", 0.35),
};
currentLayoutMode = LayoutMode.Grid;
ToggleLayoutModeCommand = new Command <LayoutMode?>(ChangeLayoutMode);
this.CreateProductCommand = new MvxCommand(OnCreateProduct);
this.EditProductCommand = new MvxCommand <Product>(OnEditProduct);
this.DeleteProductCommand = new MvxAsyncCommand <Product>(OnDeleteProduct);
this.SearchCommand = new MvxAsyncCommand(OnSearch);
this.AboutCommand = new MvxCommand(ShowAboutPage);
this.listDescription = "All Products";
}
public RootViewModel(IAuthenticationService authService, IMvxMessenger messenger)
{
_authService = authService;
_sessionChangedToken = messenger.SubscribeOnMainThread<SessionStateChangedMessage>((m) =>
{
reloadFavorites();
});
this.UserStoreViewModel = MvxToolbox.LoadViewModel<BaseUserStoreViewModel>();
}
public override async Task Initialize()
{
await LoadItems();
// Listen to any account changes to refresh the user interface
_mvxMessenger.SubscribeOnMainThread <AccountStatusChangeMessage>(async m =>
{
await LoadItems();
});
}
protected override void OnAttachedTo(BindableObject bindable)
{
if (bindable != null)
{
_sliderViews = bindable as IContainSliderViews;
_messenger = Mvx.IoCProvider.Resolve <IMvxMessenger>();
_token = _messenger.SubscribeOnMainThread <SlidersDataMessage>(PresentData);
}
base.OnAttachedTo(bindable);
}
public AddViewModel(
ICollectionService collectionService,
ILocationService locationService,
IMvxMessenger messenger,
IMvxPictureChooserTask pictureChooserTask, IMvxFileStore fileStore)
{
_collectionService = collectionService;
_locationService = locationService;
_pictureChooserTask = pictureChooserTask;
_fileStore = fileStore;
_token = messenger.SubscribeOnMainThread <LocationMessage>(OnLocation);
GetInitialLocation();
}
public AddViewModel(
ICollectionService collectionService,
ILocationService locationService,
IMvxMessenger messenger,
IMvxPictureChooserTask pictureChooserTask, IMvxFileStore fileStore)
{
_collectionService = collectionService;
_locationService = locationService;
_pictureChooserTask = pictureChooserTask;
_fileStore = fileStore;
_token = messenger.SubscribeOnMainThread<LocationMessage>(OnLocation);
GetInitialLocation();
}
public async override void Start()
{
if (await synchronisationService.AuthorizeTokenSynchronisationAsync())
{
await Task.Run(RefreshToolRoadsAsync);
}
else
{
Close(this);
ShowViewModel <LoginViewModel>();
return;
}
base.Start();
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <LocationMessage>(x => Location = x.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <StatusMessage>(x => StatusString = x.Data.ToString(), MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <MotionMessage>(x => MotionType = x.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <LogUpdated>((s) => LogText = Log._messageLog.ToString(), MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <GeoWatcherStatusMessage>((s) => IsBound = s.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <CurrentTollpointChangedMessage>((s) => CurrentWaypointString = string.Join("\n", s.Data?.Select(x => x.Name)), MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <TollRoadChangedMessage>((s) => TollRoadString = s.Data?.Name, MvxReference.Strong));
if (_geoWatcher.Location != null)
{
Location = _geoWatcher.Location;
}
LogText = Log._messageLog.ToString();
StatusString = _track.TollStatus.ToString();
TollRoadString = waypointChecker.TollRoad?.Name;
if (waypointChecker.TollPointsInRadius != null)
{
CurrentWaypointString = string.Join("\n", waypointChecker.TollPointsInRadius?.Select(x => x.Name));
}
}
public override void Start()
{
base.Start();
Task.Run(RefreshToolRoads);
try
{
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <LocationMessage>(x => Location = x.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <StatusMessage>(x => StatusString = x.Data.ToString(), MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnThreadPoolThread <MotionMessage>(x => MotionType = x.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <DistanceToNearestTollpoint>((s) => Distance = s.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <GeoWatcherStatusMessage>((s) => IsBound = s.Data, MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <CurrentTollpointChangedMessage>((s) => NearestTollpointsString = string.Join("\n", s.Data?.Select(x => x.Name)), MvxReference.Strong));
_tokens.Add(_messenger.SubscribeOnMainThread <TollRoadChangedMessage>((s) => TollRoadString = s.Data?.Name, MvxReference.Strong));
IsBound = _geoWatcher.IsBound;
if (_geoWatcher.Location != null)
{
Location = _geoWatcher.Location;
}
//LogText = Log._messageLog.ToString();
StatusString = _track.TollStatus.ToString();
TollRoadString = Mvx.Resolve <IWaypointChecker>().TollRoad?.Name;
Distance = Mvx.Resolve <IWaypointChecker>().DistanceToNearestTollpoint;
if (Mvx.Resolve <IWaypointChecker>().TollPointsInRadius != null)
{
NearestTollpointsString = string.Join("\n", Mvx.Resolve <IWaypointChecker>().TollPointsInRadius?.Select(x => x.Name));
}
}
catch (Exception ex)
{
Debug.WriteLine("Message: {0} StackTrace: {1}", ex.Message, ex.StackTrace);
}
}
public AddProductViewModel(IMvxMessenger messenger, IStateService stateService)
{
_messenger = messenger;
_stateService = stateService;
SaveProductCommand = new MvxCommand(SaveProductAction,
SaveProductCanExecute);
_selectedListChangedToken = _messenger.
SubscribeOnMainThread <SelectedListChangedMessage>(
SelectedListChangedMessageAction);
List = _stateService.SelectedList;
}
public ProductsViewModel(IMvxMessenger messenger, IStateService stateService, INotificationService notificationService)
{
_messenger = messenger;
_stateService = stateService;
_notificationService = notificationService;
AddProductCommand = new MvxCommand(AddProductAction);
CleanupCommand = new AsyncCommand(CleanupAction, () => { /* no action */ });
_selectedListChangedToken = _messenger.SubscribeOnMainThread <
SelectedListChangedMessage>(SelectedListChangedMessageAction);
List = _stateService.SelectedList;
}
public void InitialiseShell <TShellMenuSelectedMessage>(MasterDetailPage shellPage, Type menuViewModelType, Type initialDetailViewModelType, IShellNavigationPageInitialiser shellNavigationPageInitialiser = null)
where TShellMenuSelectedMessage : ShellMenuSelectedMessage
{
this.ShellPage = shellPage;
this.shellNavigationPageInitialiser = shellNavigationPageInitialiser;
this.contentPages = new Dictionary <Type, Page>();
this.ShellPage.Master = ResolvePage(menuViewModelType);
ShowContent(initialDetailViewModelType);
messenger = Mvx.Resolve <IMvxMessenger>();
subscriptionToken = messenger.SubscribeOnMainThread <TShellMenuSelectedMessage>(MenuSelected);
}
public MainView() : base("MainView", null)
{
IMvxMessenger messenger = Mvx.Resolve <IMvxMessenger>();
_alertToken = messenger.SubscribeOnMainThread <AlertMessage>(OnAlertMessage);
_titleToken = messenger.Subscribe <ViewTitleMessage>(OnViewTitleMessage);
AlertItem.Init();
AlertItem.Alerts[AlertType.notification].Button.Clicked += (sender, e) => { ViewModel.NavigateToAsync(2); };
AlertItem.Alerts[AlertType.location].Button.Clicked += (sender, e) => { ViewModel.NavigateToAsync(3); };
HamburgerItem.Init();
HamburgerItem.Button.Clicked += (sender, e) => { PerformTableTransition(); };
}
public CountersViewModel(ICountersService service,
IMvxMessenger messenger, //the messenger come from a construcot parameter
IMvxNavigationService navigationService) //Injects and stores an instance of the MvvmCross navigation service
{
token = messenger
.SubscribeOnMainThread <CountersChangedMessage>
(async m => await LoadCounters()); //Subscribes to all CountersChangedMessage messages on the UI thread
this.service = service;
Counters = new ObservableCollection <CountrViewModel>(); //The Counters property is an ObservableCollection of CounterViewModel
this.navigationService = navigationService;
ShowAddNewCounterCommand = new MvxAsyncCommand(ShowAddNewCounter); //Creates the new command
}
public BaseUserStoreViewModel(IAuthenticationService authService, IMvxMessenger messenger )
:base(authService, messenger)
{
this.ShouldSubscribeToSessionChange = true;
_storeChangeToken = messenger.SubscribeOnMainThread<StoreChangedMessage>((message) =>
{
//If the changed store is related to current user then refetch the user store to reflect the change
if(message.Store != null && this.CurrentUser != null &&
message.Store.OwnerID == this.CurrentUser.ID)
{
reloadUserStore();
}
});
PropertyChanged += propertyChanged;
}
public LocationViewModel(IMvxNavigationService navigationService, IDataService dataService,
ILocationService locationService, IFilterService filterService, IMvxMessenger messenger)
{
_navigationService = navigationService;
_dataService = dataService;
_filterService = filterService;
_token = messenger.SubscribeOnMainThread <LocationMessage>(OnLocationMessage);
Locations = Task.Run(() => _dataService.GetCities()).Result;
if (_filterService.Cinemas != null || _filterService.City != null)
{
_locationSet = true;
}
InitCommands();
}
public Guid Subscribe(Action <Notification> OnReceiveNotification, string tag)
{
if (_messenger.HasSubscriptionsForTag <NotificationMessage>(tag))
{
return(Guid.Empty);
}
var subscription = _messenger.SubscribeOnMainThread <NotificationMessage>((msg) =>
{
OnReceiveNotification(msg.Notification);
}, MvxReference.Strong);
_subscriptionToken.Add(subscription.Id, subscription);
return(subscription.Id);
}
/// <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>
/// <param name="messenger">Messenger Instance</param>
/// <param name="settingsManager">Instance of a SettingsManager</param>
protected StatisticViewModel(DateTime startDate, DateTime endDate, IMvxMessenger messenger, ISettingsManager settingsManager)
{
StartDate = startDate;
EndDate = endDate;
BackgroundColor = settingsManager.Theme == AppTheme.Dark
? new SKColor(0, 0, 0)
: SKColor.Parse("#EFF2F5");
token = messenger.SubscribeOnMainThread <DateSelectedMessage>(message =>
{
StartDate = message.StartDate;
EndDate = message.EndDate;
Load();
});
}
public OrderDetailViewModel(Services.IErpService erpService, Services.IContextService contextService, IMvxNavigationService navigationService, IMvxMessenger messenger, IAuthenticationService authenticationService)
{
this.erpService = erpService;
this.contextService = contextService;
this.navigationService = navigationService;
this.messenger = messenger;
this.CurrentUserName = authenticationService.UserName;
this.BeginEditCommand = new MvxAsyncCommand(OnBeginEditOrder);
this.DeleteCommand = new MvxAsyncCommand(OnDeleteOrder);
this.CommitCommand = new MvxAsyncCommand(OnCommitEditOrder);
this.CancelCommand = new MvxAsyncCommand(OnCancel);
this.AllProducts = new Telerik.XamarinForms.Common.ObservableItemCollection <OrderDetail>();
this.AllProducts.ItemPropertyChanged += OnAllProductsItemPropertyChanged;
this.orderSearchPerformedMessageToken = messenger
.SubscribeOnMainThread <OrderSearchPerformedMessage>((obj) => IsSearchEmpty = obj.IsEmpty);
this.emptyImageName = "Item_add.png";
}
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;
}
protected override void OnViewModelSet()
{
//this.Parent.RequestWindowFeature (WindowFeatures.NoTitle);
//RequestWindowFeature (WindowFeatures.NoTitle);
homeViewModel = (HomeViewModel)ViewModel;
SetContentView (Resource.Layout.Content_Frame);
MenuId = Resource.Menu.HomeMenu;
LegacyBar = FindViewById<LegacyBar.Library.Bar.LegacyBar>(Resource.Id.actionbar);
//LegacyBar.SetHomeLogo(Resource.Drawable.jabbr_home_icon);
AddHomeAction (() => {
slidingMenu.Toggle();
}, Resource.Drawable.jabbr_home_icon);
LegacyBar.Click += (sender, e) => {
slidingMenu.Toggle();
};
LegacyBar.Title = "JabbR";
slidingMenu = new SlidingMenu (this) {
Mode = MenuMode.LeftRight,
TouchModeAbove = TouchMode.Fullscreen,
BehindOffset = 80,
ShadowWidth = 20,
ShadowDrawableRes = Resource.Drawable.SlidingMenuShadow,
SecondaryShadowDrawableRes = Resource.Drawable.SlidingMenuShadowRight
};
slidingMenu.AttachToActivity (this, SlideStyle.Content);
slidingMenu.SetMenu (Resource.Layout.Menu_Frame);
//slidingMenu.ShadowDrawableRes = Resource.Drawable.SlidingMenuShadow;
menuFragment = new MenuFragment ();
menuFragment.ViewModel = ViewModel;
SupportFragmentManager.BeginTransaction ()
.Replace (Resource.Id.menu_frame, menuFragment).Commit ();
slidingMenu.SetSecondaryMenu (Resource.Layout.UserList_Frame);
//slidingMenu.SecondaryShadowDrawableRes = Resource.Drawable.SlidingMenuShadowRight;
emptyFragment = new EmptyFragment ();
emptyFragment.ViewModel = this.ViewModel;
SupportFragmentManager.BeginTransaction ()
.Replace (Resource.Id.content_frame, emptyFragment).Commit ();
//TODO: Put some kind of default view in the chat fragment space
homeViewModel.PropertyChanged += (sender, e) => {
Console.WriteLine("PropertyChanged: "+ e.PropertyName);
if (e.PropertyName == "CurrentRoom")
{
if (homeViewModel.CurrentRoom == null)
{
if (emptyFragment == null)
emptyFragment = new EmptyFragment();
chatFragment = null;
SupportFragmentManager.BeginTransaction ()
.Replace (Resource.Id.content_frame, emptyFragment).Commit ();
LegacyBar.Title = "JabbR";
showActions = false;
ToggleActions();
userListFragment.ViewModel = null;
SupportFragmentManager.BeginTransaction ()
.Replace (Resource.Id.userlist_frame, userListFragment).Commit ();
return;
}
showActions = true;
if (chatFragment == null)
{
chatFragment = new ChatFragment();
chatFragment.ViewModel = homeViewModel.CurrentRoom;
SupportFragmentManager.BeginTransaction()
.Replace(Resource.Id.content_frame, chatFragment).Commit();
}
else
{
chatFragment.ViewModel = homeViewModel.CurrentRoom;
}
if (userListFragment == null)
{
userListFragment = new UserListFragment();
userListFragment.ViewModel = homeViewModel.CurrentRoom;
SupportFragmentManager.BeginTransaction ()
.Replace (Resource.Id.userlist_frame, userListFragment).Commit ();
}
else
{
userListFragment.ViewModel = homeViewModel.CurrentRoom;
}
ToggleActions();
slidingMenu.Toggle();
this.RunOnUiThread(() => LegacyBar.Title = homeViewModel.CurrentRoom.Room.Name);
}
};
messenger = Mvx.Resolve<IMvxMessenger> ();
_mvxMsgTokUserSelected = messenger.SubscribeOnMainThread<UserSelectedMessage> (msg => {
chatFragment.AppendText("@" + msg.User.Name);
slidingMenu.ShowContent(true);
});
}
public ScanAsMessageViewModel(IMvxMessenger messenger, IWatcher watcher)
{
_watcher = watcher;
_messageToken = messenger.SubscribeOnMainThread<MessageReceived>(MessageRecieved);
}
