private async Task Login(MobileServiceAuthenticationProvider provider)
		{
			var user = await _authenticationService.Login(provider);
			var userName = await GetIsOauthUserRegistered (user.UserId);
			await _databaseService.SaveCurrentUserAsync(new User { UserName = userName } );

			await _databaseService.DeleteAllScheduledConferencesAsync ();
			var conferenceDtos = await _remoteConferenceService.LoadScheduledConferencesAsync (userName);

			foreach (var conferenceDto in conferenceDtos) {
				var dto = conferenceDto;
				dto.IsAddedToSchedule = true;
				var conference = await TaskEx.Run (() => Mapper.Map<Conference> (dto));

				await _databaseService.SaveConferenceAsync (conference);

				foreach (var sessionDto in dto.Sessions)
				{
					SessionDto dto1 = sessionDto;
					var session = await TaskEx.Run(() => Mapper.Map<Session>(dto1));
					session.ConferenceId = conference.Id;
					await _databaseService.SaveSessionAsync(session);

					foreach (var speakerDto in sessionDto.Speakers)
					{
						SpeakerDto speakerDto1 = speakerDto;
						var speaker = await TaskEx.Run(() => Mapper.Map<Speaker>(speakerDto1));
						speaker.SessionId = session.Id;
						await _databaseService.SaveSpeakerAsync(speaker);
					}
				}
			}

			ShowViewModel<ConferencesTabViewModel> ();
		}

        public async Task<MobileServiceUser> LoginAsync(MobileServiceClient client, MobileServiceAuthenticationProvider provider)
        {
            try
            {
                var window = UIKit.UIApplication.SharedApplication.KeyWindow;
                var root = window.RootViewController;
                if(root != null)
                {
                    var current = root;
                    while(current.PresentedViewController != null)
                    {
                        current = current.PresentedViewController;
                    }


                    Settings.LoginAttempts++;

                    var user = await client.LoginAsync(current, provider);

                    Settings.AuthToken = user?.MobileServiceAuthenticationToken ?? string.Empty;
                    Settings.UserId = user?.UserId ?? string.Empty;

                    return user;
                }
            }
            catch(Exception e)
            {
                e.Data["method"] = "LoginAsync";
                Xamarin.Insights.Report(e);
            }

            return null;
        }

        private async Task Authenticate(MobileServiceAuthenticationProvider provider)
        {
           

                try
                {
                    WAMSRepositoryService service = Mvx.Resolve<IRepositoryService>() as WAMSRepositoryService;
                    user = await service.MobileService
                        .LoginAsync(this, provider);


                }
                catch (InvalidOperationException e)
                {

                }


                var vm = ViewModel as AuthViewModel;

                if (user != null)
                {

                    vm.CreateUserCommand.Execute(user);
                }
                else
                {
                    vm.BackCommand.Execute(null);
                }
         
        }

		public async void loginAsync(MobileServiceAuthenticationProvider provider){
			while(! await DependencyService.Get<IAuthenticate> ().loginAsync (MobileServiceAuthenticationProvider.Twitter)){
				await DisplayAlert ("Login Fail", "Please try to login again", "OK");
			}
			await DisplayAlert ("Login", "Logged in successfully as: " +App.MobileService.CurrentUser.UserId, "OK");
			await Navigation.PushAsync (new Profile("twitter"));
		}

 /// <summary>
 /// Tests the <see cref="MobileServiceClient.RefreshUserAsync"/> functionality on the platform.
 /// </summary>
 /// <param name="provider">
 /// The provider with which to login.
 /// </param>
 /// <returns>
 /// The UserId and MobileServiceAuthentication token obtained from logging in.
 /// </returns>
 public static async Task<string> TestRefreshUserAsync(MobileServiceAuthenticationProvider provider)
 {
     string result;
     switch (provider)
     {
         case MobileServiceAuthenticationProvider.MicrosoftAccount:
             result = await TestMicrosoftAccountRefreshUserAsync();
             break;
         case MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory:
             result = await TestAADRefreshUserAsync();
             break;
         case MobileServiceAuthenticationProvider.Google:
             result = await TestGoogleRefreshUserAsync();
             break;
         case MobileServiceAuthenticationProvider.Facebook:
             result = await TestFacebookRefreshUserAsync();
             break;
         case MobileServiceAuthenticationProvider.Twitter:
             result = await TestTwitterRefreshUserAsync();
             break;
         default:
             result = "MobileServiceAuthenticationProvider is not recognized.";
             break;
     }
     return result;
 }

        private async System.Threading.Tasks.Task Authenticate(MobileServiceAuthenticationProvider msap)
        {
            try
            {
                user = await App.MobileService.LoginAsync(msap);
            }
            catch
            {

            }
            
            //THIS NEEDS TO BE FIXED TO STORE THE USER'S CREDENTIALs.
            //while (user == null)
            //{
            //    string message;
            //    try
            //    {
            //        user = await App.MobileService.LoginAsync(msap);
            //        message =
            //            string.Format("You are now logged in - {0}", user.UserId);
            //    }
            //    catch (InvalidOperationException)
            //    {
            //        message = "You must log in. Login Required";
            //    }

            //    MessageBox.Show(message);
            //}
        }

        private async Task DoLoginAsync(MobileServiceAuthenticationProvider provider)
        {
            MobileServiceUser user;

            try
            {
                user = await DependencyService.Get<IMobileClient>().LoginAsync(provider);
                App.AuthenticatedUser = user;
                System.Diagnostics.Debug.WriteLine("Authenticated with user: " + user.UserId);

#if __DROID__
                Droid.GcmService.RegisterWithMobilePushNotifications();
#elif __IOS__
                iOS.AppDelegate.IsAfterLogin = true;
                await iOS.AppDelegate.RegisterWithMobilePushNotifications();
#elif __WP__
                ContosoMoments.WinPhone.App.AcquirePushChannel(App.MobileService);
#endif

                //Navigation.InsertPageBefore(new ImagesList(), this);
                Navigation.InsertPageBefore(new AlbumsListView(), this);
                await Navigation.PopAsync();
            }
            catch (InvalidOperationException ex)
            {
                if (ex.Message.Contains("Authentication was cancelled"))
                {
                    messageLabel.Text = "Authentication cancelled by the user";
                }
            }
            catch (Exception ex)
            {
                messageLabel.Text = "Authentication failed";
            }
        }

        /// <summary>
        /// Starts the authentication process.
        /// </summary>
        /// <param name="provider">The provider to authenticate with.</param>
        public async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider)
        {
            try
            {
                var vault = new PasswordVault();

                // Login with the identity provider.
                var user = await AzureAppService.Current
                    .LoginAsync(provider);

                // Create and store the user credentials.
                var credential = new PasswordCredential(provider.ToString(),
                    user.UserId, user.MobileServiceAuthenticationToken);

                vault.Add(credential);
            }
            catch (InvalidOperationException invalidOperationException)
            {
                if (invalidOperationException.Message
                    .Contains("Authentication was cancelled by the user."))
                {
                    throw new AuthenticationCanceledException("Authentication canceled by user",
                        invalidOperationException);
                }

                throw new AuthenticationException("Authentication failed", invalidOperationException);
            }
            catch (Exception e)
            {
                throw new AuthenticationException("Authentication failed", e);
            }
        }

 private async void Login(MobileServiceAuthenticationProvider provider)
 {
     var client = new MobileServiceClient(this.uriEntry.Value, this.keyEntry.Value);
     var user = await client.LoginAsync(this, provider);
     var alert = new UIAlertView("Welcome", "Your userId is: " + user.UserId, null, "OK");
     alert.Show();
 }

 public LoginToken(MobileServiceUser user, MobileServiceAuthenticationProvider provider)
 {
     if (user != null && !string.IsNullOrWhiteSpace(user.MobileServiceAuthenticationToken))
     {
         User = user;
     }
     Provider = provider;
 }

        /// <summary>
        /// Instantiates a new instance of <see cref="MobileServiceTokenAuthentication"/>.
        /// </summary>
        /// <param name="client">
        /// The client.
        /// </param>
        /// <param name="provider">
        /// The authentication provider.
        /// </param>
        /// <param name="token">
        /// The token.
        /// </param>
        public MobileServiceTokenAuthentication(MobileServiceClient client, MobileServiceAuthenticationProvider provider, JObject token)
            :base(client, provider)
        {
            Debug.Assert(client != null, "client should not be null.");
            Debug.Assert(token != null, "token should not be null.");

            this.client = client;
            this.token = token;
        }

        /// <summary>
        /// Log a user into a Mobile Services application given a provider name and optional token object.
        /// </summary>
        /// <param name="provider" type="MobileServiceAuthenticationProvider">
        /// Authentication provider to use.
        /// </param>
        /// <param name="client">
        /// The <see cref="MobileServiceClient"/> to login with.
        /// </param>
        /// <param name="useSingleSignOn">
        /// Indicates that single sign-on should be used. Single sign-on requires that the
        /// application's Package SID be registered with the Windows Azure Mobile Service, but it
        /// provides a better experience as HTTP cookies are supported so that users do not have to
        /// login in everytime the application is launched.
        /// </param>
        /// <returns>
        /// Task that will complete when the user has finished authentication.
        /// </returns>
        public static Task<MobileServiceUser> LoginAsync(this IMobileServiceClient client, MobileServiceAuthenticationProvider provider, bool useSingleSignOn)
        {
            if(!useSingleSignOn)
            {
                return client.LoginAsync(provider);
            }

            MobileServiceSingleSignOnAuthentication auth = new MobileServiceSingleSignOnAuthentication(client, provider);
            return auth.LoginAsync();
        }

        public Task<MobileServiceUser> LoginAsync(IMobileServiceClient client, MobileServiceAuthenticationProvider provider, IDictionary<string, string> parameters = null)
        {
            try
            {
                return client.LoginAsync(Forms.Context, provider, parameters);
            }
            catch { }

            return null;
        }

 private static ZumoTest CreateLoginTest(MobileServiceAuthenticationProvider provider, bool useSingleSignOn)
 {
     string testName = string.Format("Login with {0}{1}", provider, useSingleSignOn ? " (using single sign-on)" : "");
     return new ZumoTest(testName, async delegate(ZumoTest test)
     {
         var client = ZumoTestGlobals.Instance.Client;
         var user = await client.LoginAsync(provider, useSingleSignOn);
         test.AddLog("Logged in as {0}", user.UserId);
         return true;
     });
 }

 public async Task<MobileServiceUser> LoginAsync(MobileServiceAuthenticationProvider provider)
 {
     try
     {
         return await mobileService.LoginAsync(provider);
     }
     catch (InvalidOperationException)
     {
         return null;
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MobileServiceAuthentication"/> class.
        /// </summary>
        /// <param name="client">
        /// The <see cref="MobileServiceClient"/> associated with this 
        /// MobileServiceLogin instance.
        /// </param>
        /// <param name="provider">
        /// The <see cref="MobileServiceAuthenticationProvider"/> used to authenticate.
        /// </param>
        public MobileServiceAuthentication(IMobileServiceClient client, MobileServiceAuthenticationProvider provider)
        {
            Debug.Assert(client != null, "client should not be null.");

            this.Client = client;
            this.Provider = provider;

            string providerName = this.Provider.ToString().ToLower();

            this.StartUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncUriFragment + "/" + providerName);
            this.EndUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncDoneUriFragment);
        }

 private async Task Login(MobileServiceAuthenticationProvider provider)
 {
     try
     {
         var user = await MobileService.LoginAsync(provider);
         AddToDebug("Logged in as {0}", user.UserId);
     }
     catch (Exception ex)
     {
         this.AddToDebug("Error: {0}", ex);
     }
 }

        private async Task LoginAsync(MobileServiceAuthenticationProvider provider)
        {
            var user = await authentication.LoginAsync(provider);

            if (user == null)
            {

            }
            else
            {
                applicationNavigation.ToCurrentExpenses();
            }
        }

		public async Task<bool> loginAsync (MobileServiceAuthenticationProvider provider){
			string message;
			try{
				await App.MobileService.LoginAsync (Forms.Context,provider);
				return true;
			}
			catch(InvalidOperationException){
				return false;
			}
			catch(Exception e){
				return false;
			}
		}

		public async Task<bool> loginAsync (MobileServiceAuthenticationProvider provider){
			string message;
			try{
				var view = UIApplication.SharedApplication.KeyWindow.RootViewController;
				await App.MobileService.LoginAsync (view, provider);
				return true;
			}
			catch(InvalidOperationException){
				return false;
			}
			catch(Exception e){
				return false;
			}
		}