private async void btnSignin_SessionChanged_2(object sender, LiveConnectSessionChangedEventArgs e)
 {
     currentLoginType = "Microsoft";
     if (TextValidation())
     {
         lblMsg.Text = "";
         App.liveAuthClient = new LiveAuthClient(redirectURL);
         LiveLoginResult liveLoginResult = await App.liveAuthClient.LoginAsync(new string[] { "wl.signin", "wl.basic" });
         if (liveLoginResult.Session != null && liveLoginResult.Status == LiveConnectSessionStatus.Connected)
         {
             client = new LiveConnectClient(liveLoginResult.Session);
             LiveOperationResult operationResult = await client.GetAsync("me");
             dynamic pic = await client.GetAsync("me/picture");
             try
             {
                 MobileServiceUser user = await App.MobileService.LoginAsync(client.Session.AuthenticationToken);
                 if (!String.IsNullOrEmpty(user.UserId))
                 {
                     dynamic meResult = operationResult.Result;
                     if (meResult.first_name != null && meResult.last_name != null)
                         //initiliazed user LiveUserInfo properties
                         SetUserDetails(user.UserId, meResult.name, meResult.first_name, meResult.last_name, pic.Result.location);
                     else
                         infoTextBlock.Text = "Welcome, Guest!";
                 }
             }
             catch (LiveConnectException exception)
             {
                 this.infoTextBlock.Text = "Error calling API: " +
                     exception.Message;
             }
         }
     }
 }

        private void UploadFile (string name)
            {
            try
                {
                using (var storage = IsolatedStorageFile.GetUserStoreForApplication ())
                    {
                    var fileStream = storage.OpenFile (name + ".wav", FileMode.Open);
                    var uploadClient = new LiveConnectClient (Utilities.SkyDriveSession);
                    uploadClient.UploadCompleted += UploadClient_UploadCompleted;
                    uploadClient.UploadAsync ("me/skydrive", name + ".wav", fileStream, OverwriteOption.Rename);
                    _progressIndicatror = new ProgressIndicator
                    {
                        IsVisible = true,
                        IsIndeterminate = true,
                        Text = "Uploading file..."
                    };

                    SystemTray.SetProgressIndicator (this, _progressIndicatror);
                    }
                }
            catch (Exception)
                {
                ShowError ();
                NavigationService.GoBack ();
                }
            }

        private async void Button_Click_1(object sender, RoutedEventArgs e)
        {
            var liveIdClient = new LiveAuthClient();
            Task<LiveLoginResult> tskLoginResult = liveIdClient.LoginAsync(new string[] { "wl.signin" });
            tskLoginResult.Wait();

            switch (tskLoginResult.Result.Status)
            {
                case LiveConnectSessionStatus.Connected:

                    try
                    {
                        LiveConnectClient client = new LiveConnectClient(tskLoginResult.Result.Session);
                        LiveOperationResult liveOperationResult = await client.GetAsync("me");

                        dynamic operationResult = liveOperationResult.Result;
                        string name = string.Format("Hello {0} ", operationResult.first_name);
                    }
                    catch (Exception ex)
                    {
                        throw new Exception(string.Format("ERRO, {0}", ex.Message), ex);
                    }

                    break;
                case LiveConnectSessionStatus.NotConnected:
                    int j = 10;
                    break;
                default:
                    int z = 10;
                    break;
            }
        }

        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  async void loginButton_Click(object sender, RoutedEventArgs e)//登录
        {
            try
            {
                msgText.Text = "亲：正在登录";
                var authClient = new LiveAuthClient();

                LiveLoginResult result = await authClient.LoginAsync(new string[] { "wl.signin", "wl.skydrive" });

                if (result.Status == LiveConnectSessionStatus.Connected)
                {

                    var connectClient = new LiveConnectClient(result.Session);
                    var meResult = await connectClient.GetAsync("me");
                    msgText.Text = "亲爱的：" + meResult.Result["name"].ToString() + "  您已成功登录OneDrive!";
                }
                updateButton.Visibility = Visibility.Visible;
                uploadButton.Visibility = Visibility.Visible;
                downButton.Visibility = Visibility.Visible;


            }
            catch (LiveAuthException ex)
            {
                msgText.Text = ex.Message;
            }
            catch (LiveConnectException ex)
            {
                msgText.Text = ex.Message;
            }
        }

        private async Task<dynamic> GetUserLogged() 
        {
            var liveIdClient = new LiveAuthClient();
            Task<LiveLoginResult> tskLoginResult = liveIdClient.LoginAsync(new string[] { "wl.signin" });
            tskLoginResult.Wait();

            switch (tskLoginResult.Result.Status)
            {
                case LiveConnectSessionStatus.Connected:
                    try
                    {
                        LiveConnectClient client = new LiveConnectClient(tskLoginResult.Result.Session);
                        LiveOperationResult liveOperationResult = await client.GetAsync("me");

                        dynamic operationResult = liveOperationResult.Result;
                        return operationResult;
                    }
                    catch (Exception ex)
                    {
                        throw new Exception(string.Format("ERRO, {0}", ex.Message), ex);
                    }
                case LiveConnectSessionStatus.NotConnected:
                    break;
            }

            return null;
        }

        /// <summary>
        /// DownloadPictures downs picutre link from sky dirve
        /// </summary>
        /// <param name="albumItem"></param>
        private async void DownloadPictures(SkydriveAlbum albumItem)
        {
            LiveConnectClient folderListClient = new LiveConnectClient(App.Session);
            LiveOperationResult result = await folderListClient.GetAsync(albumItem.ID + "/files");
            FolderListClient_GetCompleted(result, albumItem);

        }

 private async void liveSignIn_SessionChanged(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e)
 {
     if (e.Status == LiveConnectSessionStatus.Connected)
     {
         liveClient = new LiveConnectClient(e.Session);
         LiveOperationResult operationResult = await liveClient.GetAsync("me");
         try
         {
             dynamic meResult = operationResult.Result;
             if (meResult.first_name != null && meResult.last_name != null)
             {
                 infoTextBlock.Text = "Hello " + meResult.first_name + " " + meResult.last_name + "!";
             }
             else
             {
                 infoTextBlock.Text = "Hello, signed-in user!";
             }
         }
         catch (LiveConnectException exception)
         {
             this.infoTextBlock.Text = "Error calling API: " + exception.Message;
         }
     }
     else
     {
         infoTextBlock.Text = "Not signed in.";
     }
 }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            if (this.NavigationContext.QueryString.ContainsKey("path"))
            {
                this.folderPath = NavigationContext.QueryString["path"];
            }
            if (this.NavigationContext.QueryString.ContainsKey("id"))
            {
                this.fileID = NavigationContext.QueryString["id"];
            }
            if (this.NavigationContext.QueryString.ContainsKey("filename"))
            {
                this.filename = this.NavigationContext.QueryString["filename"];
                this.filenameInput.Text = this.filename;
            }

            if (this.fileID != null)
            { // try to get file contents

                this.progressIndicator = new ProgressIndicator();
                this.progressIndicator.IsIndeterminate = true;
                this.progressIndicator.IsVisible = true;
                this.progressIndicator.Text = "Looking for rain...";
                SystemTray.SetProgressIndicator(this, this.progressIndicator);

                LiveConnectClient client = new LiveConnectClient(App.Current.LiveSession);
                client.DownloadCompleted += new EventHandler<LiveDownloadCompletedEventArgs>(OnFileDownloadComplete);
                client.DownloadAsync(this.fileID+"/content");
            }
            else
            {
                this.contentInput.IsEnabled = true;
                this.filenameInput.Focus(); // doesn't work as it is here, maybe because page isn't actually loaded yet?
            }
        }

        /// <summary>
        /// Tests logging into MobileService with Live SDK token. App needs to be assosciated with a WindowsStoreApp
        /// </summary>
        private async Task TestLiveSDKLogin()
        {
            try
            {
                LiveAuthClient liveAuthClient = new LiveAuthClient(GetClient().MobileAppUri.ToString());
                LiveLoginResult result = await liveAuthClient.InitializeAsync(new string[] { "wl.basic", "wl.offline_access", "wl.signin" });
                if (result.Status != LiveConnectSessionStatus.Connected)
                {
                    result = await liveAuthClient.LoginAsync(new string[] { "wl.basic", "wl.offline_access", "wl.signin" });
                }
                if (result.Status == LiveConnectSessionStatus.Connected)
                {
                    LiveConnectSession session = result.Session;
                    LiveConnectClient client = new LiveConnectClient(result.Session);
                    LiveOperationResult meResult = await client.GetAsync("me");
                    MobileServiceUser loginResult = await GetClient().LoginWithMicrosoftAccountAsync(result.Session.AuthenticationToken);

                    Log(string.Format("{0} is now logged into MobileService with userId - {1}", meResult.Result["first_name"], loginResult.UserId));
                }
            }
            catch (Exception exception)
            {
                Log(string.Format("ExceptionType: {0} Message: {1} StackTrace: {2}",
                                                exception.GetType().ToString(),
                                                exception.Message,
                                                exception.StackTrace));
                Assert.Fail("Log in with Live SDK failed");
            }
        }

 private async Task<LiveConnectClient> ensureConnection()
 {
     if (connection != null)
     {
         return connection;
     }
     // Initialize access to the Live Connect SDK.
     LiveAuthClient LCAuth = new LiveAuthClient("https://chivalry.azure-mobile.net/");
     LiveLoginResult LCLoginResult = await LCAuth.InitializeAsync();
     // Sign in to the user's Microsoft account with the required scope.
     //    
     //  This call will display the Microsoft account sign-in screen if the user 
     //  is not already signed in to their Microsoft account through Windows 8.
     // 
     //  This call will also display the consent dialog, if the user has 
     //  has not already given consent to this app to access the data described 
     //  by the scope.
     // 
     LiveLoginResult loginResult = await LCAuth.LoginAsync(new string[] { "wl.basic", "wl.emails" });
     if (loginResult.Status == LiveConnectSessionStatus.Connected)
     {
         // Create a client session to get the profile data.
         connection = new LiveConnectClient(LCAuth.Session);
         mobileServiceUser = await App.MobileService.LoginAsync(loginResult.Session.AuthenticationToken);
         return connection;
     }
     if (LoginFailed != null)
     {
         LoginFailed(this, null);
     }
     return null;
 }

        public async Task Authenticate(LiveConnectSessionChangedEventArgs e)
        {
            if (e.Status == LiveConnectSessionStatus.Connected)
            {
                CurrentLoginStatus = "Connected to Microsoft Services";
                liveConnectClient = new LiveConnectClient(e.Session);
                microsoftAccountLoggedInUser = await liveConnectClient.GetAsync("me");

                CurrentLoginStatus = "Getting Microsoft Account Details";
                mobileServiceLoggedInUser =
                    await App.MobileService.LoginWithMicrosoftAccountAsync(e.Session.AuthenticationToken);

                CurrentLoginStatus = string.Format("Welcome {0}!", microsoftAccountLoggedInUser.Result["name"]);
                userName = microsoftAccountLoggedInUser.Result["name"].ToString();

                await Task.Delay(2000); // non-blocking Thread.Sleep for 2000ms (2 seconds)

                CurrentlyLoggedIn = true;
                CurrentLoginStatus = string.Empty;
                // this will then flip the bit that shows the different UI for logged in

                await UpdateUserOnRemoteService(); // and update on the remote service
                await UpdateLeaderBoard(); // do first pass on leaderboard update
            }
            else
            {
                CurrentLoginStatus = "Y U NO LOGIN?";
                CurrentlyLoggedIn = false;
            }

        }

        private async void InitializePage()
        {
            try
            {
                this.authClient = new LiveAuthClient();
                LiveLoginResult loginResult = await this.authClient.InitializeAsync(scopes);
                if (loginResult.Status == LiveConnectSessionStatus.Connected)
                {
                    if (this.authClient.CanLogout)
                    {
                        this.btnLogin.Content = "Sign Out";
                    }
                    else
                    {
                        this.btnLogin.Visibility = Visibility.Collapsed;
                    }

                    this.liveClient = new LiveConnectClient(loginResult.Session);
                    this.GetMe();
                }
            }
            catch (LiveAuthException authExp)
            {
                this.tbResponse.Text = authExp.ToString();
            }
        }

        private void OnSessionChanged(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e)
        {
            if (e.Error == null)
            {
                if (e.Status == LiveConnectSessionStatus.Connected)
                {

                    this.liveClient = new LiveConnectClient(e.Session);

                    this.GetMe();

                    /*var client = new LiveConnectClient(e.Session);
                    client.GetCompleted += (o, args) =>
                    {
                        if (args.Error == null)
                        {
                            MessageBox.Show(Convert.ToString(args.Result["name"]));
                        }
                    };
                    client.GetAsync("me"); */

                }
                else
                {
                    this.liveClient = null; 

                }
            }

        }

 void clientDataFetch_GetCompleted(object sender, LiveOperationCompletedEventArgs e)
 {
     if (e.Error == null)
     {
         List<object> data = (List<object>)e.Result["data"];
         string file_id = "";
         foreach (IDictionary<string, object> content in data)
         {
             if ((string)content["name"] == "BillDB.sdf")
                 file_id = (string)content["id"];
         }
         if (file_id == "")
             MessageBox.Show("No database file found.");
         else
         {
             MessageBox.Show("DB id: " + file_id + ";");
             try
             {
                 LiveConnectClient liveClient = new LiveConnectClient(session);
                 liveClient.GetCompleted += new EventHandler<LiveOperationCompletedEventArgs>(shareLink_completed);
                 liveClient.GetAsync(file_id + "/shared_edit_link");
             }
             catch (LiveConnectException exception)
             {
                 MessageBox.Show("Error getting shared edit link: " + exception.Message);
             }
         }
     }
 }

        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");

            }
        }

        private  async void uploadButton_Click(object sender, RoutedEventArgs e)//上传
        {
            try
            {
                msgText.Text = "亲：正在上传";
                var authClient = new LiveAuthClient();
                var authResult = await authClient.LoginAsync(new string[] { "wl.skydrive", "wl.skydrive_update" });
                if (authResult.Session != null)
                {
                    var liveConnectClient = new LiveConnectClient(authResult.Session);
                    StorageFolder localFolder = ApplicationData.Current.LocalFolder;
                    StorageFile file = await localFolder.GetFileAsync(App.WordBookFileName);
                    String fileText = await FileIO.ReadTextAsync(file);

                    LiveUploadOperation uploadOperation = await liveConnectClient.CreateBackgroundUploadAsync(
                        "me/skydrive", file.Name, file, OverwriteOption.Overwrite);
                    LiveOperationResult uploadResult = await uploadOperation.StartAsync();

                    if (uploadResult.Result != null)
                    {
                        msgText.Text = "恭喜：您已成功同步生词至OneDrive!";
                    }

                }
            }
            catch (LiveAuthException ex)
            {
                msgText.Text = ex.Message;
            }
            catch (LiveConnectException ex)
            {
                msgText.Text = ex.Message;
            }

        }

 public async Task<ActionResult> Index()
 {
     // récupération du statut de la connection de l'utilisateur
     var loginResult = await AuthClient.InitializeWebSessionAsync(this.HttpContext);
     // si l'utilisateur est connecté
     if (loginResult != null && loginResult.Status == LiveConnectSessionStatus.Connected)
     {
         // Récupération et affichage des informations de l'utilisateur
         var userData = new UserDataModel();
         LiveConnectClient client = new LiveConnectClient(this.AuthClient.Session);
         LiveOperationResult meResult = await client.GetAsync("me");
         if (meResult != null)
         {
             dynamic meInfo = meResult.Result;
             userData.LastName = meInfo.last_name;
             userData.FirstName = meInfo.first_name;
         }
         return View("LoggedIn", userData);
     }
     else
     {
         // l'utilisateur n'est pas connecté, génération de l'URL de connection
         var options = new Dictionary<string, string>();
         options["state"] = REDIRECT_URL;
         string loginUrl = this.AuthClient.GetLoginUrl(new string[] { "wl.signin" }, REDIRECT_URL, options);
         ViewBag.loginUrl = loginUrl;
         return View("LoggedOut");
     }
 }

        async void skydriveList_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            SkyDriveListItem item = this.skydriveList.SelectedItem as SkyDriveListItem;
            if (item == null)
                return;

            try
            {
                LiveConnectClient client = new LiveConnectClient(this.session);
                if (item.Type == SkyDriveItemType.Folder)
                {
                    if (this.session != null)
                    {
                        this.skydriveList.ItemsSource = null;
                        this.currentFolderBox.Text = item.Name;
                        LiveOperationResult result = await client.GetAsync(item.SkyDriveID + "/files");
                        this.client_GetCompleted(result);
                    }
                }
                else if (item.Type == SkyDriveItemType.Savestate || item.Type == SkyDriveItemType.SRAM)
                {
                    if (item.Type == SkyDriveItemType.Savestate)
                    {
                        string slot = item.Name.Substring(item.Name.Length - 5, 1);
                        int parsedSlot = 0;
                        if (!int.TryParse(slot, out parsedSlot))
                        {
                            MessageBox.Show(AppResources.ImportSavestateInvalidFormat, AppResources.ErrorCaption, MessageBoxButton.OK);
                            return;
                        }
                    }
                    // Download
                    if (!item.Downloading)
                    {
                        try
                        {
                            item.Downloading = true;
                            await this.DownloadFile(item, client);
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show(String.Format(AppResources.DownloadErrorText, item.Name, ex.Message), AppResources.ErrorCaption, MessageBoxButton.OK);
                        }
                    }
                    else
                    {
                        MessageBox.Show(AppResources.AlreadyDownloadingText, AppResources.ErrorCaption, MessageBoxButton.OK);
                    }
                }
                this.statusLabel.Height = 0;
            }
            catch (LiveConnectException)
            {
                this.statusLabel.Height = this.labelHeight;
                this.statusLabel.Text = AppResources.SkyDriveInternetLost;
            }
        }

        /// <summary>
        /// Lädt informationen wie Namen über den Windows Live User.
        /// </summary>
        /// <param name="userId">id des Users.</param>
        /// <returns>Der neu erstellte User.</returns>
        internal async static Task<Person> GetNewUserData(string userId, string notificationChannel, int score, DateTime accountCreatedDate)
        {
            LiveConnectClient client = new LiveConnectClient(session);

            var data = (await client.GetAsync("me")).Result;

            return new Person(0, userId, (string)data["id"], (string)data["last_name"], (string)data["first_name"],
                    notificationChannel, System.Globalization.CultureInfo.CurrentCulture.ToString(), score, App.VersionNumber, accountCreatedDate);

        }