public override void Close(IMvxViewModel toClose)
{
var root = _window.RootViewController;
var view = Mvx.Resolve<IMvxTouchViewCreator>().CreateView(toClose) as BaseViewController;
var masterView = MasterNavigationController.TopViewController as MasterPanelView;
if (masterView != null && view != null)
{
switch (view.TypeOfView)
{
case ViewType.MenuView:
base.Close(masterView.ViewModel);
break;
case ViewType.SubMenuView:
masterView.MasterContainer.HideMenu();
break;
case ViewType.DetailView:
base.Close(masterView.ViewModel);
break;
case ViewType.SingleView:
base.Close(toClose);
break;
}
}
else
base.Close(toClose);
}
public override void Close(IMvxViewModel toClose)
{
if (_currentModalViewController != null)
{
IMvxTouchView mvxTouchView = _currentModalViewController as IMvxTouchView;
if (mvxTouchView == null)
MvxTrace.Error("Unable to close view - modal is showing but not an IMvxTouchView");
else if (mvxTouchView.ReflectionGetViewModel() != toClose)
{
MvxTrace.Error("Unable to close view - modal is showing but is not the requested viewmodel");
}
else
{
// ISSUE: reference to a compiler-generated method
_currentModalViewController.DismissViewController(true, () => { });
_currentModalViewController = null;
}
return;
}
// We will look across all active navigation stacks to see if we can
// pop our MvxView associated with this MvxViewModel (saves explicitly having to specify)
bool modelClosed = CloseTopView(toClose, CentrePanelUiNavigationController());
if (!modelClosed) modelClosed = CloseTopView(toClose, LeftPanelUiNavigationController());
if (!modelClosed) modelClosed = CloseTopView(toClose, RightPanelUiNavigationController());
if (!modelClosed)
{
MvxTrace.Warning("Don't know how to close this viewmodel - none of topmost views represent this viewmodel");
}
}
public bool TryLoad(Type viewModelType, IDictionary<string, string> parameters, out IMvxViewModel model)
{
model = null;
var constructor = viewModelType
#if NETFX_CORE
.GetTypeInfo().DeclaredConstructors
#else
.GetConstructors()
#endif
.FirstOrDefault(c => c.GetParameters().All(p=> p.ParameterType == typeof(string)));
if (constructor == null)
return false;
var invokeWith = new List<object>();
foreach (var parameter in constructor.GetParameters())
{
string parameterValue = null;
if (parameters == null ||
!parameters.TryGetValue(parameter.Name, out parameterValue))
{
MvxTrace.Trace("Missing parameter in call to {0} - missing parameter {1} - asssuming null", viewModelType,
parameter.Name);
}
invokeWith.Add(parameterValue);
}
model = Activator.CreateInstance(viewModelType, invokeWith.ToArray()) as IMvxViewModel;
return (model != null);
}
public override void Close(IMvxViewModel toClose)
{
if (_currentModalViewController != null)
{
var touchView = _currentModalViewController as IMvxTouchView;
if (touchView == null)
{
MvxTrace.Trace(MvxTraceLevel.Error, "Unable to close view - modal is showing but not an IMvxTouchView");
return;
}
var viewModel = touchView.ReflectionGetViewModel();
if (viewModel != toClose)
{
MvxTrace.Trace(MvxTraceLevel.Error, "Unable to close view - modal is showing but is not the requested viewmodel");
return;
}
_currentModalViewController.DismissModalViewControllerAnimated(true);
_currentModalViewController = null;
return;
}
base.Close(toClose);
}
public CustomDialog(Android.Content.Context context, int layout, IMvxViewModel viewModel)
: this(context, Resource.Style.CustomDialog)
{
this.BindingContext = new MvxAndroidBindingContext(context, (context as IMvxLayoutInflaterHolder));
ViewModel = viewModel;
Init(layout);
}
public override void Close(IMvxViewModel toClose)
{
if (_currentModalViewController != null)
{
var touchView = _currentModalViewController as IMvxTouchView;
if (touchView == null)
{
MvxTrace.Error(
"Unable to close view - modal is showing but not an IMvxTouchView");
return;
}
var viewModel = touchView.ReflectionGetViewModel();
if (viewModel != toClose)
{
MvxTrace.Error(
"Unable to close view - modal is showing but is not the requested viewmodel");
return;
}
var nav = _currentModalViewController.ParentViewController as UINavigationController;
if (nav != null)
nav.DismissViewController(true, () => { });
else
_currentModalViewController.DismissViewController(true, () => { });
_currentModalViewController = null;
return;
}
base.Close(toClose);
}
public override void Close(IMvxViewModel viewModel)
{
if (NavigationProvider == null)
return;
NavigationProvider.Pop();
}
public virtual void Close(IMvxViewModel toClose)
{
var topViewController = this.MasterNavigationController.TopViewController;
if (topViewController == null)
{
MvxTrace.Warning("Don't know how to close this viewmodel - no topmost");
return;
}
var topView = topViewController as IMvxIosView;
if (topView == null)
{
MvxTrace.Warning(
"Don't know how to close this viewmodel - topmost is not a touchview");
return;
}
var viewModel = topView.ReflectionGetViewModel();
if (viewModel != toClose)
{
MvxTrace.Warning(
"Don't know how to close this viewmodel - topmost view does not present this viewmodel");
return;
}
this.MasterNavigationController.PopViewController(true);
}
public virtual void Close(IMvxViewModel toClose)
{
var topInterfaceController = this._interfaceControllers.Last();
if (topInterfaceController == null)
{
MvxTrace.Warning("Don't know how to close this viewmodel - no topmost");
return;
}
var topView = topInterfaceController as IMvxWatchOSView;
if (topView == null)
{
MvxTrace.Warning(
"Don't know how to close this viewmodel - topmost is not a watchOSView");
return;
}
var viewModel = topView.ReflectionGetViewModel();
if (viewModel != toClose)
{
MvxTrace.Warning(
"Don't know how to close this viewmodel - topmost view does not present this viewmodel");
return;
}
topInterfaceController.PopController();
}
public override void Close(IMvxViewModel toClose)
{
var topViewController = _masterNavigationController.TopViewController;
if (topViewController == null)
{
MvxTrace.Trace(MvxTraceLevel.Warning, "Don't know how to close this viewmodel - no topmost");
return;
}
var topView = topViewController as IMvxTouchView;
if (topView == null)
{
MvxTrace.Trace(MvxTraceLevel.Warning,
"Don't know how to close this viewmodel - topmost is not a touchview");
return;
}
var viewModel = topView.ReflectionGetViewModel();
if (viewModel != toClose)
{
MvxTrace.Trace(MvxTraceLevel.Warning,
"Don't know how to close this viewmodel - topmost view does not present this viewmodel");
return;
}
_masterNavigationController.PopViewControllerAnimated(true);
}
public sealed override void Close(IMvxViewModel viewModel)
{
if (_fragmentHostRegistrationSettings.IsTypeRegisteredAsFragment(viewModel.GetType()))
CloseFragment(viewModel);
else
CloseActivity(viewModel);
}
public virtual IMvxViewModel Reload(IMvxViewModel viewModel,
IMvxBundle parameterValues,
IMvxBundle savedState)
{
RunViewModelLifecycle(viewModel, parameterValues, savedState);
return viewModel;
}
// from Stuart Lodge N+1-25
private UIViewController CreateViewFor(IMvxViewModel viewModel, bool navBarHidden)
{
var controller = new UINavigationController();
var screen = this.CreateViewControllerFor(viewModel) as UIViewController;
controller.PushViewController(screen, false);
controller.NavigationBarHidden = navBarHidden;
return controller;
}
private UIViewController CreateTabFor(string title, string imageName, IMvxViewModel viewModel)
{
var controller = new UINavigationController();
var screen = this.CreateViewControllerFor(viewModel) as UIViewController;
SetTitleAndTabBarItem(screen, title, imageName);
controller.PushViewController(screen, false);
return controller;
}
private UIViewController CreateTabFor(string title, string imageName, IMvxViewModel viewModel)
{
Mvx.Trace("CreateTabFor");
var innerView = (UIViewController)this.CreateViewControllerFor(viewModel);
PresentViewController(innerView, false, () => { });
return innerView;
}
private void AddNewTab(string title, IMvxViewModel viewModel)
{
var tabSpec = TabHost.NewTabSpec(title);
tabSpec.SetIndicator(title);
tabSpec.SetContent(this.CreateIntentFor(viewModel));
this.TabHost.AddTab(tabSpec);
}
public virtual void Close(IMvxViewModel toClose)
{
toClose.ActOnRegisteredViews(view =>
{
var activity = view as Activity;
if (activity != null)
activity.Finish();
});
}
public override void Close(IMvxViewModel toClose)
{
if (ParentRootViewController.ViewControllers.Count() > 1)
ParentRootViewController.PopViewController(true);
else if (RootViewController.NavigationController.ViewControllers.Count() > 1)
RootViewController.NavigationController.PopViewController(true);
else
base.Close(toClose);
}
public bool RequestClose(IMvxViewModel toClose)
{
Action action = () =>
{
MvxTrace.TaggedTrace("MacNavigation", "Navigate back requested");
_presenter.Close(toClose);
};
return RequestMainThreadAction(action);
}
private UIViewController CreateTabFor(string title, string imageName, IMvxViewModel viewModel)
{
var innerView = (UIViewController)this.CreateViewControllerFor(viewModel);
innerView.Title = title;
innerView.TabBarItem = new UITabBarItem(
title,
UIImage.FromBundle("Images/Tabs/" + imageName + ".png"),
_createdSoFarCount++);
return innerView;
}
public void AddPreloadedViewModel(string viewModelType, IMvxViewModel viewModel)
{
if (_preloadedViewModels.ContainsKey(viewModelType)) { // replace
// TODO: destroy old instance??
_preloadedViewModels[viewModelType] = viewModel;
}
else {
_preloadedViewModels.Add(viewModelType, viewModel);
}
}
public void Bind(IMvxViewModel viewModel, IMvxBundle parameterValues = null, IMvxBundle savedState = null)
{
var controllerAware = viewModel as IControllerAware;
if (controllerAware != null)
{
var viewModelType = viewModel.GetType();
var name = viewModelType.FullName.Replace("ViewModel", "Controller");
Type controllerType = GetControllerTypeForViewModel(_getCreateableTypes(), viewModel);
if (controllerType == null)
{
throw new ArgumentException(string.Format("Controller for view model {0} cannot be found.", viewModelType));
}
try
{
var controller = (IMvxController) Mvx.IocConstruct(controllerType);
controllerAware.AttachController(controller);
var viewModelAware = controller as IViewModelAware;
if (viewModelAware != null)
{
viewModelAware.AttachViewModel(viewModel);
}
try
{
CallControllerInitMethods(controller, parameterValues);
if (savedState != null)
{
CallReloadStateMethods(controller, savedState);
}
}
catch (Exception ex)
{
MvxTrace.Error("MvxControllers: Problem initialising controller of type {0} - problem {1}",
controllerType.Name, ex.ToLongString());
throw;
}
controller.WaitForInitialize();
}
catch (Exception ex)
{
MvxTrace.Error("MvxControllers: Problem creating controller of type {0} - problem {1}",
controllerType,
ex.ToLongString());
throw;
}
}
}
public override void Close(IMvxViewModel viewModel)
{
if (VmPageMappings.NavigationPage == null)
return;
var page = VmPageMappings.NavigationPage.Navigation.NavigationStack.Single(p => p.BindingContext == viewModel);
page.BindingContext = null;
VmPageMappings.NavigationPage.Navigation.RemovePage(page);
}
public virtual bool CloseChildViewModel(IMvxViewModel viewModel)
{
// current implementation assumes the ViewModel to close is the currently shown ViewController
var navController = SelectedViewController as UINavigationController;
if(navController != null)
{
navController.PopViewController(true);
return true;
}
return false;
}
public IMvxViewModel GetAndClear(Bundle bundle)
{
var storedViewModel = _currentViewModel;
_currentViewModel = null;
if (bundle == null)
return null;
var key = bundle.GetInt(BundleCacheKey);
var toReturn = (key == _counter) ? storedViewModel : null;
return toReturn;
}
public void Cache(IMvxViewModel toCache, Bundle bundle)
{
_currentViewModel = toCache;
_counter++;
if (_currentViewModel == null)
{
return;
}
bundle.PutInt(BundleCacheKey, _counter);
}
public virtual bool Close(IMvxViewModel viewModel)
{
//Workaround for closing fragments. This will not work when showing multiple fragments of the same viewmodel type in one activity
var frag = GetCurrentCacheableFragmentsInfo ().FirstOrDefault (x => x.ViewModelType == viewModel.GetType());
if (frag == null)
{
return false;
}
// Close method can not be fully fixed at this moment. That requires some changes in main MvvmCross library
CloseFragment(frag.Tag, frag.ContentId);
return true;
}
private UIViewController CreateTabFor(string title, string imageName, IMvxViewModel viewModel)
{
Debug.Log("CreateTabFor ");
var innerView = (UIViewController)this.CreateViewControllerFor(viewModel);
PresentViewController(innerView, false, () => { });
//innerView.Title = title;
//innerView.TabBarItem = new UITabBarItem(
// title,
// UIImage.FromBundle("Images/Tabs/" + imageName + ".png"),
// _createdSoFarCount++);
return innerView;
}
public virtual IMvxTouchView CreateView(IMvxViewModel viewModel)
{
var viewModelType = viewModel.GetType();
var request = MvxShowViewModelRequest.GetDefaultRequest(viewModelType);
var view = CreateView(request);
var viewModelProperty = view.GetType().GetProperty("ViewModel");
if (viewModelProperty == null)
throw new MvxException("ViewModel Property missing for " + view.GetType());
if (!viewModelProperty.CanWrite)
throw new MvxException("ViewModel Property readonly for " + view.GetType());
viewModelProperty.SetValue(view, viewModel, null);
return view;
}
public override bool TryLoad(Type viewModelType, IDictionary<string, string> parameterValueLookup,
out IMvxViewModel model)
{
model = null;
var constructor = viewModelType
.GetConstructors()
.FirstOrDefault(c => c.GetParameters().All(p => IsConvertibleParameter(p)));
if (constructor == null)
return false;
var invokeWith = CreateArgumentList(viewModelType, parameterValueLookup, constructor.GetParameters());
model = Activator.CreateInstance(viewModelType, invokeWith.ToArray()) as IMvxViewModel;
return (model != null);
}
/// <summary>
/// See if the supplied ViewModel matches up with the MvxView at the top of the supplied UINavigationController
/// and if so, pop that View from the stack
/// </summary>
private bool CloseTopView(IMvxViewModel toClose, UINavigationController uiNavigationController)
{
if (uiNavigationController == null)
{
return(false);
}
IMvxIosView mvxTouchView = uiNavigationController.TopViewController as IMvxIosView;
if (mvxTouchView == null)
{
return(false);
}
if (mvxTouchView.ReflectionGetViewModel() != toClose)
{
return(false);
}
uiNavigationController.PopViewController(true);
return(true);
}
protected virtual Task <bool> CloseViewPagerFragment(IMvxViewModel viewModel, MvxViewPagerFragmentPresentationAttribute attribute)
{
ViewPager viewPager = null;
FragmentManager fragmentManager = null;
if (attribute.FragmentHostViewType != null)
{
var fragment = GetFragmentByViewType(attribute.FragmentHostViewType);
if (fragment == null)
{
throw new MvxException("Fragment not found", attribute.FragmentHostViewType.Name);
}
viewPager = fragment.View.FindViewById <ViewPager>(attribute.ViewPagerResourceId);
fragmentManager = fragment.ChildFragmentManager;
}
else
{
viewPager = CurrentActivity.FindViewById <ViewPager>(attribute.ViewPagerResourceId);
fragmentManager = CurrentFragmentManager;
}
if (viewPager?.Adapter is MvxCachingFragmentStatePagerAdapter adapter)
{
var ft = fragmentManager.BeginTransaction();
var fragmentInfo = adapter.FragmentsInfo.Find(x => x.FragmentType == attribute.ViewType && x.ViewModelType == attribute.ViewModelType);
var fragment = fragmentManager.FindFragmentByTag(fragmentInfo.Tag);
adapter.FragmentsInfo.Remove(fragmentInfo);
ft.Remove(fragment);
ft.CommitAllowingStateLoss();
adapter.NotifyDataSetChanged();
OnFragmentPopped(ft, fragment, attribute);
return(Task.FromResult(true));
}
return(Task.FromResult(false));
}
public override void Close(IMvxViewModel viewModel)
{
var navigationType = ((IBaseViewModel)viewModel)?.VmNavigationType ?? NavigationType.None;
if (navigationType == NavigationType.None)
{
MenuNavigationController.HideMenu();
return;
}
if (navigationType == NavigationType.Push)
{
if (MenuNavigationController.TopNavigationController.PresentedViewController != null)
{
var navigationController = (MenuNavigationController.TopNavigationController.PresentedViewController as UINavigationController);
if (navigationController != null)
{
navigationController.PopViewController(true);
}
else
{
MenuNavigationController.TopNavigationController.PresentedViewController.DismissViewControllerAsync(true);
}
}
else
{
MenuNavigationController.TopNavigationController.PopViewController(true);
}
}
if (navigationType == NavigationType.PresentModal)
{
var controller = GetLastPresentedController(MenuNavigationController.TopNavigationController.PresentedViewController ?? MenuNavigationController.TopNavigationController.TopViewController);
controller?.DismissViewControllerAsync(true);
}
((IBaseViewModel)viewModel)?.Unbind();
}
public override void Close(IMvxViewModel viewModel)
{
var currentWindows = Windows;
for (int i = currentWindows.Count - 1; i >= 0; i--)
{
var window = currentWindows[i];
// if toClose is a sheet or modal
if (window.ContentViewController.PresentedViewControllers.Any())
{
var modal = window.ContentViewController.PresentedViewControllers
.Select(v => v as MvxViewController)
.FirstOrDefault(v => v.ViewModel == viewModel);
if (modal != null)
{
window.ContentViewController.DismissViewController(modal);
return;
}
}
// if toClose is a tab
var tabViewController = window.ContentViewController as IMvxTabViewController;
if (tabViewController != null && tabViewController.CloseTabView(viewModel))
{
return;
}
// toClose is a content
var controller = window.ContentViewController as MvxViewController;
if (controller != null && controller.ViewModel == viewModel)
{
window.Close();
return;
}
}
}
public virtual bool CloseMasterDetailPage(IMvxViewModel viewModel, MvxMasterDetailPagePresentationAttribute attribute)
{
var masterDetailHost = FormsApplication.MainPage as MasterDetailPage;
if (masterDetailHost == null && FormsApplication.MainPage is MvxNavigationPage navigationPage)
{
masterDetailHost = navigationPage.CurrentPage as MasterDetailPage;
}
switch (attribute.Position)
{
case MasterDetailPosition.Root:
if (FormsApplication.MainPage is MvxNavigationPage rootNavigationPage)
{
rootNavigationPage.PopAsync();
}
break;
case MasterDetailPosition.Master:
if (masterDetailHost.Master is NavigationPage navigationMasterPage)
{
navigationMasterPage.PopAsync();
}
break;
case MasterDetailPosition.Detail:
if (masterDetailHost.Detail is NavigationPage navigationDetailPage)
{
navigationDetailPage.PopAsync();
}
break;
default:
break;
}
return(true);
}
public IMvxViewModel LoadViewModel(MvxViewModelRequest request, IMvxBundle savedState, IMvxNavigateEventArgs navigationArgs)
{
if (request.ViewModelType == typeof(MvxNullViewModel))
{
return(new MvxNullViewModel());
}
var viewModelLocator = FindViewModelLocator(request);
IMvxViewModel viewModel = null;
var parameterValues = new MvxBundle(request.ParameterValues);
try
{
viewModel = viewModelLocator.Load(request.ViewModelType, parameterValues, savedState, navigationArgs);
}
catch (Exception exception)
{
throw exception.MvxWrap(
"Failed to construct and initialize ViewModel for type {0} from locator {1} - check InnerException for more information",
request.ViewModelType, viewModelLocator.GetType().Name);
}
return(viewModel);
}
public virtual bool TryLoad(Type viewModelType,
IMvxBundle parameterValues,
IMvxBundle savedState,
out IMvxViewModel viewModel)
{
viewModel = null;
try
{
viewModel = (IMvxViewModel)Mvx.IocConstruct(viewModelType);
}
catch (Exception exception)
{
MvxTrace.Warning("Problem creating viewModel of type {0} - problem {1}",
viewModelType.Name, exception.ToLongString());
return(false);
}
try
{
CallCustomInitMethods(viewModel, parameterValues);
if (savedState != null)
{
CallReloadStateMethods(viewModel, savedState);
}
viewModel.Start();
}
catch (Exception exception)
{
MvxTrace.Warning("Problem initialising viewModel of type {0} - problem {1}",
viewModelType.Name, exception.ToLongString());
return(false);
}
return(true);
}
protected virtual bool CloseModalViewController(IMvxViewModel toClose)
{
if (ModalViewControllers == null || !ModalViewControllers.Any())
{
return(false);
}
// check for plain modals
var modalToClose = ModalViewControllers.FirstOrDefault(v => v is IMvxIosView && v.GetIMvxIosView().ViewModel == toClose);
if (modalToClose != null)
{
CloseModalViewController(modalToClose);
return(true);
}
// check for modal navigation stacks
UIViewController controllerToClose = null;
foreach (var vc in ModalViewControllers.Where(v => v is UINavigationController))
{
var root = ((UINavigationController)vc).ViewControllers.FirstOrDefault();
if (root != null && root.GetIMvxIosView().ViewModel == toClose)
{
controllerToClose = root;
break;
}
}
if (controllerToClose != null)
{
CloseModalViewController(controllerToClose);
return(true);
}
return(false);
}
public ValueTask <IMvxViewModel> ReloadViewModel <TParameter>(IMvxViewModel <TParameter> viewModel, TParameter param, MvxViewModelRequest request, IMvxBundle?savedState, IMvxNavigateEventArgs?navigationArgs)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var viewModelLocator = FindViewModelLocator(request);
var parameterValues = new MvxBundle(request.ParameterValues);
try
{
viewModel = viewModelLocator.Reload(viewModel, param, parameterValues, savedState, navigationArgs);
}
catch (Exception exception)
{
throw exception.MvxWrap(
"Failed to reload a previously created created ViewModel for type {0} from locator {1} - check InnerException for more information",
request.ViewModelType !, viewModelLocator.GetType().Name);
}
return(new ValueTask <IMvxViewModel>(viewModel));
}
protected void RunViewModelLifecycle(IMvxViewModel viewModel, IMvxBundle parameterValues, IMvxBundle savedState, IMvxNavigateEventArgs navigationArgs)
{
try
{
CallCustomInitMethods(viewModel, parameterValues);
if (navigationArgs?.Cancel == true)
{
return;
}
if (savedState != null)
{
CallReloadStateMethods(viewModel, savedState);
if (navigationArgs?.Cancel == true)
{
return;
}
}
viewModel.Start();
if (navigationArgs?.Cancel == true)
{
return;
}
viewModel.Prepare();
if (navigationArgs?.Cancel == true)
{
return;
}
viewModel.InitializeTask = MvxNotifyTask.Create(() => viewModel.Initialize());
}
catch (Exception exception)
{
throw exception.MvxWrap("Problem running viewModel lifecycle of type {0}", viewModel.GetType().Name);
}
}
protected override bool CloseFragment(IMvxViewModel viewModel, MvxFragmentPresentationAttribute attribute)
{
// try to close nested fragment first
if (attribute.FragmentHostViewType != null)
{
var fragmentHost = GetFragmentByViewType(attribute.FragmentHostViewType);
if (fragmentHost != null &&
TryPerformCloseFragmentTransaction(fragmentHost.ChildFragmentManager, attribute))
{
return(true);
}
}
// Close fragment. If it isn't successful, then close the current Activity
if (TryPerformCloseFragmentTransaction(CurrentFragmentManager, attribute))
{
return(true);
}
else
{
CurrentActivity.Finish();
return(true);
}
}
public override void Close(IMvxViewModel viewModel)
{
var currentView = this._rootFrame.Content as IMvxView;
if (currentView == null)
{
Mvx.Warning("Ignoring close for viewmodel - rootframe has no current page");
return;
}
if (currentView.ViewModel != viewModel)
{
Mvx.Warning("Ignoring close for viewmodel - rootframe's current page is not the view for the requested viewmodel");
return;
}
if (!this._rootFrame.CanGoBack)
{
Mvx.Warning("Ignoring close for viewmodel - rootframe refuses to go back");
return;
}
this._rootFrame.GoBack();
}
protected virtual bool TryCloseViewControllerInsideStack(UINavigationController navigationController,
IMvxViewModel viewModel)
{
var topViewController = navigationController.TopViewController.GetIMvxTvosView();
if (topViewController != null && topViewController.ViewModel == viewModel)
{
navigationController.PopViewController(true);
return(true);
}
var viewControllers = navigationController.ViewControllers.ToList();
var viewController = viewControllers.FirstOrDefault(vc => vc.GetIMvxTvosView().ViewModel == viewModel);
if (viewController != null)
{
viewControllers.Remove(viewController);
navigationController.ViewControllers = viewControllers.ToArray();
return(true);
}
return(false);
}
protected virtual Task <bool> CloseActivity(IMvxViewModel viewModel, MvxActivityPresentationAttribute?attribute)
{
var currentView = CurrentActivity as IMvxView;
if (currentView == null)
{
_logger.Value?.Log(LogLevel.Warning, "Ignoring close for viewmodel - rootframe has no current page");
return(Task.FromResult(false));
}
if (currentView.ViewModel != viewModel)
{
_logger.Value?.Log(LogLevel.Warning, "Ignoring close for viewmodel - rootframe's current page is not the view for the requested viewmodel");
return(Task.FromResult(false));
}
// don't kill the dead
if (CurrentActivity.IsActivityAlive())
{
CurrentActivity !.Finish();
}
return(Task.FromResult(true));
}
private async Task <bool> HandleMasterDetailRequest(Page page, IMvxViewModel viewModel)
{
var masterDetailPage = page as MasterDetailPage;
if (masterDetailPage == null)
{
return(false);
}
await CleanupMasterDetailPage();
try
{
MvxFormsApplication.Current.MainPage = masterDetailPage;
}
catch (NullReferenceException) {
// In IOS da problemi
}
RootMasterDetailPage = masterDetailPage;
page.BindingContext = viewModel;
return(true);
}
public override void Close(IMvxViewModel viewModel)
{
var viewFinder = Mvx.Resolve <IMvxViewsContainer>();
var viewType = viewFinder.GetViewType(viewModel.GetType());
if (viewType.HasRegionAttribute())
{
var containerView = FindChild <Frame>(_rootFrame.UnderlyingControl, viewType.GetRegionName());
if (containerView == null)
{
throw new MvxException($"Region '{viewType.GetRegionName()}' not found in view '{viewType}'");
}
if (containerView.CanGoBack)
{
containerView.GoBack();
}
}
else
{
base.Close(viewModel);
}
}
public override ValueTask <bool> Close(IMvxViewModel viewModel)
{
var currentWindows = Windows;
foreach (var window in currentWindows.Reverse <NSWindow>())
{
// if toClose is a sheet or modal
if (window?.ContentViewController.PresentedViewControllers.Any() ?? false)
{
var modal = window.ContentViewController.PresentedViewControllers
.Select(v => v as MvxViewController)
.FirstOrDefault(v => v?.ViewModel == viewModel);
if (modal != null)
{
window.ContentViewController.DismissViewController(modal);
return(new ValueTask <bool>(true));
}
}
// if toClose is a tab
var tabViewController = window?.ContentViewController as IMvxTabViewController;
if (tabViewController != null && tabViewController.CloseTabView(viewModel))
{
return(new ValueTask <bool>(true));
}
// toClose is a content
var controller = window?.ContentViewController as MvxViewController;
if (controller != null && controller.ViewModel == viewModel)
{
window?.Close();
return(new ValueTask <bool>(true));
}
}
return(new ValueTask <bool>(true));
}
public override async Task <bool> Close(IMvxViewModel viewModel)
{
// Only run this on host pages
if (!(_rootFrame.Content is ISoundByteHost host))
{
return(await base.Close(viewModel));
}
// Get the view type
var viewsContainer = Mvx.IoCProvider.Resolve <IMvxViewsContainer>();
var viewType = viewsContainer.GetViewType(viewModel.GetType());
// Modal frame
if (viewType.HasModalAttribute())
{
host.CloseModal();
return(true);
}
// Standard frame
await host.NavigateBackAsync();
return(true);
}
public static IMvxBundle SaveStateBundle(this IMvxViewModel viewModel)
{
var toReturn = new MvxBundle();
var methods = viewModel.GetType()
.GetMethods()
.Where(m => m.Name == "SaveState")
.Where(m => m.ReturnType != typeof(void))
.Where(m => !m.GetParameters().Any());
foreach (var methodInfo in methods)
{
// use methods like `public T SaveState()`
var stateObject = methodInfo.Invoke(viewModel, new object[0]);
if (stateObject != null)
{
toReturn.Write(stateObject);
}
}
// call the general `public void SaveState(bundle)` method too
viewModel.SaveState(toReturn);
return(toReturn);
}
public virtual bool CloseChildViewModel(IMvxViewModel viewModel)
{
var navController = SelectedViewController as UINavigationController;
if (navController != null)
{
navController.PopViewController(true);
return(true);
}
// loop through Tabs
var toClose = ViewControllers.Where(v => v.GetType() != typeof(MvxNavigationController))
.Select(v => v.GetIMvxIosView())
.FirstOrDefault(mvxView => mvxView.ViewModel == viewModel);
if (toClose != null)
{
var newTabs = ViewControllers.Where(v => v.GetIMvxIosView() != toClose);
ViewControllers = newTabs.ToArray();
return(true);
}
return(false);
}
public void Test_WithReloadState()
{
_fixture.ClearAll();
_fixture.Ioc.RegisterSingleton <IMvxStringToTypeParser>(new MvxStringToTypeParser());
var testThing = new MockTestThing();
_fixture.Ioc.RegisterSingleton <ITestThing>(testThing);
var initBundleObject = new BundleObject
{
TheBool1 = false,
TheBool2 = true,
TheGuid1 = Guid.NewGuid(),
TheGuid2 = new Guid(123, 10, 444, 1, 2, 3, 4, 5, 6, 7, 8),
TheInt1 = 123,
TheInt2 = 456,
TheString1 = "Hello World",
TheString2 = null
};
var initBundle = new MvxBundle();
initBundle.Write(initBundleObject);
var reloadBundleObject = new BundleObject
{
TheBool1 = true,
TheBool2 = true,
TheGuid1 = Guid.NewGuid(),
TheGuid2 = new Guid(1123, 10, 444, 1, 2, 3, 4, 5, 6, 7, 8),
TheInt1 = 1234,
TheInt2 = 4567,
TheString1 = "Foo Bar",
TheString2 = null
};
var reloadBundle = new MvxBundle();
reloadBundle.Write(reloadBundleObject);
var navigationService = _fixture.Ioc.Resolve <IMvxNavigationService>();
var toTest = new MvxDefaultViewModelLocator(navigationService);
var args = new MvxNavigateEventArgs(NavigationMode.Show);
IMvxViewModel viewModel = toTest.Load(typeof(Test1ViewModel), initBundle, reloadBundle, args);
Assert.NotNull(viewModel);
var typedViewModel = (Test1ViewModel)viewModel;
Assert.Equal(initBundle, typedViewModel.BundleInit);
Assert.Equal(reloadBundle, typedViewModel.BundleState);
Assert.Equal(testThing, typedViewModel.Thing);
Assert.Equal(initBundleObject, typedViewModel.TheInitBundleSet);
Assert.Equal(reloadBundleObject, typedViewModel.TheReloadBundleSet);
Assert.Equal(initBundleObject.TheGuid1, typedViewModel.TheInitGuid1Set);
Assert.Equal(initBundleObject.TheGuid2, typedViewModel.TheInitGuid2Set);
Assert.Equal(initBundleObject.TheString1, typedViewModel.TheInitString1Set);
Assert.Equal(reloadBundleObject.TheGuid1, typedViewModel.TheReloadGuid1Set);
Assert.Equal(reloadBundleObject.TheGuid2, typedViewModel.TheReloadGuid2Set);
Assert.Equal(reloadBundleObject.TheString1, typedViewModel.TheReloadString1Set);
Assert.True(typedViewModel.StartCalled);
}
protected virtual void CallReloadStateMethods(IMvxViewModel viewModel, IMvxBundle savedState)
{
viewModel.CallBundleMethods("ReloadState", savedState);
}
public virtual bool Close(IMvxViewModel viewModel)
{
// Close method can not be fixed at this moment
// That requires some changes in main MvvmCross library
return(false);
}
protected virtual bool CloseAnimatedRootViewController(IMvxViewModel viewModel, AnimatedRootPresentationAttribute attribute)
{
return(CloseRootViewController(viewModel, attribute));
}
protected virtual void CallCustomInitMethods(IMvxViewModel viewModel, IMvxBundle parameterValues)
{
viewModel.CallBundleMethods("Init", parameterValues);
}
protected bool Close(IMvxViewModel viewModel)
{
return(ChangePresentation(new MvxClosePresentationHint(viewModel)));
}
public override void Close(IMvxViewModel viewModel)
{
FormsPagePresenter.Close(viewModel);
}
public override void Close(IMvxViewModel viewModel)
{
GetPresentationAttributeAction(viewModel.GetType(), out MvxBasePresentationAttribute attribute).CloseAction.Invoke(viewModel, attribute);
}
protected virtual bool CloseSplitView(IMvxViewModel viewModel, MvxSplitViewPresentationAttribute attribute)
{
return(ClosePage(viewModel, attribute));
}
protected virtual void CloseFragment(IMvxViewModel viewModel)
{
GetActualFragmentHost().Close(viewModel);
}
