// runs only when not restored from state
        public async override Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // Handle toast activation
            if (args is ToastNotificationActivatedEventArgs)
            {
                var toastActivationArgs = args as ToastNotificationActivatedEventArgs;

                // Parse the query string
                QueryString arguments = QueryString.Parse(toastActivationArgs.Argument);

                // See what action is being requested 
                switch (arguments["action"])
                {
                    case "openurl":
                        var url = arguments["url"];
                        await Launcher.LaunchUriAsync(new Uri(url));
                        break;
                    case "showtemperature":
                        var temperature = arguments["temperature"];
                        NavigationService.Navigate(typeof(Views.NotificationsPage), temperature);
                        break;
                    case "gettingfar":
                        var distance = arguments["distance"];
                        NavigationService.Navigate(typeof(Views.NotificationsPage), distance);
                        break;
                }
            }

            if (NavigationService.CurrentPageType != typeof(Views.MainPage))
                NavigationService.Navigate(typeof(Views.MainPage));
        }

        // runs only when not restored from state
        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {

            // set hamburger menu to full screen mode on Mobile devices.
            if (DeviceUtils.Current().IsPhone())
                Views.Shell.HamburgerMenu.IsFullScreen = true;

            if (!AuthHelper.IsCachedCredentialsAvailable())
            {
                Debug.WriteLine("App.OnStartAsync() : no cached credentials available, loading login page...");
                NavigationService.Navigate(typeof(Views.LoginPage));
            }
            else
            {
                Debug.WriteLine("App.OnStartAsync() : cached credentials found, bypassing login page...");
                await AuthHelper.AuthenticateAsync();
                if (Settings.IsAlreadyConfigured)
                {
                    Debug.WriteLine("App.OnStartAsync() : already set up, skipping to MainPage...");
                    NavigationService.Navigate(typeof(Views.MainPage));
                }
                else
                {
                    Debug.WriteLine("App.OnStartAsync() : not configured, starting setup wizard...");
                    NavigationService.Navigate(typeof(Views.SetupWizardHomePage));
                }
            }
            
            
            
        }

        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // long-running startup tasks go here

            NavigationService.Navigate(typeof(Views.MainPage));
            await Task.CompletedTask;
        }       

		// runs only when not restored from state
		public override Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
		{
			// navigate to first page
			NavigationService.Navigate(typeof(Views.MainPage));

			return Task.CompletedTask;
		}

        public override Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // long-running startup tasks go here
            db = new DataService();

            db.createDB();

            foreach (var device in db.DevicesTable)
            {
                IDevice dev = DeviceTypeFactory.MakeDevice(device.FirmwareName, device);

                dev.DeviceDetails.Status = DeviceStatus.Missing;

                devices.Add(dev);
            }

            NavigationService.Navigate(typeof(Views.MainPage));

            ssdpClient.Search();
            wifiClient.Search();

            searchTimer.Tick += SearchTimer_Tick;
            searchTimer.Interval = new TimeSpan(0, 1, 0);
            searchTimer.Start();


            return Task.CompletedTask;
        }

        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            GoogleAnalytics.EasyTracker.GetTracker().SendEvent("Lifecycle", startKind.ToString(), null, 0);
            bool isNewLaunch = args.PreviousExecutionState == ApplicationExecutionState.NotRunning;
            if (isNewLaunch)
            {
                await InitLibrary();

                var nav = new MergedNavigationService(NavigationService);
                nav.Configure(ViewModelLocator.SplashPageKey, typeof(Pages.SplashScreen));
                nav.Configure(ViewModelLocator.FrontPageKey, typeof(FrontPage));
                nav.Configure(ViewModelLocator.SubGalleryPageKey, typeof(SubGalleryPage));
                nav.Configure(ViewModelLocator.SubredditBrowserPageKey, typeof(SubredditBrowserPage));
                nav.Configure(ViewModelLocator.BrowserPageKey, typeof(BrowserPage));
                if (!SimpleIoc.Default.IsRegistered<GalaSoft.MvvmLight.Views.INavigationService>())
                    SimpleIoc.Default.Register<GalaSoft.MvvmLight.Views.INavigationService>(() => nav);
                SimpleIoc.Default.Register<IViewModelLocator>(() => ViewModelLocator.GetInstance());
                SimpleIoc.Default.Register<RemoteDeviceHelper>();
            }
            JObject navigationParam = new JObject();
            navigationParam["isNewLaunch"] = isNewLaunch;
            if (args is ProtocolActivatedEventArgs)
            {
                var protoArgs = args as ProtocolActivatedEventArgs;
                if (args.Kind == ActivationKind.Protocol)
                    navigationParam["url"] = protoArgs.Uri.AbsoluteUri;
            }
            Portable.Helpers.StateHelper.SessionState["LaunchData"] = navigationParam;
            SimpleIoc.Default.GetInstance<GalaSoft.MvvmLight.Views.INavigationService>().NavigateTo(ViewModelLocator.SplashPageKey);
        }

        public override Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            if (args.Kind == ActivationKind.VoiceCommand)
            {
                var result = (args as VoiceCommandActivatedEventArgs).Result;
                var properties = result.SemanticInterpretation.Properties
                    .ToDictionary(x => x.Key, x => x.Value);

                var command = result.RulePath.First();
                if (command.Equals("FreeTextCommand"))
                {
                    // get spoken text
                    var text = properties.First(x => x.Key.Equals("textPhrase")).Value[0];

                    // remember to handle response appropriately
                    var mode = properties.First(x => x.Key.Equals("commandMode")).Value;
                    if (mode.Equals("voice")) { /* okay to speak */ }
                    else { /* not okay to speak */ }

                    // update value
                    ViewModels.MainPageViewModel.Instance.Value = text;
                }
                else { /* unexpected command */ }
            }
            else
            {
                NavigationService.Navigate(typeof(Views.MainPage));
            }
			return Task.CompletedTask;
		}

 public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
 {
     CoreApp.Initialize(Services.LocationServices.LocationService.Current, Services.DataServices.ProtoDataService.Current);
     await Task.Delay(500);
     NavigationService.Navigate(typeof(Views.MainPage));
     await Task.CompletedTask;
 }

        // runs only when not restored from state
        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            await Task.Delay(50);

            if (_settings.FirstRun)
            {
                Window.Current.Activate();
            }
            else
            {
                NavigationService.Navigate(typeof(Views.MainPage));
            }

            if (ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar"))
            {
                var statusBar = StatusBar.GetForCurrentView();

                if (statusBar != null)
                {
                    statusBar.BackgroundOpacity = 1;
                    statusBar.BackgroundColor = (Color)Application.Current.Resources["AccentColour"];
                    statusBar.ForegroundColor = Colors.White;
                }
            }
        }

        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            await ViewModelController.RefreshLibrary();
            await ViewModelController.RefreshCollections();

            NavigationService.Navigate(typeof(Views.MainPage));
            await Task.CompletedTask;
        }

        /// <summary>
        /// The OnStartAsync implementation.
        /// </summary>
        /// <remarks>
        /// Runs only when not restored from a state.
        /// </remarks>
        /// <param name="startKind">The kind of App start.</param>
        /// <param name="args">The arguments from the activation.</param>
        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // Perform any long-running load
            await Task.Delay(0);

            // Navigate to the first page inside the shell
            this.NavigationService.Navigate(Pages.Main);
        }

        // runs only when not restored from state
        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // perform long-running load
            await Task.Delay(0);

            // navigate to first page
            NavigationService.Navigate(typeof(Views.MainPage));
        }

 public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
 {
     string arguments = string.Empty;
     if (DetermineStartCause(args) == AdditionalKinds.JumpListItem)
     {
         arguments = (args as LaunchActivatedEventArgs).Arguments;
         FileReceived?.Invoke(this, arguments);
     }
     NavigationService.Navigate(typeof(Views.MainPage), arguments);
 }

        public override Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            if ((args.Kind == ActivationKind.Launch) && ((args as LaunchActivatedEventArgs)?.PrelaunchActivated ?? false))
            {
                // update pre-launch live tile
            }

            // start the user experience
            NavigationService.Navigate(typeof(Views.MainPage));
            return Task.FromResult<object>(null);
        }

        // runs only when not restored from state
        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // perform long-running load
            await Task.Delay(0);

            // navigate to first page
            if (SettingsService.Instance.UserInteractionMode == false)
                NavigationService.Navigate(typeof(Views.MainPageHandleld));
            else
                NavigationService.Navigate(typeof(Views.MainPageTeam));
        }

        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // long-running startup tasks go here
            //await Task.Delay(5000);

            //自定义代码段
            SetTitleColor();
            PlaybackService.Instance.StartBackgroundAudioTask();

            NavigationService.Navigate(typeof(Views.DiscoveryPage));
            await Task.CompletedTask;
        }

        // runs only when not restored from state
        //public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        //{
        //    await Task.Delay(50);
        //    NavigationService.Navigate(typeof(Views.MainPage));
        //}

        //[TW] 1/16/2016 - Better fix for returning for suspending before release of 1.0.9 of template 10 
        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // navigate to first page
            var nav = WindowWrapper.ActiveWrappers.FirstOrDefault(wrapper => object.ReferenceEquals(wrapper.Window, Window.Current)).NavigationServices;
            if (nav.Count > 1)
            {
                nav.Remove(nav[0]);
            }

            NavigationService.Navigate(typeof(Views.MainPage));
            await Task.CompletedTask;
        }

 public override Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
 {
     if (startKind == StartKind.Launch)
     {
         this.NavigationService.Navigate(typeof(Views.MainPage));
     }
     else
     {
         // this.NavigationService.Navigate(typeof(Views.SecondPage));
     }
     return Task.FromResult<object>(null);
 }

        // runs only when not restored from state
        public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            await Task.Delay(3500);

            var param = string.Empty;
            var protocolArgs = args as ProtocolActivatedEventArgs;
            if (protocolArgs != null)
            {
                var uri = protocolArgs.Uri;
                var decoder = new Windows.Foundation.WwwFormUrlDecoder(uri.Query);
                param = decoder.GetFirstValueByName("filter");
            }
            NavigationService.Navigate(typeof(Views.MainPage), param);
        }

 public override Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
 {
     var shareArgs = args as ShareTargetActivatedEventArgs;
     if (shareArgs != null)
     {
         var key = SessionState.Add(typeof(ShareOperation), string.Empty, shareArgs.ShareOperation);
         NavigationService.Navigate(typeof(Views.MainPage), key.Key);
     }
     else
     {
         NavigationService.Navigate(typeof(Views.MainPage));
     }
     return Task.CompletedTask;
 }