public static void Configure(Container container, PhoneApplicationFrame root)
        {
            container.Register<IJiraService>(c => new JiraService{Store = c.Resolve<IDocumentStore>()});
            container.Register<IScheduler>(c => new Scheduler());

            container.Register(c => new SignInCommandHandler{Bus = c.Resolve<IBus>()});
            container.Register(c => new SyncHandler{Bus = c.Resolve<IBus>(), Jira = c.Resolve<IJiraService>()});
            container.Register(
                c => new SyncProjectHandler
                    {
                        Bus = c.Resolve<IBus>(),
                        Store = c.Resolve<IDocumentStore>(),
                        Jira = c.Resolve<IJiraService>(),
                        Scheduler = c.Resolve<IScheduler>()
                    });
            container.Register(c => new SyncNewlyDiscoveredProjectsByDefaultHandler {Bus = c.Resolve<IBus>()});

            container.Register(c => new ProfileLoggedInEventHandler { Store = c.Resolve<IDocumentStore>() });

            var bus = container.Resolve<IBus>();

            bus.RegisterHandler<SignInCommandHandler, SignInCommand>();
            bus.RegisterHandler<SyncHandler, ApplicationLoadedEvent>();
            bus.RegisterHandler<ProfileLoggedInEventHandler, LoggedInEvent>();
            bus.RegisterHandler<SyncHandler, LoggedInEvent>();
            bus.RegisterHandler<SyncProjectHandler, ProjectsDiscoveredEvent>();
            bus.RegisterHandler<SyncProjectHandler, SyncProjectCommand>();
            bus.RegisterHandler<SyncNewlyDiscoveredProjectsByDefaultHandler, DiscoveredNewProjectEvent>();
        }

        private bool EnsureMainFrame()
        {
            if (_mainFrame != null)
            {
                return true;
            }

            _mainFrame = Application.Current.RootVisual as PhoneApplicationFrame;

            if (_mainFrame != null)
            {
                // Could be null if the app runs inside a design tool
                _mainFrame.Navigating += (s, e) =>
                {
                    if (Navigating != null)
                    {
                        Navigating(s, e);
                    }
                };

                return true;
            }

            return false;
        }

 /// <summary>
 ///     Initializes a new instance of the <see cref="WindowsPhoneBootstrapperBase" /> class.
 /// </summary>
 protected WindowsPhoneBootstrapperBase([NotNull] PhoneApplicationFrame rootFrame, PlatformInfo platform = null)
     : base(platform ?? PlatformExtensions.GetPlatformInfo())
 {
     Should.NotBeNull(rootFrame, "rootFrame");
     _rootFrame = rootFrame;
     PhoneApplicationService.Current.Launching += OnLaunching;
 }

        public void OpenPickerPage()
        {
            if (null == PickerPageUri)
            {
                throw new ArgumentException("PickerPageUri property must not be null.");
            }

            if (null == _frame)
            {
                _frame = Application.Current.RootVisual as PhoneApplicationFrame;
                if (null != _frame)
                {
                    _frameContentWhenOpened = _frame.Content;

                    // Save and clear host page transitions for the upcoming "popup" navigation
                    UIElement frameContentWhenOpenedAsUIElement = _frameContentWhenOpened as UIElement;
                    if (null != frameContentWhenOpenedAsUIElement)
                    {
                        _savedNavigationInTransition = TransitionService.GetNavigationInTransition(frameContentWhenOpenedAsUIElement);
                        TransitionService.SetNavigationInTransition(frameContentWhenOpenedAsUIElement, null);
                        _savedNavigationOutTransition = TransitionService.GetNavigationOutTransition(frameContentWhenOpenedAsUIElement);
                        TransitionService.SetNavigationOutTransition(frameContentWhenOpenedAsUIElement, null);
                    }

                    _frame.Navigated += OnFrameNavigated;
                    _frame.NavigationStopped += OnFrameNavigationStoppedOrFailed;
                    _frame.NavigationFailed += OnFrameNavigationStoppedOrFailed;

                    _frame.Navigate(PickerPageUri);

                }
            }
        }

 protected override IMvxPhoneViewsContainer CreateViewsContainer(PhoneApplicationFrame rootFrame)
 {
     var viewsContainer = new MultiAssemblyViewsContainer();
     var viewFinder = new LazyViewFinder(() => typeof(ThirdView).Assembly);
     viewsContainer.AddSecondary(viewFinder);
     return viewsContainer;
 }

        public NavigationServiceFacade(PhoneApplicationFrame frame)
        {
            if (frame == null)
                throw new ArgumentNullException("frame");

            this.frame = frame;
        }

 public NotificationService(
     PhoneApplicationFrame RootFrame,
     [Dispatcher] IScheduler Dispatcher
     ) {
     RootFrame.Navigated += OnFrameNavigated;
     NotificationScheduler = Dispatcher;
 }

 protected override PhoneApplicationFrame CreatePhoneApplicationFrame()
 {
     rootFrame = new PhoneApplicationFrame();
     rootFrame.Navigated += rootFrame_Navigated;
     rootFrame.Navigating += rootFrame_Navigating;
     return rootFrame;
 }

		public PhoneModule(PhoneApplicationFrame frame, IScheduler dispatcher)
		{
			if (frame == null) throw new ArgumentNullException("frame");
			if (dispatcher == null) throw new ArgumentNullException("dispatcher");
			_frame = frame;
			_dispatcher = dispatcher;
		}

        public static void Configure(PhoneApplicationFrame rootFrame)
        {
            DocumentStore = new DocumentStore();
            Container = new Container();

            Container.Register<IDocumentStore>(c => new DocumentStore());
            Container.Register<IBus>(c => new Bus(c));

            Container.Register(c => new ActivityNewActivityHandler { Bus = c.Resolve<IBus>(), DocumentStore = DocumentStore });
            Container.Register(c => new TestModeActivatedHandler { Bus = c.Resolve<IBus>() });
            Container.Register(c => new ActivateTestModeHandler { Bus = c.Resolve<IBus>() });
            Container.Register(c => new ClearCacheHandler { DocumentStore = c.Resolve<IDocumentStore>() });
            Container.Register(c => new Contexts.Review.Domain.ClearCacheHandler { DocumentStore = c.Resolve<IDocumentStore>() });

            var bus = Container.Resolve<IBus>();

            bus.RegisterHandler<ActivityNewActivityHandler, NewActivityEvent>();
            bus.RegisterHandler<TestModeActivatedHandler, TestModeActivatedEvent>();
            bus.RegisterHandler<ActivateTestModeHandler, ActivateCommand>();
            bus.RegisterHandler<Contexts.Settings.ClearCacheHandler, ClearCacheCommand>();
            bus.RegisterHandler<Contexts.Review.Domain.ClearCacheHandler, ClearCacheCommand>();

            Contexts.Import.Module.Configure(Container);
            Contexts.Import.ModuleUi.Configure(Container, rootFrame);

            Contexts.Review.Module.Confiure(Container);
        }

        /// <summary>
        ///     Initializes the application context for use through out the entire application life time.
        /// </summary>
        /// <param name="frame">
        ///     The <see cref="T:Microsoft.Phone.Controls.PhoneApplicationFrame" /> of the current application.
        /// </param>
        public static void Initialize(PhoneApplicationFrame frame)
        {
            // Initialize Ioc container.
            var kernel = new StandardKernel();
            kernel.Bind<Func<Type, NotifyableEntity>>().ToMethod(context => t => context.Kernel.Get(t) as NotifyableEntity);
            kernel.Bind<PhoneApplicationFrame>().ToConstant(frame);
            kernel.Bind<INavigationService>().To<NavigationService>().InSingletonScope();
            kernel.Bind<IStorage>().To<IsolatedStorage>().InSingletonScope();
            kernel.Bind<ISerializer<byte[]>>().To<BinarySerializer>().InSingletonScope();
            kernel.Bind<IGoogleMapsClient>().To<GoogleMapsClient>().InSingletonScope();
            kernel.Bind<IDataContext>().To<DataContext>().InSingletonScope();
            kernel.Bind<IConfigurationContext>().To<ConfigurationContext>().InSingletonScope();
            Initialize(kernel);

            // Initialize event handlers and other properties.
            GeoCoordinateWatcher = new GeoCoordinateWatcher(GeoPositionAccuracy.High) {MovementThreshold = 10D};

            ((DataContext) Data).AppVersion = new AssemblyName(Assembly.GetExecutingAssembly().FullName).Version;

            Data.PreventScreenLock.ValueChanged += (old, @new) => { PhoneApplicationService.Current.UserIdleDetectionMode = @new ? IdleDetectionMode.Disabled : IdleDetectionMode.Enabled; };

            Data.UseLocationService.ValueChanged += (old, @new) =>
            {
                if (@new) GeoCoordinateWatcher.Start();
                else GeoCoordinateWatcher.Stop();
            };

            IsNetworkAvailable = NetworkInterface.GetIsNetworkAvailable();
            NetworkChange.NetworkAddressChanged += (s, e) => IsNetworkAvailable = NetworkInterface.GetIsNetworkAvailable();
        }

        public void Initialize(PhoneApplicationFrame frame)
        {
            _mangoIndicator = new ProgressIndicator();

            frame.Navigated += OnRootFrameNavigated;

            (frame.Content as PhoneApplicationPage).SetValue(SystemTray.ProgressIndicatorProperty, _mangoIndicator);
        }

 private void InitializePhoneApplication()
 {
     if (phoneApplicationInitialized) return;
     RootFrame = new PhoneApplicationFrame();
     RootFrame.Navigated += CompleteInitializePhoneApplication;
     RootFrame.NavigationFailed += RootFrame_NavigationFailed;
     phoneApplicationInitialized = true;
 }

 public NavigationServiceAdapter(PhoneApplicationFrame frame)
 {
     this.frame = frame;
     this.frame.Navigated += frame_Navigated;
     this.frame.Navigating += frame_Navigating;
     this.frame.Obscured += frame_Obscured;
     this.RecoveredFromTombstoning = false;
 }

        public static void Configure(Container container, PhoneApplicationFrame root)
        {
            container.Register(c => new SignInActivator { RootFrame = root });

            var bus = container.Resolve<IBus>();

            bus.RegisterHandler<SignInActivator, UnauthorizedNotLoggedInEvent>();
        }

        public void Initialize(PhoneApplicationFrame frame)
        {
            // If using AgFx:
            //DataManager.Current.PropertyChanged += OnDataManagerPropertyChanged;

            _mangoIndicator = new ProgressIndicator();
            frame.Navigated += OnRootFrameNavigated;
        }

        public ProgressService(PhoneApplicationFrame rootFrame)
        {
            _indicator = new ProgressIndicator {Text = DefaultIndicatorText};
            
            rootFrame.Navigated += RootFrameOnNavigated;

            UpdateProgressBarAttachment(rootFrame.Content);
        }

 private bool IsMainFrame()
 {
     if (mainFrame != null)
     {
         return true;
     }
     mainFrame = Application.Current.RootVisual as PhoneApplicationFrame;
     return mainFrame != null;
 }

 public void scan(string options)
 {
     Deployment.Current.Dispatcher.BeginInvoke(() =>
     {
         this.currentRootVisual = Application.Current.RootVisual as PhoneApplicationFrame;
         this.currentRootVisual.Navigated += this.OnFrameNavigated;
         this.currentRootVisual.Navigate(new Uri("/Plugins/com.phonegap.plugins.barcodescanner/Scan.xaml", UriKind.Relative));
     });
 }

 protected override IMvxPhoneViewsContainer CreateViewsContainer(PhoneApplicationFrame rootFrame)
 {
     var viewsContainer = new MultiAssemblyViewsContainer();
     var sometimesViewFinder = new LazyViewFinder(() => typeof(ProductEditing).Assembly);
     viewsContainer.AddSecondary(sometimesViewFinder);
     var rarelyViewFinder = new LazyViewFinder(() => typeof(ExportAndImport).Assembly);
     viewsContainer.AddSecondary(rarelyViewFinder);
     return viewsContainer;
 }