protected virtual void InitializeRootPage(IViewModel viewModel, IDataContext context)
{
var mainPage = (Page)ViewManager.GetOrCreateView(viewModel, true, context);
var navigationPage = mainPage as NavigationPage;
if (WrapToNavigationPage)
{
navigationPage = CreateNavigationPage(mainPage);
}
var isRoot = navigationPage == null || ReferenceEquals(mainPage, navigationPage);
if (navigationPage != null)
{
INavigationService navigationService;
if (!ToolkitServiceProvider.TryGet(out navigationService))
{
navigationService = CreateNavigationService();
ToolkitServiceProvider.IocContainer.BindToConstant(navigationService);
}
//Activating navigation provider if need
INavigationProvider provider;
ToolkitServiceProvider.TryGet(out provider);
navigationService.UpdateRootPage(navigationPage, viewModel);
mainPage = navigationPage;
}
Application.Current.MainPage = mainPage;
EventHandler <Page, CancelEventArgs> handler = OnBackButtonPressed;
XamarinFormsToolkitExtensions.BackButtonPressed -= handler;
var mode = NavigationMode.New;
if (isRoot)
{
XamarinFormsToolkitExtensions.BackButtonPressed += handler;
if (viewModel.Settings.State.Contains(IsRootConstant))
{
mode = NavigationMode.Refresh;
}
else
{
viewModel.Settings.State.AddOrUpdate(IsRootConstant, null);
}
viewModel.Settings.Metadata.AddOrUpdate(ViewModelConstants.CanCloseHandler, CanCloseRootViewModel);
NavigationDispatcher.OnNavigated(new NavigationContext(NavigationType.Page, mode, null, viewModel, this, context));
}
else
{
mainPage.SetNavigationParameter(NavigationProvider.GenerateNavigationParameter(viewModel));
ToolkitServiceProvider.Get <INavigationProvider>().Restore(context);
}
}
protected virtual void SaveState()
{
if (_presenter == null && !_presenterActivated)
{
_presenter = ToolkitServiceProvider.Get <IViewModelPresenter>() as IRestorableViewModelPresenter;
_presenterActivated = true;
}
_presenter?.SaveState();
}
public SinglePathObserver([NotNull] object source, [NotNull] IBindingPath path, bool ignoreAttachedMembers, bool hasStablePath, bool observable, bool optional)
: base(source, path)
{
Should.BeSupported(path.IsSingle, "The SinglePathObserver supports only single path members.");
_ignoreAttachedMembers = ignoreAttachedMembers;
_ref = ToolkitServiceProvider.WeakReferenceFactory(this);
_hasStablePath = hasStablePath;
_observable = observable;
_optional = optional;
}
protected T Get <T>()
{
var viewModel = DataContext as IViewModel;
if (viewModel == null)
{
return(ToolkitServiceProvider.Get <T>());
}
return(viewModel.GetIocContainer(true).Get <T>());
}
public FrameworkElementBindingContext(FrameworkElement element)
{
_sourceReference = ToolkitServiceProvider.WeakReferenceFactory(element);
element.DataContextChanged += RaiseDataContextChanged;
if (ListenUnloadEvent)
{
element.Unloaded += ElementOnUnloaded;
}
_isUnset = IsUnset(element);
}
public MultiPathObserver([NotNull] object source, [NotNull] IBindingPath path, bool ignoreAttachedMembers, bool hasStablePath, bool observable, bool optional)
: base(source, path)
{
Should.BeSupported(!path.IsEmpty, "The MultiPathObserver doesn't support the empty path members.");
_listeners = new List <IDisposable>(path.Parts.Count - 1);
_ignoreAttachedMembers = ignoreAttachedMembers;
_lastMemberListener = new LastMemberListener(ToolkitServiceProvider.WeakReferenceFactory(this));
_hasStablePath = hasStablePath;
_observable = observable;
_optional = optional;
}
public MvvmViewControllerMediator([NotNull] UIViewController viewController)
{
Should.NotBeNull(viewController, nameof(viewController));
_viewController = ToolkitServiceProvider.WeakReferenceFactory(viewController);
_canDispose = true;
var viewModel = viewController.DataContext() as IViewModel;
if (viewModel == null || !viewModel.Settings.Metadata.Contains(ViewModelConstants.StateNotNeeded))
{
viewController.InititalizeRestorationIdentifier();
}
}
private object InvokeInternal(IOperationResult result)
{
var type = Type.GetType(TargetType, true);
var flags = MemberFlags.Public | MemberFlags.NonPublic |
(IsStatic ? MemberFlags.Static : MemberFlags.Instance);
var method = type.GetMethodsEx(flags).First(FilterMethod);
var viewModels = CollectViewModels(result);
var items = new Dictionary <Type, object>();
if (result.Source != null)
{
items[result.Source.GetType()] = result.Source;
}
object[] args;
if (FirstParameterSource)
{
var parameter = method.GetParameters()[0];
object firstParam;
if (!items.TryGetValue(parameter.ParameterType, out firstParam))
{
var viewModel = viewModels.FirstOrDefault(model => model.GetType() == parameter.ParameterType);
firstParam = viewModel ?? result.Source;
}
args = new[] { firstParam, result };
}
else
{
args = new object[] { result }
};
if (IsStatic)
{
return(method.InvokeEx(null, args));
}
object target = Target;
if (target == null)
{
if (!items.TryGetValue(type, out target))
{
target = ToolkitServiceProvider.GetOrCreateDefault(type);
items[type] = target;
}
}
if (Snapshots != null)
{
foreach (var fieldSnapshot in Snapshots)
{
fieldSnapshot.Restore(type, target, items, viewModels, null, result);
}
}
return(method.InvokeEx(target, args));
}
public BindableObjectBindingContext(BindableObject element)
{
_sourceReference = ToolkitServiceProvider.WeakReferenceFactory(element);
if (IsWindows())
{
element.BindingContextChanged += RaiseDataContextChangedWindows;
}
else
{
element.BindingContextChanged += RaiseDataContextChanged;
}
}
private bool InitializeEventAggregator(bool required)
{
if (_localEventAggregator != null)
{
return(true);
}
if (!required)
{
return(false);
}
Interlocked.CompareExchange(ref _localEventAggregator, ToolkitServiceProvider.InstanceEventAggregatorFactory(this), null);
return(true);
}
protected override bool OnAttached()
{
if (_isTarget)
{
Binding.TargetAccessor.ValueChanging += OnValueChanging;
}
else
{
Binding.SourceAccessor.ValueChanging += OnValueChanging;
}
_timer = new Timer(CallbackInternalDelegate, ToolkitServiceProvider.WeakReferenceFactory(this), Timeout.Infinite, Timeout.Infinite);
return(true);
}
protected virtual object GetView([NotNull] IViewMappingItem viewMapping, [NotNull] IDataContext context)
{
object viewObj = ToolkitServiceProvider.Get(viewMapping.ViewType);
if (ApplicationSettings.ViewManagerDisposeView)
{
ToolkitServiceProvider.AttachedValueProvider.SetValue(viewObj, ViewManagerCreatorPath, null);
}
if (Tracer.TraceInformation)
{
Tracer.Info("The view {0} for the view-model {1} was created.", viewObj.GetType(), viewMapping.ViewModelType);
}
return(viewObj);
}
public ParentSourceValue(object target, RelativeSourceInfo node)
{
_node = node;
_isElementSource = _node.Type == RelativeSourceInfo.ElementSourceType;
_targetReference = ToolkitServiceProvider.WeakReferenceFactory(target);
_value = Empty.WeakReference;
IBindingMemberInfo rootMember = BindingServiceProvider.VisualTreeManager.GetRootMember(target.GetType());
if (rootMember != null)
{
_subscriber = rootMember.TryObserve(target, this);
}
TryHandle(null, null);
}
protected ObserverBase([NotNull] object source, [NotNull] IBindingPath path)
{
Should.NotBeNull(source, nameof(source));
Should.NotBeNull(path, nameof(path));
_path = path;
if (source is ISourceValue)
{
_source = source;
}
else
{
_source = ToolkitServiceProvider.WeakReferenceFactory(source);
}
}
public override void OnDestroy(Action baseOnDestroy)
{
if (Tracer.TraceInformation)
{
Tracer.Info($"OnDestroy activity({Target})");
}
ToolkitServiceProvider.EventAggregator.Unsubscribe(this);
Destroyed?.Invoke(Target, EventArgs.Empty);
_view.ClearBindingsRecursively(true, true, AndroidToolkitExtensions.AggressiveViewCleanup);
_view = null;
if (_metadata != null)
{
_metadata.Clear();
_metadata = null;
}
MenuTemplate.Clear(_menu);
_menu = null;
if (_menuInflater != null)
{
_menuInflater.Dispose();
_menuInflater = null;
}
if (_layoutInflater != null)
{
_layoutInflater.Dispose();
_layoutInflater = null;
}
ToolkitServiceProvider.Get <INavigationService>().OnDestroyActivity(Target, NavigationContext);
base.OnDestroy(baseOnDestroy);
ThreadPool.QueueUserWorkItem(state => AndroidToolkitExtensions.CleanupWeakReferences(true));
AndroidToolkitExtensions.SetCurrentActivity(Target, true);
Target.ClearBindings(false, true);
OptionsItemSelected = null;
ActivityResult = null;
ConfigurationChanged = null;
PostCreate = null;
BackPressing = null;
Created = null;
Started = null;
Paused = null;
SaveInstanceState = null;
Stoped = null;
Restarted = null;
Resume = null;
Destroyed = null;
}
public Task WaitCurrentNavigationAsync(IDataContext context = null)
{
var viewModel = context?.GetData(NavigationConstants.ViewModel);
INavigationProvider provider;
if (viewModel == null)
{
ToolkitServiceProvider.TryGet(out provider);
}
else
{
viewModel.GetIocContainer(true).TryGet(out provider);
}
return(provider?.CurrentNavigationTask ?? Empty.Task);
}
private static void MvvmApplicationOnInitialized(object sender, EventArgs eventArgs)
{
ToolkitServiceProvider.Initialized -= MvvmApplicationOnInitialized;
IViewModelPresenter presenter;
if (ToolkitServiceProvider.TryGet(out presenter))
{
var windowPresenter = presenter.DynamicPresenters.OfType <DynamicViewModelWindowPresenter>().FirstOrDefault();
if (windowPresenter == null)
{
windowPresenter = ToolkitServiceProvider.Get <DynamicViewModelWindowPresenter>();
presenter.DynamicPresenters.Add(windowPresenter);
}
windowPresenter.RegisterMediatorFactory <WindowViewMediator, IWindowView>();
}
}
private void UpdateParent(object target)
{
var oldParent = _parent.Target;
var parent = BindingServiceProvider.VisualTreeManager.GetParent(target);
if (oldParent != parent)
{
if (oldParent != null)
{
GetOrAdd(oldParent).Remove(this);
}
if (parent != null)
{
GetOrAdd(parent).Add(this);
}
_parent = ToolkitServiceProvider.WeakReferenceFactory(parent);
}
}
public MultiViewModel()
{
var collection = new SynchronizedNotifiableCollection <TViewModel>();
var list = ToolkitServiceProvider.TryDecorate(this, collection);
Should.BeOfType <INotifiableCollection <TViewModel> >(list, "DecoratedItemsSource");
_itemsSource = (INotifiableCollection <TViewModel>)list;
collection.AfterCollectionChanged = OnViewModelsChanged;
_propertyChangedWeakEventHandler = ReflectionExtensions.MakeWeakPropertyChangedHandler(this, (model, o, arg3) => model.OnItemPropertyChanged(o, arg3));
var weakReference = ToolkitExtensions.GetWeakReference(this);
_closeViewModelWeakHandler = (dispatcher, vm, arg3) =>
{
var self = (MultiViewModel <TViewModel>)weakReference.Target;
return(self?.CloseViewModel(dispatcher, vm, arg3) ?? Empty.FalseTask);
};
DisposeViewModelOnRemove = ApplicationSettings.MultiViewModelDisposeViewModelOnRemove;
CloseViewModelsOnClose = ApplicationSettings.MultiViewModelCloseViewModelsOnClose;
}
internal ItemsSourceGenerator([NotNull] object view)
{
Should.NotBeNull(view, nameof(view));
var type = view.GetType();
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
_itemTemplateMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(type, AttachedMemberConstants.ItemTemplate, false, false);
#if WINFORMS
_collectionViewManagerMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(type, AttachedMembers.Object.CollectionViewManager, false, false);
ListenDisposeEvent(view as IComponent);
_isTabControl = view is TabControl;
#elif TOUCH
_collectionViewManagerMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(type, AttachedMembers.UIView.CollectionViewManager, false, false);
TryListenController(view as INativeObject);
#endif
}
public void SetOriginalItemsSource <TItemsSource>(TItemsSource originalItemsSource)
where TItemsSource : IList <T>, INotifyCollectionChanged, IList
{
EnsureNotDisposed();
Should.NotBeNull(originalItemsSource, nameof(originalItemsSource));
INotifyCollectionChanging collectionChanging;
if (_originalData != null)
{
collectionChanging = _originalData as INotifyCollectionChanging;
if (collectionChanging != null)
{
collectionChanging.CollectionChanging -= RaiseCollectionChanging;
}
((INotifyCollectionChanged)_originalData).CollectionChanged -= RaiseCollectionChanged;
if (_originalData.Count != 0)
{
originalItemsSource.AddRange(_originalData, true);
}
}
_filterableItemsSource = new FilterableNotifiableCollection <T>(originalItemsSource);
collectionChanging = originalItemsSource as INotifyCollectionChanging;
if (collectionChanging != null)
{
collectionChanging.CollectionChanging += RaiseCollectionChanging;
}
originalItemsSource.CollectionChanged += RaiseCollectionChanged;
_originalData = originalItemsSource;
var list = ToolkitServiceProvider.TryDecorate(this, FilterableItemsSource);
Should.BeOfType <INotifiableCollection <T> >(list, "DecoratedItemsSource");
_itemsSource = (INotifiableCollection <T>)list;
UpdateFilter();
OnPropertyChanged(nameof(ItemsSource));
OnPropertyChanged(nameof(OriginalItemsSource));
RaiseItemsSourceChanged(_itemsSource);
}
protected virtual UIViewController GetViewControllerInternal([NotNull] string restorationIdentifier, [NotNull] Type type,
[NotNull] NSCoder coder, [NotNull] IDataContext context)
{
UIViewController controller = null;
Func <Type, NSCoder, IDataContext, UIViewController> factory = ViewControllerFactory;
if (factory != null)
{
controller = factory(type, coder, context);
}
if (controller == null)
{
if (type == typeof(MvvmNavigationController))
{
controller = new MvvmNavigationController();
}
else
{
controller = (UIViewController)ToolkitServiceProvider.Get(type);
}
}
controller.RestorationIdentifier = restorationIdentifier;
return(controller);
}
public EmptyPathObserver([NotNull] object source, [NotNull] IBindingPath path)
: base(source, path)
{
Should.BeSupported(path.IsEmpty, "The EmptyPathObserver supports only empty path members.");
_members = new EmptyBindingPathMembers(ToolkitServiceProvider.WeakReferenceFactory(this));
}
private ParentObserver(Element view)
{
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(FindParent(view), Empty.WeakReference, false);
view.PropertyChanged += OnPropertyChanged;
}
private View OnViewCreated(View view, string name, Context context, IAttributeSet attrs)
{
if (name == "fragment" || view != null && _lastCreatedView.Target == view)
{
return(view);
}
ViewResult viewResult;
if (view == null)
{
var type = TypeCache <View> .Instance.GetTypeByName(name, true, false);
if (type == null)
{
return(null);
}
viewResult = _viewFactory.Create(type, context, attrs);
view = viewResult.View;
}
else
{
var type = TypeCache <View> .Instance.GetTypeByName(name, true, false);
if (type != null && !type.IsInstanceOfType(view))
{
try
{
view = (View)JavaCastMethod.MakeGenericMethod(type).Invoke(null, new object[] { view });
}
catch
{
;
}
}
viewResult = _viewFactory.Initialize(view, attrs);
}
var viewCreated = AndroidToolkitExtensions.ViewCreated;
if (viewCreated != null)
{
view = viewCreated(view, name, context, attrs);
}
string bind = null;
if (!viewResult.IsEmpty)
{
view = viewResult.View;
bind = viewResult.Bind;
if (!string.IsNullOrEmpty(bind))
{
if (AndroidToolkitExtensions.CurrentLayoutInflaterResult == null)
{
var manualBindings = view as IManualBindings;
if (manualBindings == null)
{
BindingServiceProvider.BindingProvider.CreateBindingsFromString(view, bind);
}
else
{
manualBindings.SetBindings(bind);
}
}
}
}
if (AndroidToolkitExtensions.CurrentLayoutInflaterResult == null)
{
var viewGroup = view as ViewGroup;
if (viewGroup != null && !viewGroup.IsDisableHierarchyListener())
{
viewGroup.SetOnHierarchyChangeListener(GlobalViewParentListener.Instance);
}
}
else
{
Action <object> postAction;
if (view is ViewGroup)
{
postAction = o =>
{
var vg = (ViewGroup)o;
if (!vg.IsDisableHierarchyListener())
{
vg.SetOnHierarchyChangeListener(GlobalViewParentListener.Instance);
}
};
}
else
{
postAction = null;
}
AndroidToolkitExtensions.CurrentLayoutInflaterResult.AddBindingInfo(view, bind, postAction);
}
_lastCreatedView = ToolkitServiceProvider.WeakReferenceFactory(view);
return(view);
}
private ParentObserver(View view)
{
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(GetParent(view), Empty.WeakReference, false);
}
public bool TryHandle(object sender, object message)
{
var target = GetReferenceValue();
if (target == null)
{
UnsubscribeEventHandler();
return(false);
}
LastContext.AddOrUpdate(BindingConstants.CurrentEventArgs, message);
WeakReference reference = null;
var command = target as ICommand;
if (command != null)
{
if (sender != null)
{
reference = ToolkitServiceProvider.WeakReferenceFactory(sender);
ToolkitExtensions.AddCurrentBindingEventSender(reference);
}
if (_path.IsDebuggable)
{
var parameter = GetCommandParameter(LastContext);
DebugInfo($"Binding invokes command '{command}' with parameter: '{parameter}', event args: '{message}'", new[] { command, parameter, message });
command.Execute(parameter);
}
else
{
command.Execute(GetCommandParameter(LastContext));
}
if (reference != null)
{
ToolkitExtensions.RemoveCurrentBindingEventSender(reference);
}
return(true);
}
var actionValue = target as BindingActionValue;
if (actionValue == null || actionValue.MemberSource.Target == null)
{
UnsubscribeEventHandler();
return(false);
}
if (sender != null)
{
reference = ToolkitServiceProvider.WeakReferenceFactory(sender);
ToolkitExtensions.AddCurrentBindingEventSender(reference);
}
if (_path.IsDebuggable)
{
var args = new[] { GetCommandParameter(LastContext), message, LastContext };
DebugInfo($"Binding invokes member '{actionValue.Member.Path}' with parameter: '{args[0]}', event args: '{message}'", args);
actionValue.TrySetValue(args, out target);
}
else
{
actionValue.TrySetValue(new[] { GetCommandParameter(LastContext), message, LastContext }, out target);
}
if (reference != null)
{
ToolkitExtensions.RemoveCurrentBindingEventSender(reference);
}
return(true);
}
public NavigationItemSelectedListener(BottomNavigationView view)
{
_view = ToolkitServiceProvider.WeakReferenceFactory(view);
}
public WeakOpenedViewModelInfo(IViewModel viewModel, object provider, NavigationType navigationType)
{
_viewModelReference = ToolkitServiceProvider.WeakReferenceFactory(viewModel);
_providerReference = ToolkitServiceProvider.WeakReferenceFactory(provider);
NavigationType = navigationType;
}
protected virtual INavigationService CreateNavigationService(Frame frame)
{
return(new FrameNavigationService(frame, ToolkitServiceProvider.Get <IViewModelProvider>()));
}
