// *** Methods ***

        public async Task<bool> Activate(IActivatedEventArgs activatedEventArgs)
        {
            // Raise Activating event

            EventHandler<IActivatedEventArgs> activatingEventHandler = Activating;

            if (activatingEventHandler != null)
                activatingEventHandler(this, activatedEventArgs);

            // Call activate on all activation handlers
            // NB: We convert to an array so that the Select is not called multiple times

            IEnumerable<Task<bool>> activationTasks = registeredServices.Select(service => service.Activate(activatedEventArgs)).ToArray();
            await Task.WhenAll(activationTasks);

            // Raise Activated event

            EventHandler<IActivatedEventArgs> activatedEventHandler = Activated;

            if (activatedEventHandler != null)
                activatedEventHandler(this, activatedEventArgs);

            // Determine if the activation was handled by any of the handlers

            Task<bool> firstHandlingTask = activationTasks.FirstOrDefault(task => task.Result == true);
            bool handled = firstHandlingTask != null;

            // If the activation was handled then activate the current window
            
            if (handled && Window.Current != null)
                Window.Current.Activate();

            return handled;
        }

        protected override void OnActivated(IActivatedEventArgs args)
        {
            Frame rootFrame = Window.Current.Content as Frame;

            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();

                rootFrame.NavigationFailed += OnNavigationFailed;

                // Place the frame in the current Window
                Window.Current.Content = rootFrame;
            }


            switch (args.Kind)
            {
                case ActivationKind.VoiceCommand:
                    HandleVoiceCommand(args, rootFrame);
                    break;
                    
                default:
                    break;
            }

            Window.Current.Activate();

            base.OnActivated(args);
        }

 // runs even if restored from state
 public override async Task OnInitializeAsync(IActivatedEventArgs args)
 {
     // setup hamburger shell
     var nav = NavigationServiceFactory(BackButton.Attach, ExistingContent.Include);
     Window.Current.Content = new Views.Shell(nav);
     await Task.Yield();
 }

 protected override void OnActivated(IActivatedEventArgs args)
 {
     if (args.Kind == ActivationKind.Protocol)
     {
         OnProtocolActivated((ProtocolActivatedEventArgs)args);
     }
 }

        protected override void OnActivated(IActivatedEventArgs e)
        {
            if (e.Kind == ActivationKind.Protocol)
            {
                var protocolArgs = e as ProtocolActivatedEventArgs;
                var uri = protocolArgs.Uri;

                if (uri.AbsoluteUri.IndexOf("?access_token=") != -1)
                {
                    int Start = uri.AbsoluteUri.IndexOf("?access_token=");
                    int offset = ("?access_token=").Length;
                    int End = uri.AbsoluteUri.IndexOf("&expires_in");
                    string FBtoken = uri.AbsoluteUri.Substring(Start + offset, End - Start - offset);
                    if (OnProtocolActivated != null)
                        OnProtocolActivated.Invoke(this, FBtoken);
                }
                else
                {
                    SocialAuthentication.RaiseAuthenFail();
                }
                return;
            }

            base.OnActivated(e);
        }

		/// <summary>
		/// Invoked when application is launched through protocol.
		/// Read more - http://msdn.microsoft.com/library/windows/apps/br224742
		/// </summary>
		/// <param name="args"></param>
		protected override void OnActivated(IActivatedEventArgs args)
		{
			string appArgs = "";
			
			switch (args.Kind)
			{
				case ActivationKind.Protocol:
					ProtocolActivatedEventArgs eventArgs = args as ProtocolActivatedEventArgs;
					splashScreen = eventArgs.SplashScreen;
					appArgs += string.Format("Uri={0}", eventArgs.Uri.AbsoluteUri);
					break;
                case ActivationKind.VoiceCommand:
                    var commandArgs = args as VoiceCommandActivatedEventArgs;
                    SpeechRecognitionResult speechRecognitionResult = commandArgs.Result;
                    string voiceCommandName = speechRecognitionResult.RulePath[0];

                    // This is one way of handling different commands found in the VCD file with code.
                    switch (voiceCommandName)
                    {
                        case "startPlay":
                            {
                                break;
                            }
                        case "checkScore":
                            if (speechRecognitionResult.SemanticInterpretation.Properties.ContainsKey("message"))
                            {
                                // Just to show you can get the message as well..
                                string message = speechRecognitionResult.SemanticInterpretation.Properties["message"][0];
                            }
                            break;
                    }
                    break;
            }
			InitializeUnity(appArgs);
		}

        protected override void OnActivated(IActivatedEventArgs args)
        {
            var rootFrame = Window.Current.Content as Frame;
            if (rootFrame == null)
            {
                base.OnActivated(args);
                return;
            }

            // Return to Reply Page with image.

            var replyPage = rootFrame.Content as ReplyPage;
            if (replyPage != null && args is FileOpenPickerContinuationEventArgs)
            {
                replyPage.ContinueFileOpenPicker(args as FileOpenPickerContinuationEventArgs);
            }

            var editPage = rootFrame.Content as EditPage;
            if (editPage != null && args is FileOpenPickerContinuationEventArgs)
            {
                editPage.ContinueFileOpenPicker(args as FileOpenPickerContinuationEventArgs);
            }

            // Voice command!111!!!11!

            if (args.Kind == ActivationKind.VoiceCommand)
            {
                VoiceCommandActivatedEventArgs vcArgs = (VoiceCommandActivatedEventArgs) args;
                string voiceCommandName = vcArgs.Result.RulePath.First();
                rootFrame.Navigate(typeof(VoiceHandlePage), vcArgs.Result);
            }
            base.OnActivated(args);

        }

    protected override void OnActivated(IActivatedEventArgs args)
    {
      var launchContinuationArgs = args as ProtocolWithResultsContinuationActivatedEventArgs;
      if (launchContinuationArgs != null)
      {

        Frame rootFrame = Window.Current.Content as Frame;

        // Do not repeat app initialization when the Window already has content,
        // just ensure that the window is active
        if (rootFrame == null)
        {
          // Create a Frame to act as the navigation context and navigate to the first page
          rootFrame = new Frame();
          // Set the default language
          rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];

          rootFrame.NavigationFailed += OnNavigationFailed;

          // Place the frame in the current Window
          Window.Current.Content = rootFrame;
        }

        // Navigate to the continuation page, configuring the new page by passing the 
        // results ValueSet as a navigation parameter
        rootFrame.Navigate(typeof(ContinuationPage),launchContinuationArgs.Result);
        
        // Ensure the current window is active
        Window.Current.Activate();
      }
    }

        // *** Methods ***

        public Task<bool> Activate(IActivatedEventArgs activatedEventArgs)
        {
            if (activatedEventArgs == null)
                throw new ArgumentNullException(nameof(activatedEventArgs));

            return ActivateInternal(activatedEventArgs);
        }

 protected override async void OnActivated(IActivatedEventArgs e)
 {
   switch (e.Kind)
   {
     // See http://go.microsoft.com/fwlink/?LinkID=288842
     case ActivationKind.Launch:
       var args = e as LaunchActivatedEventArgs;
       if (args.TileId == "App" && !args.Arguments.Any())
       { await OnActivatedByPrimaryTileAsync(args); }
       else if (args.TileId == "App" && args.Arguments.Any())
       { await OnActivatedBySecondaryTileAsync(args); }
       else
       { await OnActivatedByToastNotificationAsync(args); }
       break;
     case ActivationKind.Protocol:
     case ActivationKind.ProtocolForResults:
     case ActivationKind.ProtocolWithResultsContinuation:
       await OnActivatedByProtocolAsync(e as ProtocolActivatedEventArgs);
       break;
     default:
       break;
   }
   // this is to handle any other type of activation
   await this.OnActivatedAsync(e);
   Window.Current.Activate();
 }

 protected override void OnActivated(IActivatedEventArgs e)
 {
     base.OnActivated(e);
     try
     {
         if (e.Kind == ActivationKind.VoiceCommand)
         {
             VoiceCommandActivatedEventArgs args = (VoiceCommandActivatedEventArgs)e;
             Library.Command = args.Result.SemanticInterpretation.Properties["colour"].FirstOrDefault();
         }
     }
     catch { }
     Frame rootFrame = Window.Current.Content as Frame;
     if (rootFrame == null)
     {
         rootFrame = new Frame();
         rootFrame.NavigationFailed += OnNavigationFailed;
         Window.Current.Content = rootFrame;
     }
     if (rootFrame.Content == null)
     {
         rootFrame.Navigate(typeof(MainPage), e);
     }
     Window.Current.Activate();
 }

 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;
 }

        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 async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
        {
            // long-running startup tasks go here

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

        protected override void OnActivated(IActivatedEventArgs args)
        {
            InitializeApp();

            // Was the app activated by a voice command?
            if (args.Kind == Windows.ApplicationModel.Activation.ActivationKind.VoiceCommand)
            {
                var commandArgs = args as Windows.ApplicationModel.Activation.VoiceCommandActivatedEventArgs;
                Windows.Media.SpeechRecognition.SpeechRecognitionResult speechRecognitionResult = commandArgs.Result;

                // If so, get the name of the voice command and the values for the semantic properties from the grammar file
                string voiceCommandName = speechRecognitionResult.RulePath[0];
                var interpretation = speechRecognitionResult.SemanticInterpretation.Properties;
                IReadOnlyList<string> dictatedSearchTerms;
                interpretation.TryGetValue("dictatedSearchTerms", out dictatedSearchTerms);

                switch (voiceCommandName)
                {
                    case "NearMeSearch":
                        MainViewModel.SearchNearMeCommand.Execute(null);
                        break;

                    case "PlaceSearch":
                        MainViewModel.SearchTerm = dictatedSearchTerms[0];
                        MainViewModel.SearchTrailsCommand.Execute(null);
                        break;

                    default:
                        // There is no match for the voice command name.
                        break;
                }
            }
        }

        private async Task<bool> ActivateInternal(IActivatedEventArgs activatedEventArgs)
        {
            if (activatedEventArgs.Kind == ActivationKind.Search)
            {
                ISearchActivatedEventArgs searchEventArgs = (ISearchActivatedEventArgs)activatedEventArgs;

                // If the previous execution state was terminated then attempt to restore the navigation stack

                if (activatedEventArgs.PreviousExecutionState == ApplicationExecutionState.Terminated)
                    await _navigationManager.RestoreNavigationStack();

                // Otherwise if the application is a new instance navigate to the home page

                else if (activatedEventArgs.PreviousExecutionState == ApplicationExecutionState.ClosedByUser
                      || activatedEventArgs.PreviousExecutionState == ApplicationExecutionState.NotRunning)
                    _navigationManager.NavigateTo(_navigationManager.HomePageName);

                // Then display the search results

                DisplaySearchResults(searchEventArgs.QueryText, searchEventArgs.Language);

                return true;
            }

            return false;
        }

 void Activate(IActivatedEventArgs e)
 {
     switch (e.Kind)
     {
         case ActivationKind.Launch:
             {
                 var args = e as ILaunchActivatedEventArgs;
                 if (args.PreviousExecutionState == ApplicationExecutionState.Running)
                     this.Frame.Navigate(typeof(Views.Splash));
                 else
                 {
                     // do not activate, let the splash activate itself
                     var page = new Views.Splash()
                     {
                         SplashScreen = args.SplashScreen,
                         Navigate = () => this.Frame.Navigate(typeof(Views.MainPage))
                     };
                     Window.Current.Content = page as UIElement;
                     page.Start();
                 }
                 break;
             }
         default:
             throw new NotImplementedException(e.Kind.ToString());
     }
 }

        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;
		}

 protected override void OnActivated(IActivatedEventArgs args)
 {
     if (args.Kind == ActivationKind.ProtocolForResults)
     {
         ShowPage(typeof(ProtocolPage), args);
     }
 }

        protected override void OnActivated(IActivatedEventArgs args)
        {
            Frame rootFrame = Window.Current.Content as Frame;

            if (rootFrame == null)
            {
                rootFrame = new Frame();

                rootFrame.NavigationFailed += OnNavigationFailed;

                // Place the frame in the current Window
                Window.Current.Content = rootFrame;
            }

            string uri = string.Empty;
            var protocolArgs = args as ProtocolActivatedEventArgs;
            if(protocolArgs != null)
            {
                uri = protocolArgs.Uri.ToString();
            }

            rootFrame.Navigate(typeof(ProtocolActivationPage), uri);

            // Ensure the current window is active
            Window.Current.Activate();
        }