protected void PrepareFragment (IMvxFragmentView fragment, MvxViewModelRequest request)
		{
			var loaderService = Mvx.Resolve<IMvxViewModelLoader> ();
			var viewModel = loaderService.LoadViewModel (request, null);

			fragment.ViewModel = viewModel;
		}

 protected override IMvxTouchView CreateViewOfType(Type viewType, MvxViewModelRequest request)
 {
     var storyboardName = UserInterfaceIsPhone ? "iPhone" : "iPad";
     var storyboard = UIStoryboard.FromName(storyboardName, null);
     return (IMvxTouchView)storyboard
         .InstantiateViewController(viewType.Name);
 }

 public override sealed void Show(MvxViewModelRequest request)
 {
     if (_fragmentHostRegistrationSettings.IsTypeRegisteredAsFragment(request.ViewModelType))
         ShowFragment(request);
     else
         ShowActivity(request);
 }

        public static bool Handle(string path)
        {
            var viewDispatcher = Mvx.Resolve<Cirrious.MvvmCross.Views.IMvxViewDispatcher>();
            var appService = Mvx.Resolve<IApplicationService>();
            if (!path.EndsWith("/", StringComparison.Ordinal))
                path += "/";

            foreach (var route in Routes)
            {
                var regex = new Regex(route.Path, RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase);
                var match = regex.Match(path);
                var groups = regex.GetGroupNames().Skip(1);

                if (match.Success)
                {
                    var rec = new MvxViewModelRequest();
                    rec.ViewModelType = route.ViewModelType;
                    rec.ParameterValues = new Dictionary<string, string>();
                    foreach (var group in groups)
                        rec.ParameterValues.Add(group, match.Groups[group].Value);
                    appService.SetUserActivationAction(() => viewDispatcher.ShowViewModel(rec));
                    return true;
                }
            }

            return false;
        }

        public virtual async void Show(MvxViewModelRequest request)
        {
            if (await TryShowPage(request))
                return;

            Mvx.Error("Skipping request for {0}", request.ViewModelType.Name);
        }

 // thats an OVERLOAD!, just in case somebody reads way to fast ;)
 public void Show(MvxViewModelRequest request, bool viewModelShouldHandleError = true)
 {
     // TODO: use an as cast with an null check instead?
     if (ImplementsInterface(request.ViewModelType, typeof(IConditionalViewModel))) {
         // check condition here
         var loader = Mvx.Resolve<IMvxViewModelLoader>();
         var viewModel = loader.LoadViewModel(request, null) as IConditionalViewModel;
         if (viewModel.Precondition(viewModelShouldHandleError) == false) {
             if (viewModelShouldHandleError) {
                 // in this case the ViewModel already handled the error - if it did nothing ( no redirect ) basically just nothing happens
                 return;
             }
             else {
                 // The calle asked us ot inform him if the viewmodel does not allow instantiation to handle the error himself, so throw an Exception
                 throw new ViewNotAllowedException();
             }
         }
         else {
             var view = this.CreateViewControllerFor(request);
             // reuse the viewModel
             view.ViewModel = viewModel;
             Show(view);
         }
     }
     else {
         // no conditions, classiv way
         var view = this.CreateViewControllerFor(request);
         Show(view);
     }
 }

        public void Test_Round_Trip_Works_For_Normal_ViewModel_Requests()
        {
            ClearAll();

            var viewModelNameLookup = new MvxViewModelByNameLookup();
            viewModelNameLookup.AddAll(GetType().Assembly);
            Mvx.RegisterSingleton<IMvxViewModelByNameLookup>(viewModelNameLookup);

            var parameterBundle = new MvxBundle(new Dictionary<string, string> { { "On'e", "1'\\" }, { "Two", "2" } });
            var presentationBundle =
                new MvxBundle(new Dictionary<string, string> { { "Thre\"\'\\e", "3\"\'\\" }, { "Four", null } });
            var request = new MvxViewModelRequest<Test1ViewModel>(parameterBundle, presentationBundle,
                                                                  new MvxRequestedBy(
                                                                      MvxRequestedByType.AutomatedService, "HelloWorld"));

            var serializer = new MvxViewModelRequestCustomTextSerializer();
            var output = serializer.SerializeObject(request);

            var deserializer = new MvxViewModelRequestCustomTextSerializer();
            var deserialized = deserializer.DeserializeObject<MvxViewModelRequest>(output);

            Assert.AreEqual(typeof(Test1ViewModel), deserialized.ViewModelType);
            Assert.AreEqual(MvxRequestedByType.AutomatedService, deserialized.RequestedBy.Type);
            Assert.AreEqual("HelloWorld", deserialized.RequestedBy.AdditionalInfo);
            Assert.AreEqual(2, deserialized.PresentationValues.Count);
            Assert.AreEqual(2, deserialized.ParameterValues.Count);
            Assert.AreEqual("1'\\", deserialized.ParameterValues["On'e"]);
            Assert.AreEqual("2", deserialized.ParameterValues["Two"]);
            Assert.AreEqual("3\"\'\\", deserialized.PresentationValues["Thre\"\'\\e"]);
            Assert.AreEqual(null, deserialized.PresentationValues["Four"]);
        }

        public override void Show(MvxViewModelRequest request)
        {
            // XFViewModel means we need a Forms View
            if (request.ViewModelType.FullName.Contains ("XFViewModel"))
            {
                //get the xamarin.forms page from the ViewModel
                var contentPage = MvxPresenterHelpers.CreatePage (request);

                //MvvmCross call to create the view model with DI etc
                var viewModel = MvxPresenterHelpers.LoadViewModel (request);

                //Assign it to the Forms Binding Content
                contentPage.BindingContext = viewModel;

                //Creating the view controller from the content page
                var viewController = contentPage.CreateViewController ();

                if (this.MasterNavigationController == null)
                {
                    // If it's the first view
                    this.ShowFirstView (viewController);
                }
                else
                {
                    // If it's already in the stack
                    this.MasterNavigationController.PushViewController (viewController, true);
                }

            }
            else
            {
                //Using a normal MvvmCross View
                base.Show (request);
            }
        }

        private async Task<bool> TryShowPage(MvxViewModelRequest request)
        {
            var page = MvxPresenterHelpers.CreatePage(request);
            if (page == null)
                return false;

            var viewModel = MvxPresenterHelpers.LoadViewModel(request);

            var mainPage = _mvxFormsApp.MainPage as NavigationPage;
            page.BindingContext = viewModel;

            if (mainPage == null)
            {
                _mvxFormsApp.MainPage = new NavigationPage(page);
                mainPage = _mvxFormsApp.MainPage as NavigationPage;
                CustomPlatformInitialization(mainPage);
            }
            else
            {
                try
                {
                    await mainPage.PushAsync(page);
                }
                catch (Exception e)
                {
                    Mvx.Error("Exception pushing {0}: {1}\n{2}", page.GetType(), e.Message, e.StackTrace);
                }
            }

            return true;
        }

		protected  override IMvxTouchView CreateViewOfType(Type viewType, MvxViewModelRequest request)
		{
			// If View is "SampleViewController", then Storyboard should be "SampleViewController.storyboard"
			// If we can't find storyboard, then proceed to load XIB..
			//
			// NOTE: You must have this ctor defined for Storyboard: 
			//
			//   public YourViewController (IntPtr handle) : base (handle)
			//
            // As indicated here: http://developer.xamarin.com/guides/ios/user_interface/introduction_to_storyboards/
            //

		    IMvxTouchView viewController = null;

			if (NSBundle.MainBundle.PathForResource (viewType.Name, "storyboardc") != null) {
				// If storyboard exists for this view, load it.
				System.Console.WriteLine ("Creating view from Storyboard {0}.storyboard", viewType.Name);
				var storyboard = UIStoryboard.FromName(viewType.Name, null);
				viewController = (IMvxTouchView)storyboard.InstantiateInitialViewController();
			}
			else {
				System.Console.WriteLine ("Storyboard {0}.storyboard does not exist: creating view of type instead", viewType.Name);
				viewController = (IMvxTouchView)base.CreateViewOfType(viewType, request);
			}

			if(viewController == null) {
				System.Console.WriteLine ("Can't create view for type:" + viewType.Name);
				throw new Exception ("Can't create view for type:" + viewType.Name);
			}									
			return viewController;
		}

        public void Test_NormalViewModel()
        {
            ClearAll();

            IMvxViewModel outViewModel = new Test2ViewModel();

            var mockLocator = new Mock<IMvxViewModelLocator>();
            mockLocator.Setup(
                m => m.Load(It.IsAny<Type>(), It.IsAny<IMvxBundle>(), It.IsAny<IMvxBundle>()))
                       .Returns(() => outViewModel);

            var mockCollection = new Moq.Mock<IMvxViewModelLocatorCollection>();
            mockCollection.Setup(m => m.FindViewModelLocator(It.IsAny<MvxViewModelRequest>()))
                          .Returns(() => mockLocator.Object);

            Ioc.RegisterSingleton(mockCollection.Object);

            var parameters = new Dictionary<string, string> { { "foo", "bar" } };
            var request = new MvxViewModelRequest<Test2ViewModel>(new MvxBundle(parameters), null,
                                                                  MvxRequestedBy.UserAction);
            var state = new MvxBundle();
            var loader = new MvxViewModelLoader();
            var viewModel = loader.LoadViewModel(request, state);

            Assert.AreSame(outViewModel, viewModel);
            Assert.AreEqual(MvxRequestedBy.UserAction, viewModel.RequestedBy);
        }

		public override void Show(MvxViewModelRequest request)
		{
            if (TryShowPage(request))
				return;

			Mvx.Error("Skipping request for {0}", request.ViewModelType.Name);
		}

        public virtual IMvxUnityView CreateView(MvxViewModelRequest request)
        {
            try
            {
                CurrentRequest = request;

                IMvxUnityView view;
                //var viewType = GetViewType(request.ViewModelType);
                //if (viewType == null)
                //    throw new MvxException("View Type not found for " + request.ViewModelType);

                var customAttribute = (MvxViewAttribute)request.ViewModelType.GetCustomAttributes(typeof(MvxViewAttribute), false).FirstOrDefault();

                if (customAttribute != null)
                {
                    string viewUrl = customAttribute.Url;

                    GameObject prefab = (GameObject)UnityEngine.Resources.Load(viewUrl);

                    Camera uiCamera = NGUITools.FindCameraForLayer(prefab.layer);

                    Vector3 newPosition;
                    if (prefab.layer == LayerMask.NameToLayer("UI"))
                    {
                        newPosition = new Vector3(0, 0, uiCamera.farClipPlane + 100f);
                    }
                    else
                    {
                        newPosition = Vector3.zero;
                    }

                    GameObject go = GameObject.Instantiate(prefab, newPosition, Quaternion.identity) as GameObject;

                    PreventCameraSwapOnUIAnchor(go);

                    view = go.GetComponent(typeof(IMvxUnityView)) as IMvxUnityView;
                }
                else
                {
                    /*
                    GameObject go = new GameObject();
                    go.name = request.ViewModelType.Name + "(Clone)";
                    go = go.AddComponent(viewType).gameObject;
                    view = go.GetComponent(typeof(IMvxUnityView)) as IMvxUnityView;
                    */
                    throw new Exception("Unable to find MvxViewAttribute on ViewModel: " + request.ViewModelType.Name);
                }

                if (view == null)
                    throw new MvxException("View not loaded for " + request.ViewModelType);

                view.Request = request;
                return view;
            }
            finally
            {
                CurrentRequest = null;
            }
        }

 // thats an OVERLOAD!, just in case somebody reads way to fast ;)
 public bool ShowViewModel(MvxViewModelRequest request, bool viewModelShouldHandleError = true)
 {
     Action action = () => {
         MvxTrace.TaggedTrace("TouchNavigation", "Navigate requested");
         _presenter.Show(request);
     };
     return RequestMainThreadAction(action);
 }

 protected override IMvxTouchView CreateViewOfType(Type viewType, MvxViewModelRequest request)
 {
     // Get storyboard using the View name that is passed. This will only work if the Storyboard ID is set on the .storyboard file
     // If we move to unified storyboards this will not be necessary
     var sb = UIStoryboard.FromName(string.Format("{0}_{1}", viewType.Name, UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone ? "iPhone" : "iPad"), NSBundle.MainBundle);
     var vc = sb.InstantiateViewController(viewType.Name);
     return vc as IMvxTouchView;
 }

        protected override IMvxTouchView CreateViewOfType(Type viewType, MvxViewModelRequest request)
        {
            MvxTrace.Trace(MvxTraceLevel.Diagnostic, "Create iOS View:" + viewType.Name);
            var storyboard = UIStoryboard.FromName("Main", null);
            var returnValue = storyboard.InstantiateViewController(viewType.Name);

            return (IMvxTouchView)returnValue;
        }

        protected virtual void Show(IMvxMacView view, MvxViewModelRequest request)
        {
            var viewController = view as NSViewController;
            if (viewController == null)
                throw new MvxException("Passed in IMvxTouchView is not a UIViewController");

            Show(viewController, request);
        }

		public override void Show (MvxViewModelRequest request)
		{
			if (_customPresenterOpenScenarios.ContainsKey (request.ViewModelType)) {
				_customPresenterOpenScenarios [request.ViewModelType] (request);
			} else {
				base.Show (request);
			}
		}

        public bool Show(MvxViewModelRequest request, Bundle bundle)
        {
            drawerLayout.CloseDrawers();

            int targetId = request.ViewModelType == typeof(MenuViewModel) ? Resource.Id.left_drawer : Resource.Id.content_frame;
            ShowFragment(request.ViewModelType.Name, targetId, bundle);

            return true;
        }

 public bool ShowViewModel(MvxViewModelRequest request)
 {
     Action action = () =>
     {
         MvxTrace.TaggedTrace("UnityNavigation", "Navigate requested");
         _presenter.Show(request);
     };
     return RequestMainThreadAction(action);
 }