private void ClearNavigationStackIfNeed(IDataContext context)
{
if (context == null)
{
context = DataContext.Empty;
}
var backStack = _frame.BackStack;
if (!context.GetData(NavigationConstants.ClearBackStack) || backStack.IsReadOnly)
{
return;
}
for (int index = 0; index < backStack.Count; index++)
{
var vmId = GetViewModelIdFromParameter(backStack[index].Parameter);
var viewModel = _viewModelProvider.TryGetViewModelById(vmId);
if (viewModel != null)
{
var ctx = new DataContext(context);
ctx.AddOrUpdate(NavigationConstants.ViewModel, viewModel);
RaiseNavigated(new RemoveNavigationEventArgs(ctx));
}
backStack.RemoveAt(index);
--index;
}
}
protected override void OnDetached()
{
EventHandler <IObserver, ValueChangedEventArgs> handler = OnBindingSourceValueChanged;
var accessor = Binding.SourceAccessor as ISingleBindingSourceAccessor;
if (accessor == null)
{
var sources = Binding.SourceAccessor.Sources;
for (int index = 0; index < sources.Count; index++)
{
sources[index].ValueChanged -= handler;
}
}
else
{
accessor.Source.ValueChanged -= handler;
}
UpdateSources(true);
lock (_subscribers)
{
// Ensure that all concurrent adds have completed.
}
var context = new DataContext(Binding.Context);
context.AddOrUpdate(BindingConstants.ClearErrors, true);
UpdateErrors(Empty.Array <object>(), context);
}
private bool ClearNavigationStackIfNeed(UIViewController newItem, IDataContext context, bool animated)
{
if (context == null)
{
context = DataContext.Empty;
}
if (context.GetData(NavigationConstants.ClearBackStack) && NavigationController != null)
{
var controllers = NavigationController.ViewControllers;
if (controllers != null)
{
NavigationController.SetViewControllers(new[] { newItem }, animated);
Array.Reverse(controllers);
for (int i = 0; i < controllers.Length; i++)
{
var controller = controllers[i];
if (ReferenceEquals(controller, newItem))
{
continue;
}
var viewModel = controller.DataContext() as IViewModel;
if (viewModel != null)
{
var ctx = new DataContext(context);
ctx.AddOrUpdate(NavigationConstants.ViewModel, viewModel);
RaiseNavigated(controller, NavigationMode.Remove, null, ctx);
}
}
}
return(true);
}
return(false);
}
private void ClearNavigationStack(IDataContext context, Page page, Task task)
{
var navigation = _rootPage.Navigation;
if (navigation == null)
{
return;
}
task.TryExecuteSynchronously(t =>
{
var pages = navigation.NavigationStack.ToList();
pages.Reverse();
for (int i = 0; i < pages.Count; i++)
{
var toRemove = pages[i];
if (toRemove == page)
{
continue;
}
navigation.RemovePage(toRemove);
var viewModel = toRemove.BindingContext as IViewModel;
if (viewModel != null)
{
var ctx = new DataContext(context);
ctx.AddOrUpdate(NavigationConstants.ViewModel, viewModel);
RaiseNavigated(toRemove, null, NavigationMode.Remove, ctx);
}
}
});
}
public void Detach(IDataBinding binding)
{
binding.BindingUpdated -= BindingUpdatedDelegate;
var errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider == null)
return;
var context = new DataContext(binding.Context);
context.AddOrUpdate(BindingConstants.ClearErrors, true);
SetErrors(errorProvider, binding, Empty.Array<object>(), context);
}
public void Detach(IDataBinding binding)
{
binding.BindingUpdated -= BindingUpdatedDelegate;
var errorProvider = BindingServiceProvider.ErrorProvider;
if (errorProvider == null)
{
return;
}
var context = new DataContext(binding.Context);
context.AddOrUpdate(BindingConstants.ClearErrors, true);
SetErrors(errorProvider, binding, Empty.Array <object>(), context);
}
private void ClearBackStack(Intent intent, IViewModel viewModel, bool bringToFront, IDataContext dataContext)
{
if (intent != null)
{
if (AndroidToolkitExtensions.IsApiLessThanOrEqualTo10)
{
intent.AddFlags(ActivityFlags.NewTask | ActivityFlags.ClearTop);
}
else
{
intent.AddFlags(ActivityFlags.NewTask | ActivityFlags.ClearTask);
}
}
var message = new MvvmActivityMediator.FinishActivityMessage();
if (bringToFront)
{
if (viewModel != null)
{
message.IgnoredViewModels = new[] { viewModel }
}
;
}
EventAggregator.Publish(this, message);
if (message.FinishedViewModels != null)
{
message.FinishedViewModels.Reverse();
foreach (var vm in message.FinishedViewModels)
{
var ctx = new DataContext(dataContext);
ctx.AddOrUpdate(NavigationConstants.ViewModel, vm);
RaiseNavigated(vm, NavigationMode.Remove, null, ctx);
}
}
}
#endregion
#region Implementation of INavigationService
object INavigationService.CurrentContent => AndroidToolkitExtensions.CurrentActivity;
private void ClearNavigationStack(IDataContext context)
{
var backStack = _frame.BackStack;
if (backStack.IsReadOnly)
{
return;
}
for (int index = 0; index < backStack.Count; index++)
{
var vmId = GetViewModelIdFromParameter(backStack[index].Parameter);
var viewModel = _viewModelProvider.TryGetViewModelById(vmId);
if (viewModel != null)
{
var ctx = new DataContext(context);
ctx.AddOrUpdate(NavigationConstants.ViewModel, viewModel);
RaiseNavigated(new NavigationEventArgs(MugenMvvmToolkit.Models.NavigationMode.Remove, ctx, null, null));
}
backStack.RemoveAt(index);
--index;
}
}
public IList<IDataContext> Parse(object target, string bindingExpression, IList<object> sources, IDataContext context)
{
Should.NotBeNull(bindingExpression, nameof(bindingExpression));
if (context == null)
context = DataContext.Empty;
KeyValuePair<KeyValuePair<string, int>, Action<IDataContext>[]>[] bindingValues;
lock (_cache)
{
if (!_cache.TryGetValue(bindingExpression, out bindingValues))
{
try
{
if (ReferenceEquals(context, DataContext.Empty))
context = _defaultContext;
context.AddOrUpdate(BindingBuilderConstants.Target, target);
_context = context;
_expression = Handle(bindingExpression, context);
_tokenizer = CreateTokenizer(Expression);
_memberVisitor.Context = context;
var value = ParseInternal()
.Select((pair, i) => new KeyValuePair<KeyValuePair<string, int>, Action<IDataContext>[]>(new KeyValuePair<string, int>(pair.Key, i), pair.Value))
.ToList();
value.Sort(MemberComparison);
bindingValues = value.ToArray();
if (!context.Contains(BindingBuilderConstants.NoCache))
_cache[bindingExpression] = bindingValues;
}
finally
{
if (ReferenceEquals(_defaultContext, context))
_defaultContext.Clear();
_tokenizer = null;
_expression = null;
_context = null;
_memberVisitor.Context = null;
}
}
}
var result = new IDataContext[bindingValues.Length];
if (sources != null && sources.Count > 0)
{
for (int i = 0; i < bindingValues.Length; i++)
{
var pair = bindingValues[i];
var dataContext = new DataContext(context);
dataContext.AddOrUpdate(BindingBuilderConstants.Target, target);
if (pair.Key.Value < sources.Count)
{
object src = sources[pair.Key.Value];
if (src != null)
dataContext.Add(BindingBuilderConstants.Source, src);
}
var actions = pair.Value;
for (int j = 0; j < actions.Length; j++)
actions[j].Invoke(dataContext);
result[i] = dataContext;
}
}
else
{
for (int i = 0; i < bindingValues.Length; i++)
{
var actions = bindingValues[i].Value;
var dataContext = new DataContext(context);
dataContext.AddOrUpdate(BindingBuilderConstants.Target, target);
for (int j = 0; j < actions.Length; j++)
actions[j].Invoke(dataContext);
result[i] = dataContext;
}
}
return result;
}
protected override void OnDetached()
{
EventHandler<IObserver, ValueChangedEventArgs> handler = OnBindingSourceValueChanged;
var accessor = Binding.SourceAccessor as ISingleBindingSourceAccessor;
if (accessor == null)
{
var sources = Binding.SourceAccessor.Sources;
for (int index = 0; index < sources.Count; index++)
sources[index].ValueChanged -= handler;
}
else
accessor.Source.ValueChanged -= handler;
UpdateSources(true);
lock (_subscribers)
{
// Ensure that all concurrent adds have completed.
}
var context = new DataContext(Binding.Context);
context.AddOrUpdate(BindingErrorProviderBase.ClearErrorsConstant, true);
UpdateErrors(Empty.Array<object>(), context);
}
public IViewModel RestoreViewModel(IDataContext viewModelState, IDataContext dataContext, bool throwOnError)
{
try
{
dataContext = new DataContext(dataContext ?? DataContext.Empty);
if (viewModelState == null)
{
viewModelState = DataContext.Empty;
}
else
{
dataContext.Merge(viewModelState);
}
IViewModel viewModel;
if (!dataContext.GetData(InitializationConstants.IgnoreViewModelCache))
{
Guid id;
if (viewModelState.TryGetData(ViewModelConstants.Id, out id))
{
viewModel = GetOrAddCachedViewModel(id).GetViewModel();
if (viewModel != null)
{
return(viewModel);
}
}
}
CachedViewModel restoredParentViewModel = null;
IViewModel parentViewModel = null;
Guid idParent;
if (viewModelState.TryGetData(ViewModelConstants.IdParent, out idParent))
{
restoredParentViewModel = GetOrAddCachedViewModel(idParent);
parentViewModel = restoredParentViewModel.GetViewModel();
if (parentViewModel != null)
{
dataContext.AddOrUpdate(InitializationConstants.ParentViewModel, parentViewModel);
}
}
var restoring = Restoring;
if (restoring != null)
{
var args = new ViewModelRestoringEventArgs {
Context = dataContext, State = viewModelState
};
restoring(this, args);
dataContext = args.Context ?? DataContext.Empty;
}
viewModel = RestoreViewModelInternal(viewModelState, dataContext);
if (viewModel != null)
{
if (restoredParentViewModel != null && parentViewModel == null)
{
restoredParentViewModel.AddChildViewModel(viewModel);
}
OnViewModelRestored(viewModel, viewModelState, dataContext);
var restored = Restored;
if (restored != null)
{
var args = new ViewModelRestoredEventArgs(viewModel)
{
Context = dataContext,
State = viewModelState
};
restored(this, args);
}
Tracer.TraceViewModel(ViewModelLifecycleType.Restored, viewModel);
if (ReferenceEquals(viewModelState, DataContext.Empty))
{
Tracer.Warn("The view model '{0}' was restored without state.", viewModel);
}
return(viewModel);
}
if (throwOnError)
{
throw ExceptionManager.ViewModelCannotBeRestored();
}
}
catch (Exception e) when(!throwOnError)
{
Tracer.Warn(e.Flatten(true));
}
return(null);
}
public bool Navigate(IViewMappingItem source, string parameter, IDataContext dataContext)
{
Should.NotBeNull(source, nameof(source));
Should.NotBeNull(dataContext, nameof(dataContext));
bool bringToFront;
dataContext.TryGetData(NavigationProvider.BringToFront, out bringToFront);
if (!RaiseNavigating(new NavigatingCancelEventArgs(source, bringToFront ? NavigationMode.Refresh : NavigationMode.New, parameter, dataContext)))
{
return(false);
}
_newContext = dataContext;
bool clearBackStack = dataContext.GetData(NavigationConstants.ClearBackStack);
var activity = AndroidToolkitExtensions.CurrentActivity;
var context = activity ?? Application.Context;
var intent = new Intent(context, source.ViewType);
if (activity == null)
{
intent.AddFlags(ActivityFlags.NewTask);
}
else if (clearBackStack)
{
if (AndroidToolkitExtensions.IsApiLessThanOrEqualTo10)
{
intent.AddFlags(ActivityFlags.NewTask | ActivityFlags.ClearTop);
}
else
{
intent.AddFlags(ActivityFlags.NewTask | ActivityFlags.ClearTask);
}
var message = new MvvmActivityMediator.FinishActivityMessage();
if (bringToFront)
{
var viewModel = dataContext.GetData(NavigationConstants.ViewModel);
if (viewModel != null)
{
message.IgnoredViewModels = new[] { viewModel }
}
;
}
ServiceProvider.EventAggregator.Publish(this, message);
if (message.FinishedViewModels != null)
{
message.FinishedViewModels.Reverse();
foreach (var vm in message.FinishedViewModels)
{
var ctx = new DataContext(dataContext);
ctx.AddOrUpdate(NavigationConstants.ViewModel, vm);
RaiseNavigated(vm, NavigationMode.Remove, null, ctx);
}
}
}
if (parameter != null)
{
intent.PutExtra(ParameterId, parameter);
}
if (bringToFront)
{
//http://stackoverflow.com/questions/20695522/puzzling-behavior-with-reorder-to-front
//http://code.google.com/p/android/issues/detail?id=63570#c2
bool closed = false;
if (!clearBackStack && AndroidToolkitExtensions.IsApiGreaterThanOrEqualTo19)
{
var viewModel = dataContext.GetData(NavigationConstants.ViewModel);
var activityView = viewModel?.GetCurrentView <object>() as Activity;
if (activityView != null && activityView.IsTaskRoot)
{
var message = new MvvmActivityMediator.FinishActivityMessage(viewModel);
ServiceProvider.EventAggregator.Publish(this, message);
closed = message.IsFinished;
}
}
if (!closed)
{
intent.AddFlags(ActivityFlags.ReorderToFront);
}
}
StartActivity(context, intent, source, dataContext);
return(true);
}
/// <summary>
/// Starts the current bootstrapper.
/// </summary>
public virtual Page Start(bool wrapToNavigationPage = true)
{
if (Current != null && !ReferenceEquals(Current, this))
return Current.Start(wrapToNavigationPage);
InitializationContext = new DataContext(InitializationContext);
InitializationContext.AddOrUpdate(WrapToNavigationPageConstant, wrapToNavigationPage);
if (_mainViewModel == null || _mainViewModel.IsDisposed)
{
Initialize();
Type viewModelType = GetMainViewModelType();
_mainViewModel = CreateMainViewModel(viewModelType);
}
var view = (Page)ViewManager.GetOrCreateView(_mainViewModel, true, new DataContext(InitializationContext));
NavigationPage page = view as NavigationPage ?? CreateNavigationPage(view);
if (page == null)
return view;
INavigationService navigationService;
if (!IocContainer.TryGet(out navigationService))
{
navigationService = CreateNavigationService();
IocContainer.BindToConstant(navigationService);
}
//Activating navigation provider
INavigationProvider provider;
IocContainer.TryGet(out provider);
navigationService.UpdateRootPage(page);
return page;
}
