private static LayoutInflaterFactoryWrapper GetWrapper(LayoutInflater inflater, IViewFactory factory)
{
if (factory == null && !ToolkitServiceProvider.TryGet(out factory))
{
factory = new ViewFactory();
}
return(new LayoutInflaterFactoryWrapper(inflater, factory));
}
private static Func <string> GetDisplayNameAccessor(MemberInfo member)
{
if (DisplayNameProvider == null && !ToolkitServiceProvider.TryGet(out DisplayNameProvider))
{
return(() => member.Name);
}
return(DisplayNameProvider.GetDisplayNameAccessor(member));
}
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);
}
}
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>();
}
}
public bool Restore(Type targetType, object target, Dictionary <Type, object> items, ICollection <IViewModel> viewModels, string awaiterResultType, IOperationResult result)
{
var field = targetType.GetFieldEx(Name, MemberFlags.NonPublic | MemberFlags.Public | MemberFlags.Instance);
if (field == null)
{
TraceError(null, targetType);
return(false);
}
switch (FieldType)
{
case BuilderField:
var type = Type.GetType(TypeName, true);
var createMethod = type.GetMethodEx("Create", MemberFlags.NonPublic | MemberFlags.Public | MemberFlags.Static);
var startMethod = type.GetMethodEx("Start", MemberFlags.NonPublic | MemberFlags.Public | MemberFlags.Instance);
if (createMethod == null || startMethod == null || !startMethod.IsGenericMethodDefinition)
{
((IAsyncStateMachine)target).MoveNext();
return(true);
}
var builder = createMethod.Invoke(null, Empty.Array <object>());
SetValue(field, target, builder);
startMethod.MakeGenericMethod(typeof(IAsyncStateMachine))
.Invoke(builder, new[] { target });
break;
case AwaiterField:
var awaiterType = typeof(SerializableAwaiter <>).MakeGenericType(Type.GetType(awaiterResultType, true));
var instance = Activator.CreateInstance(awaiterType, result);
SetValue(field, target, instance);
break;
case AsyncOperationField:
var opType = typeof(AsyncOperation <>).MakeGenericType(Type.GetType(awaiterResultType, true));
var opInstance = (IAsyncOperation)Activator.CreateInstance(opType);
AsyncOperation <object> .TrySetResult(opInstance, result);
SetValue(field, target, opInstance);
break;
case AnonymousClass:
var anonType = Type.GetType(TypeName, true);
object anonClass;
if (!items.TryGetValue(anonType, out anonClass))
{
anonClass = ToolkitServiceProvider.GetOrCreateDefault(anonType);
foreach (var snapshot in Snapshots)
{
snapshot.Restore(anonType, anonClass, items, viewModels, awaiterResultType, result);
}
items[anonType] = anonClass;
}
SetValue(field, target, anonClass);
break;
case NonSerializableField:
object service;
if (State == null)
{
var serviceType = Type.GetType(TypeName, true);
if (!items.TryGetValue(serviceType, out service))
{
if (field.Name.Contains("CachedAnonymousMethodDelegate"))
{
service = field.GetValueEx <object>(target);
}
else if (!ToolkitServiceProvider.TryGet(serviceType, out service))
{
service = field.GetValueEx <object>(target);
TraceError(field, targetType);
}
items[serviceType] = service;
}
}
else
{
var stateManager = ToolkitServiceProvider.OperationCallbackStateManager;
service = stateManager == null ? State : stateManager.RestoreValue(State, field, items, viewModels, result, DataContext.Empty);
}
SetValue(field, target, service);
break;
case SerializableField:
SetValue(field, target, IsType ? Type.GetType((string)State, false) : State);
break;
case ViewModelField:
var viewModel = RestoreViewModel(viewModels, items, result);
if (viewModel == null)
{
TraceError(field, targetType);
return(false);
}
SetValue(field, target, viewModel);
break;
}
return(true);
}
