public SkyDriveImportPage() { InitializeComponent(); this.labelHeight = this.statusLabel.Height; this.session = PhoneApplicationService.Current.State["parameter"] as LiveConnectSession; PhoneApplicationService.Current.State.Remove("parameter"); if (this.session == null) { throw new ArgumentException("Parameter passed to SkyDriveImportPage must be a LiveConnectSession."); } this.skydriveStack = new List<List<SkyDriveListItem>>(); this.skydriveStack.Add(new List<SkyDriveListItem>()); this.skydriveStack[0].Add(new SkyDriveListItem() { Name = "SkyDrive", SkyDriveID = "me/skydrive", Type = SkyDriveItemType.Folder, ParentID = "" }); this.currentFolderBox.Text = this.skydriveStack[0][0].Name; this.BackKeyPress += SkyDriveImportPage_BackKeyPress; #if GBC this.fileFormatLabel.Text = AppResources.SkyDriveFileFormatHint2; this.titleLabel.Text = AppResources.ApplicationTitle2; #endif }
public async void LoginWithSession() { try { LiveConnectSession savedSession = new LiveConnectSession(this.authClient); savedSession.RefreshToken = TestAuthClient.FakeOldRefreshToken; this.authClient.AuthClient.SaveSession(savedSession); await this.InitializeAuthClient(TestAuthClient.Scopes); LiveConnectSession session = this.authClient.Session; Assert.IsNotNull(session, "Session is null."); Assert.IsTrue(session.IsValid, "Session is not valid."); Assert.IsTrue(session.AccessToken == TestAuthClient.FakeAccessToken, "AccessToken is incorrect."); Assert.IsTrue(session.RefreshToken == TestAuthClient.FakeRefreshToken, "RefreshToken is incorrect."); Assert.IsTrue(new List<string>(session.Scopes).Count == TestAuthClient.Scopes.Length, "Scope count is incorrect."); } catch (Exception e) { Assert.Fail(e.ToString()); } finally { EnqueueTestComplete(); } }
public async static Task<List<SkyDriveEntity>> GetFolderContents(LiveConnectSession session, string folderId) { try { LiveConnectClient client = new LiveConnectClient(session); LiveOperationResult result = await client.GetAsync(folderId + "/files"); //clear entries in data data.Clear(); List<object> container = (List<object>)result.Result["data"]; foreach (var item in container) { SkyDriveEntity entity = new SkyDriveEntity(); IDictionary<string, object> dictItem = (IDictionary<string, object>)item; string type = dictItem["type"].ToString(); entity.IsFolder = type == "folder" || type == "album" ? true : false; entity.ID = dictItem["id"].ToString(); entity.Name = dictItem["name"].ToString(); data.Add(entity); } return null; } catch { return null; } }
private void SignInButtonSessionChanged(object sender, LiveConnectSessionChangedEventArgs e) { if (e.Session != null) { _session = e.Session; var client = new LiveConnectClient(_session); EventHandler<LiveOperationCompletedEventArgs> handler = null; handler = (s, even) => { client.GetCompleted -= handler; var resultDict = (Dictionary<string, object>)even.Result; var items = (List<object>)resultDict["data"]; // Перебираем все объекты в папке, отбиаем только тип folder foreach (var item in items.Cast<Dictionary<string, object>>().Where(item => item["type"].ToString() == "folder")) { _files.Add(new FileModel() { Name = item["name"].ToString() }); } lbFileList.ItemsSource = _files; }; client.GetCompleted += handler; //Путь к корню вашего skydrive client.GetAsync("me/skydrive/files"); } }
/// <summary> /// Provider class to access SkyDrive contents. /// </summary> /// <param name="session">A live connect session which will be used to retrieve cloud content.</param> public SkyDriveProvider(LiveConnectSession session) : base("SkyDrive", SupportedDrive.SkyDrive, RootDirectory) { Init(session); }
/// <summary> /// Versucht Login, ohne einen entsprechenden Dialog zu zu zeigen. /// </summary> /// <returns>Ein MobileServiceUser, der awaited werden kann oder null bei Misserfolg.</returns> internal static async Task<MobileServiceUser> AuthenticateSilent(MobileServiceClient mobileService) { LiveAuthClient liveAuthClient = new LiveAuthClient(APIKeys.LiveClientId); session = (await liveAuthClient.InitializeAsync()).Session; return await mobileService.LoginWithMicrosoftAccountAsync(session.AuthenticationToken); }
public async void SetSession(LiveConnectSession session) { _syncContext.Send(delegate { SkyDriveHelper.SetSession(session); }, null); }
/// <summary> /// Authenticate the user. Ask user for consent if neccessary. /// </summary> public async Task<LiveLoginResult> AuthenticateAsync(string scopes, bool silent) { Exception error = null; string accessToken = null; string authenticationToken = null; LiveLoginResult result = null; try { accessToken = await this.GetAccessToken(scopes, silent); LiveConnectSession session = new LiveConnectSession(this.authClient); session.AccessToken = accessToken; if (!string.IsNullOrEmpty(this.authClient.RedirectUrl) && !this.authClient.RedirectUrl.Equals(Win8ReturnUriScheme, StringComparison.OrdinalIgnoreCase)) { authenticationToken = await this.GetAuthenticationToken(this.authClient.RedirectUrl, silent); session.AuthenticationToken = authenticationToken; } result = new LiveLoginResult(LiveConnectSessionStatus.Connected, session); } catch (TaskCanceledException) { result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); } catch (Exception comExp) { switch (comExp.HResult) { case TailoredAuthClient.UserNotFoundLoginExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); break; case TailoredAuthClient.ConsentNotGrantedExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); break; case TailoredAuthClient.InvalidClientExceptionHResult: case TailoredAuthClient.InvalidAuthTargetExceptionHResult: error = new LiveAuthException(AuthErrorCodes.InvalidRequest, ResourceHelper.GetString("InvalidAuthClient"), comExp); break; default: error = new LiveAuthException(AuthErrorCodes.ServerError, ResourceHelper.GetString("ServerError"), comExp); break; } } if (result == null) { Debug.Assert(error != null); result = new LiveLoginResult(error); } return result; }
public SkyDriveBackup(MyLiveConnectClient liveConnectClient, string appFolderName, LiveConnectSession session, List<string> fileNames, BackupViewModel model) { SkyDriveFolderId = string.Empty; Files = new Dictionary<string, string>(); FileNames = fileNames; _session = session; _appFolderName = appFolderName; LiveClient = liveConnectClient; _model = model; GetFolders(); }
public void OnAuthComplete(LiveStatus status, LiveConnectSession session, Object userState) { try { source.SetResult(session); } catch (Exception ex) { source.TrySetException(ex); } }
private void signInButton_SessionChanged(object sender, LiveConnectSessionChangedEventArgs e) { if (e.Status == LiveConnectSessionStatus.Connected) { MainPage.session = e.Session; this.NavigationService.Navigate(new Uri("/Index.xaml", UriKind.Relative)); } else { MainPage.session = null; } }
/// <summary> /// The login async. /// </summary> /// <returns> /// The <see cref="Task"/> object. /// </returns> /// public async Task<AuthenticationSession> LoginAsync() { Exception rException = null; try { _authClient = new LiveAuthClient(); // Rui: https://msdn.microsoft.com/en-us/library/hh694244.aspx //var loginResult = await _authClient.InitializeAsync(_scopes); // Rui: https://msdn.microsoft.com/en-us/library/hh533677.aspx var result = await _authClient.LoginAsync(_scopes); //if (loginResult.Status == LiveConnectSessionStatus.Connected) if (result.Status == LiveConnectSessionStatus.Connected) { //_liveSession = loginResult.Session; _liveSession = result.Session; var meResult = await GetUserInfo(); var session = new AuthenticationSession { AccessToken = result.Session.AccessToken, //AccessToken = loginResult.Session.AccessToken, Provider = Constants.MicrosoftProvider, UserInfo = meResult["name"].ToString() }; return session; } } catch (LiveAuthException authExp) { System.Diagnostics.Debug.WriteLine("LiveAuthException = " + authExp.ToString()); } catch (LiveConnectException connExp) { System.Diagnostics.Debug.WriteLine("LiveConnectException = " + connExp.ToString()); } catch (Exception ex) { rException = ex; System.Diagnostics.Debug.WriteLine("rException = " + rException.ToString()); } await _logManager.LogAsync(rException); return null; }
public BackupPage() { InitializeComponent(); this.session = PhoneApplicationService.Current.State["parameter"] as LiveConnectSession; PhoneApplicationService.Current.State.Remove("parameter"); if (this.session == null) { throw new ArgumentException("Parameter passed to SkyDriveImportPage must be a LiveConnectSession."); } this.db = ROMDatabase.Current; this.romList.ItemsSource = db.GetROMList(); }
private async void Init(LiveConnectSession session) { if (session == null) throw new NullReferenceException("The 'session' parameter cannot be null"); _liveClient = new LiveConnectClient(session); _absoluteRootDirectory = RootDirectory; LiveOperationResult operationResult = await _liveClient.GetAsync("me"); //me, or user id will be taken cared of by the session object which will specifically connect to a particular user. so no need to worry about supporting multiple user accounts here. dynamic result = operationResult.Result; this.UserName = result.name; _rootCloudObject = await GetRootDirectoryAsync(); //_rootCloudObject = new SkyDriveObject(operationResult.Result.Result); }
public async Task<LiveLoginResult> Authenticate() { LiveLoginResult result = null; try { //string url = _liveAuthClient.GetLoginUrl(new string[] { "wl.signin", "wl.basic", "wl.emails"}); result = await _liveAuthClient.InitializeWebSessionAsync(new HttpContextWrapper(HttpContext.Current)); if (false) { result = await _liveAuthClient.ExchangeAuthCodeAsync(new HttpContextWrapper(HttpContext.Current)); } _session = result.Session; } catch (LiveAuthException){} return result; }
public static void MicrosoftAccount_SessionChanged(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e) { if (e.Status == Microsoft.Live.LiveConnectSessionStatus.Connected) { MicrosoftAccountClient = new LiveConnectClient(e.Session); MicrosoftAccountSession = e.Session; MicrosoftAccountClient.GetCompleted += client_GetCompleted; MicrosoftAccountClient.GetAsync("me", null); } else { CoreViewModel.Instance.MicrosoftAccountImage = "/Images/stock_user.png"; CoreViewModel.Instance.MicrosoftAccountName = "no Microsoft Account connected"; MicrosoftAccountClient = null; } }
private async void SignInButton_SessionChanged(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e) { if (e.Status == Microsoft.Live.LiveConnectSessionStatus.Connected) { _currentSession = e.Session; this.liveClient = new LiveConnectClient(e.Session); await this.GetMe(); this.Proceed.Visibility = System.Windows.Visibility.Visible; } else { this.Proceed.Visibility = System.Windows.Visibility.Collapsed; this.liveClient = null; this.tbGreeting.Text = e.Error != null ? e.Error.ToString() : string.Empty; } }
/// <summary> /// Creates a new LiveConnectClient instance. /// </summary> /// <param name="session">the session object that contains the authentication information.</param> public LiveConnectClient(LiveConnectSession session) { if (session == null) { throw new ArgumentNullException("session"); } this.Session = session; this.syncContext = SynchronizationContextWrapper.Current; #if DEBUG this.ApiEndpoint = string.IsNullOrEmpty(LiveConnectClient.ApiEndpointOverride) ? LiveConnectClient.DefaultApiEndpoint : LiveConnectClient.ApiEndpointOverride; #else this.ApiEndpoint = LiveConnectClient.DefaultApiEndpoint; #endif }
private async void btnLogin_Click(object sender, RoutedEventArgs e) { // 認証用インスタンスを生成 var authClient = new LiveAuthClient(); // スコープを設定 var scopes = new List<string>() { "wl.signin", "wl.skydrive_update" }; // ログイン用ダイアログを表示する var authResult = await authClient.LoginAsync(scopes); if (authResult.Status == LiveConnectSessionStatus.Connected) { Session = authResult.Session; } else { // サインインに失敗 return; } }
//event triggered when Skydrive sign in status is changed private void btnSignIn_SessionChanged(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e) { //if the user is signed in if (e.Status == LiveConnectSessionStatus.Connected) { _session = e.Session; _client = new LiveConnectClient(e.Session); _model.Message = "Accessing SkyDrive..."; _myClient = new MyLiveConnectClient(e.Session); _backup = new SkyDriveBackup(_myClient, SkyDriveFolderName, e.Session, new List<string> { "ReminderBackup.txt", "HistoryBackup.txt", "HarvestBackup.txt" }, _model); } else { _model.Message = "Not signed in."; _client = null; } }
/// <summary> /// Login mit einem entsprechenden Dialog. /// </summary> /// <returns>Ein MobileServiceUser, der awaited werden kann oder null bei Misserfolg.</returns> internal async static Task<MobileServiceUser> Authenticate(MobileServiceClient mobileService) { LiveAuthClient liveAuthClient = new LiveAuthClient(APIKeys.LiveClientId); var source = new TaskCompletionSource<MobileServiceUser>(); liveAuthClient.Logout(); var scopes = new string[] { "wl.basic", "wl.offline_access", "wl.signin" }; App.Current.RootVisual.Visibility = System.Windows.Visibility.Collapsed; try { session = (await liveAuthClient.LoginAsync(scopes)).Session; } finally { App.Current.RootVisual.Visibility = System.Windows.Visibility.Visible; } return await mobileService.LoginWithMicrosoftAccountAsync(session.AuthenticationToken); }
void btnSignin_SessionChanged(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e) { if (e.Status == LiveConnectSessionStatus.Connected) { PhoneApplicationService.Current.State["parameter"] = this.session = e.Session; this.NavigationService.Navigate(new Uri("/SkyDriveImportPage.xaml", UriKind.Relative)); //LiveConnectClient client = new LiveConnectClient(e.Session); //this.session = e.Session; //testLabel.Text = "Signed in."; //client.GetCompleted += client_GetCompleted; //client.GetAsync("me", null); } else { session = null; if (e.Error != null) { statusLabel.Text = "Error calling API: " + e.Error.ToString(); } } }
private async System.Threading.Tasks.Task Authenticate() { LiveAuthClient liveIdClient = new LiveAuthClient("https://sendit.azure-mobile.net/"); while (session == null) { // Force a logout to make it easier to test with multiple Microsoft Accounts if (liveIdClient.CanLogout) liveIdClient.Logout(); LiveLoginResult result = await liveIdClient.LoginAsync(new[] { "wl.basic" }); if (result.Status == LiveConnectSessionStatus.Connected) { session = result.Session; LiveConnectClient client = new LiveConnectClient(result.Session); LiveOperationResult meResult = await client.GetAsync("me"); MobileServiceUser loginResult = await App.MobileService.LoginAsync(result.Session.AuthenticationToken); string title = string.Format("Welcome {0}!", meResult.Result["first_name"]); var message = string.Format("You are now logged in - {0}", loginResult.UserId); var dialog = new MessageDialog(message, title); dialog.Commands.Add(new UICommand("OK")); await dialog.ShowAsync(); } else { session = null; var dialog = new MessageDialog("You must log in.", "Login Required"); dialog.Commands.Add(new UICommand("OK")); await dialog.ShowAsync(); } } }
/// <summary> /// Creates a LiveConnectSession object based on the parsed response. /// </summary> private static LiveConnectSession CreateSession(IDictionary<string, object> result) { var session = new LiveConnectSession(); Debug.Assert(result.ContainsKey(AuthConstants.AccessToken)); if (result.ContainsKey(AuthConstants.AccessToken)) { session.AccessToken = result[AuthConstants.AccessToken] as string; if (result.ContainsKey(AuthConstants.AuthenticationToken)) { session.AuthenticationToken = result[AuthConstants.AuthenticationToken] as string; } if (result.ContainsKey(AuthConstants.ExpiresIn)) { if (result[AuthConstants.ExpiresIn] is string) { session.Expires = CalculateExpiration(result[AuthConstants.ExpiresIn] as string); } else { session.Expires = DateTimeOffset.UtcNow.AddSeconds((int)result[AuthConstants.ExpiresIn]); } } if (result.ContainsKey(AuthConstants.Scope)) { session.Scopes = LiveAuthUtility.ParseScopeString(result[AuthConstants.Scope] as string); } if (result.ContainsKey(AuthConstants.RefreshToken)) { session.RefreshToken = result[AuthConstants.RefreshToken] as string; } } return session; }
private async Task<Boolean> LogInToSkydrive() { var hasErrors = false; do { try { hasErrors = false; this.retrySelected = false; LiveAuthClient auth = new LiveAuthClient(); LiveLoginResult loginResult = await auth.LoginAsync(new string[] { "wl.signin", "wl.skydrive", "wl.skydrive_update" }); if (loginResult.Status == LiveConnectSessionStatus.Connected) { LiveSession = loginResult.Session; return true; } } catch (LiveAuthException) { hasErrors = true; } if (hasErrors) { var errorTitle = "Live Connect error"; await ShowMessage(errorTitle, "Exception occured while logging in to Skydrive."); } } while (this.retrySelected); return false; }
public OneNoteRepository(LiveConnectSession liveConnectSession) { this.liveConnectSession = liveConnectSession; }
private static bool AreSessionsSame(LiveConnectSession session1, LiveConnectSession session2) { if (session1 != null && session2 != null) { return session1.AccessToken == session2.AccessToken && session1.AuthenticationToken == session2.AuthenticationToken; } return session1 == session2; }
/// <summary> /// Creates a LiveConnectSession object based on the parsed response. /// </summary> internal static LiveConnectSession CreateSession(LiveAuthClient client, IDictionary<string, object> result) { var session = new LiveConnectSession(client); Debug.Assert(result.ContainsKey(AuthConstants.AccessToken)); if (result.ContainsKey(AuthConstants.AccessToken)) { session.AccessToken = result[AuthConstants.AccessToken] as string; if (result.ContainsKey(AuthConstants.AuthenticationToken)) { session.AuthenticationToken = result[AuthConstants.AuthenticationToken] as string; } } return session; }
/// <summary> /// Writes the user current session. /// </summary> public static void UpdateUserSession(HttpContextBase context, LiveLoginResult loginResult, string requestTs) { if (context == null) { return; } Debug.Assert(loginResult != null); Dictionary <string, string> cookieValues = new Dictionary <string, string>(); HttpCookie cookie = context.Request.Cookies[AuthCookie]; HttpCookie newCookie = new HttpCookie(AuthCookie); newCookie.Path = "/"; string host = context.Request.Headers["Host"]; newCookie.Domain = host.Split(':')[0]; if (cookie != null && cookie.Values != null) { foreach (string key in cookie.Values.AllKeys) { newCookie.Values[key] = cookie[key]; } } LiveConnectSession session = loginResult.Session; if (session != null) { newCookie.Values[AuthConstants.AccessToken] = Uri.EscapeDataString(session.AccessToken); newCookie.Values[AuthConstants.AuthenticationToken] = Uri.EscapeDataString(session.AuthenticationToken); newCookie.Values[AuthConstants.Scope] = Uri.EscapeDataString(LiveAuthUtility.BuildScopeString(session.Scopes)); newCookie.Values[AuthConstants.ExpiresIn] = Uri.EscapeDataString(LiveAuthWebUtility.GetExpiresInString(session.Expires)); newCookie.Values[AuthConstants.Expires] = Uri.EscapeDataString(LiveAuthWebUtility.GetExpiresString(session.Expires)); } LiveConnectSessionStatus status; if (!string.IsNullOrEmpty(newCookie[AuthConstants.AccessToken])) { // We have an access token, so it is connected, regardless expired or not // since it is handled after loading the session in both Asp.Net and JS library. status = LiveConnectSessionStatus.Connected; } else { status = loginResult.Status; if (loginResult.Status == LiveConnectSessionStatus.Unknown) { // If we recorded NotConnected previously, keep it. LiveConnectSessionStatus statusFromCookie; if (Enum.TryParse <LiveConnectSessionStatus>( newCookie[AuthConstants.Status], true /*ignore case*/, out statusFromCookie)) { if (statusFromCookie == LiveConnectSessionStatus.NotConnected) { status = statusFromCookie; } } } } newCookie.Values[AuthConstants.Status] = GetStatusString(status); // Needs to write error to inform the JS library. LiveAuthException authError = loginResult.Error as LiveAuthException; if (authError != null) { newCookie.Values[AuthConstants.Error] = Uri.EscapeDataString(authError.ErrorCode); newCookie.Values[AuthConstants.ErrorDescription] = HttpUtility.UrlPathEncode(authError.Message); } else if (status != LiveConnectSessionStatus.Connected) { newCookie.Values[AuthConstants.Error] = Uri.EscapeDataString(AuthErrorCodes.AccessDenied); newCookie.Values[AuthConstants.ErrorDescription] = HttpUtility.UrlPathEncode("Cannot retrieve access token."); } if (!string.IsNullOrEmpty(requestTs)) { newCookie.Values[AuthConstants.ClientRequestTs] = requestTs; } context.Response.Cookies.Add(newCookie); }
/// <summary> /// Creates a new LiveLoginResult instance. /// </summary> public LiveLoginResult(LiveConnectSessionStatus status, LiveConnectSession session) { this.Status = status; this.Session = session; }
/// <summary> /// Save session to persistence store. N/A on Windows 8. /// </summary> public void SaveSession(LiveConnectSession session) { // No-op. }
private void TryRefreshToken(string redirectUrl) { Debug.Assert(this.loginStatus != null); IEnumerable <string> scopes; LiveAuthException error; bool isTokenRequest = this.CheckRefreshTokenRequest(out scopes, out error); if (error != null) { this.OnAuthTaskCompleted(new LiveLoginResult(error)); return; } // Try to refresh a token if // i) there is a token request or // ii) we don't have a token or // iii) the current token is expired. LiveLoginResult result = null; LiveConnectSession session = this.loginStatus.Session; bool hasValidToken = session != null && session.IsValid; bool shouldRefresh = (this.refreshTokenHandler != null) && (isTokenRequest || !hasValidToken); if (!shouldRefresh) { this.OnAuthTaskCompleted(null); return; } if (this.initScopes == null) { // We don't have initScopes, then use the scopes received from Url. this.initScopes = scopes; } this.refreshTokenHandler.RetrieveRefreshTokenAsync().ContinueWith(t => { try { this.refreshTokenInfo = t.Result; if (this.refreshTokenInfo != null) { string currentUserId = this.publicAuthClient.CurrentUserId; if (currentUserId != null && this.refreshTokenInfo.UserId != currentUserId) { // There is a user Id available in current session. We need to ensure the token provided matches it. result = new LiveLoginResult(new LiveAuthException( AuthErrorCodes.InvalidRequest, ErrorText.RefereshTokenNotMatchUserId)); } else { LiveAuthRequestUtility.RefreshTokenAsync( this.clientId, this.clientSecret, redirectUrl, this.refreshTokenInfo.RefreshToken, null/*scopes - We intentially specify null scopes and validate the initScopes after we have the session * result. With this approach, we can return notConnected if initScopes is not satisfied, and surface * the error if there is one. */ ).ContinueWith((Task <LiveLoginResult> rt) => { result = rt.Result; this.OnAuthTaskCompleted(result); }); return; } } } catch (Exception ex) { error = new LiveAuthException(AuthErrorCodes.ClientError, ErrorText.RetrieveRefreshTokenError, ex); result = new LiveLoginResult(error); } this.OnAuthTaskCompleted(result); }); }
/// <summary> /// Authenticate the user. Ask user for consent if neccessary. /// </summary> public async Task <LiveLoginResult> AuthenticateAsync(string scopes, bool silent) { Exception error = null; string accessToken = null; string authenticationToken = null; LiveLoginResult result = null; try { accessToken = await this.GetAccessToken(scopes, silent); LiveConnectSession session = new LiveConnectSession(this.authClient); session.AccessToken = accessToken; if (!string.IsNullOrEmpty(this.authClient.RedirectUrl) && !this.authClient.RedirectUrl.StartsWith(Win8AppIdPrefix, StringComparison.OrdinalIgnoreCase)) { authenticationToken = await this.GetAuthenticationToken(this.authClient.RedirectUrl, silent); session.AuthenticationToken = authenticationToken; } result = new LiveLoginResult(LiveConnectSessionStatus.Connected, session); } catch (TaskCanceledException) { result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); } catch (Exception comExp) { switch (comExp.HResult) { case TailoredAuthClient.UserNotFoundLoginExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); break; case TailoredAuthClient.ConsentNotGrantedExceptionHResult: result = new LiveLoginResult(LiveConnectSessionStatus.NotConnected, null); break; case TailoredAuthClient.InvalidClientExceptionHResult: case TailoredAuthClient.InvalidAuthTargetExceptionHResult: error = new LiveAuthException(AuthErrorCodes.InvalidRequest, ResourceHelper.GetString("InvalidAuthClient"), comExp); break; default: error = new LiveAuthException(AuthErrorCodes.ServerError, ResourceHelper.GetString("ServerError"), comExp); break; } } if (result == null) { Debug.Assert(error != null); result = new LiveLoginResult(error); } return(result); }
// Authenticate the user via Microsoft Account (the default on Windows Phone) // Authentication via Facebook, Twitter or Google ID will be added in a future release. private async Task Authenticate() { prgBusy.IsActive = true; Exception exception = null; try { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { TextUserName.Text = "Please wait while we log you in..."; }); LiveAuthClient liveIdClient = new LiveAuthClient(ConfigSecrets.AzureMobileServicesURI); while (session == null) { // Force a logout to make it easier to test with multiple Microsoft Accounts // This code should be commented for the release build //if (liveIdClient.CanLogout) // liveIdClient.Logout(); // Microsoft Account Login LiveLoginResult result = await liveIdClient.LoginAsync(new[] { "wl.basic" }); if (result.Status == LiveConnectSessionStatus.Connected) { session = result.Session; LiveConnectClient client = new LiveConnectClient(result.Session); LiveOperationResult meResult = await client.GetAsync("me"); user = await App.MobileService .LoginWithMicrosoftAccountAsync(result.Session.AuthenticationToken); userfirstname = meResult.Result["first_name"].ToString(); userlastname = meResult.Result["last_name"].ToString(); await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { var message = string.Format("Logged in as {0} {1}", userfirstname, userlastname); TextUserName.Text = message; }); // Debugging dialog, make sure it's commented for publishing //var dialog = new MessageDialog(message, "Welcome!"); //dialog.Commands.Add(new UICommand("OK")); //await dialog.ShowAsync(); isLoggedin = true; SetUIState(true); } else { session = null; await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { UpdateStatus("You must log in before you can chat in this app.", true); var dialog = new MessageDialog("You must log in.", "Login Required"); dialog.Commands.Add(new UICommand("OK")); dialog.ShowAsync(); }); } } } catch (Exception ex) { exception = ex; } if (exception != null) { UpdateStatus("Something went wrong when trying to log you in.", true); string msg1 = "An error has occurred while trying to sign you in." + Environment.NewLine + Environment.NewLine; // TO DO: Dissect the various potential errors and provide a more appropriate // error message in msg2 for each of them. string msg2 = "Make sure that you have an active Internet connection and try again."; await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { new MessageDialog(msg1 + msg2, "Authentication Error").ShowAsync(); }); } prgBusy.IsActive = false; }