Windows Dev Center

Langage: HTML | XAML

Exigences en matière de connexion à un compte Microsoft (XAML)

Vos applications Windows Runtime utilisant C++, C# ou Visual Basic peuvent connecter et déconnecter les utilisateurs via leurs comptes Microsoft lorsqu’elles ont besoin d’accéder aux données de ces utilisateurs dans des services de cloud computing Microsoft (comme Outlook.com et Microsoft OneDrive).

Suivez ces recommandations lorsque vous concevez l’expérience de connexion/déconnexion de votre application, afin que cette application fournisse une expérience utilisateur cohérente avec les autres applications Windows Runtime. Ces recommandations vous aideront également à créer une application qui garantit la sécurité des données de l’utilisateur.

Important  Le didacticiel de cette rubrique porte sur une application du Windows Store. Vous pouvez également ajouter des services Microsoft à une application du Windows Phone Store. Toutefois, l’interface utilisateur de l’appareil Windows Phone ne prenant pas en charge les menus volants, vous devez utiliser des pages dans une application du Windows Phone Store pour implémenter les fonctionnalités pour lesquelles les menus volants sont utilisés dans cette rubrique.

Vue d’ensemble

L’accès aux données utilisateur stockées dans des services cloud Microsoft comme Outlook.com et OneDrive n’est possible que si les utilisateurs se sont connectés à votre application avec leur compte Microsoft et qu’ils ont donné leur consentement pour que l’application accède aux données requises. Pour aider les utilisateurs qui partagent un même ordinateur à sécuriser leurs données personnelles, votre application du Windows Store doit permettre à chaque utilisateur de se déconnecter de l’application. Cette rubrique explique comment procéder.

Important  Si votre application n’offre pas aux utilisateurs la possibilité de se déconnecter, elle a accès aux données utilisateur dès lors que les utilisateurs ouvrent l’application en utilisant le compte d’utilisateur avec lequel ils se sont initialement connectés. Ce type d’accès est pratique pour les utilisateurs qui ne partagent jamais leur ordinateur, ou pour ceux qui ne risquent pas de le perdre, mais il peut mettre en danger la sécurité des données utilisateur si l’ordinateur est utilisé par une autre personne ou s’il est volé. Pour ces raisons, votre application du Windows Store doit toujours indiquer à l’utilisateur s’il est ou non connecté avec son compte et fournir à cet utilisateur la possibilité de se déconnecter.

Ces étapes décrivent dans le détail de quelle façon votre application peut accéder aux informations sur le profil de l’utilisateur. Pour obtenir des instructions détaillées, commencez ici.

  1. Ajouter des commandes de paramètres à votre application

    Ajoutez ces deux entrées dans le volet Paramètres de l’application.

    • Compte

      La commande Compte du volet Paramètres affiche le menu volant qui permet aux utilisateurs de se connecter et se déconnecter de leur compte Microsoft.

    • Déclaration de confidentialité

      La commande Confidentialité du volet Paramètres affiche le menu volant qui comporte la déclaration de confidentialité de votre application.

  2. Fournir une déclaration de confidentialité

    Pour en savoir plus, consultez la section Politiques du Windows Store et du Windows Phone Store.

  3. Connecter l’utilisateur

    Votre application peut connecter l’utilisateur automatiquement au démarrage, ou autoriser l’utilisateur à se connecter seulement lorsqu’elle a besoin d’accéder à des données stockées dans des services cloud Microsoft comme Outlook.com Hotmail et OneDrive. La procédure pour chaque méthode est décrite plus loin dans la section Connexion des utilisateurs.

  4. Déconnecter l’utilisateur

    Réfléchissez à la façon dont votre application sera utilisée. Si l’application est censée accéder à des données jugées sensibles par l’utilisateur, elle doit automatiquement déconnecter l’utilisateur pour empêcher tout accès non autorisé. En revanche, si l’application est conçue pour un usage dans un environnement plus sécurisé, vous pouvez laisser le choix à l’utilisateur de se déconnecter manuellement à l’aide de la commande de paramètres Compte. La procédure pour chaque méthode est décrite plus loin dans la section Déconnexion des utilisateurs.

    Important  

    Les utilisateurs doivent toujours être en mesure de savoir s’ils sont ou non connectés à l’application avec leur compte Microsoft.

  5. Afficher l’état de connexion dans l’interface utilisateur de l’application

    Dans l’interface utilisateur de votre application, ajoutez un type d’indication qui avertit les utilisateurs qu’ils sont connectés et que leurs données peuvent être utilisées par l’application.

    Remarque  Il est important que les utilisateurs puissent déterminer s’ils sont ou non connectés à votre application. Il suffit pour cela d’afficher leur nom ou de répertorier les éléments qui sont issus des données stockées dans leur service cloud Microsoft. Par exemple, si votre application affiche des photos que les utilisateurs ont stockées sur OneDrive, elle peut afficher une liste de ces photos lorsque les utilisateurs sont connectés, ou un message invitant les utilisateurs à se connecter s’ils ne le sont pas encore.

Ajouter les paramètres requis

Cette section explique comment ajouter les commandes des paramètres requis dans le volet Paramètres.

  1. Créez le menu volant Confidentialité.

    1. Dans Microsoft Visual Studio, dans l’Explorateur de solutions, cliquez avec le bouton droit sur l’application, puis sélectionnez la commande Ajouter > Nouvel élément... pour ajouter un nouveau contrôle SettingsFlyout.
    2. Dans le navigateur Ajouter un nouvel élément, sélectionnez Installé > Visual C# > Windows Store pour afficher les éléments disponibles.
    3. Sélectionnez Paramètres du menu volant dans la liste, entrez Privacy.xaml dans le champ Nom, puis cliquez sur Ajouter.
    4. Ouvrez le fichier Privacy.xaml, remplacez l’élément TextbBlock.Text par celui-ci, puis modifiez les éléments spécifiés en fonction de votre application.
      
      <!-- Replace the app class name in x:Class and xmlns:local    -->
      <!--   with the class name of your app                        -->
      
      <SettingsFlyout
          x:Class="App.Privacy"
          xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
          xmlns:local="using:App"
          xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
          xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
          mc:Ignorable="d"
          IconSource="Assets/SmallLogo.png"
          Title="Privacy"
          d:DesignWidth="346">
      
          <!-- This StackPanel acts as a root panel for vertical layout of the content sections -->
          <StackPanel VerticalAlignment="Stretch" HorizontalAlignment="Stretch" >
      
              <!-- The StackPanel(s) below define individual content sections -->
      
              <!-- Content Section 1-->
              <StackPanel Style="{StaticResource SettingsFlyoutSectionStyle}">
                  <!-- Section 1 header -->
                  <TextBlock Style="{StaticResource TitleTextBlockStyle}" Text="Privacy statement" />
                  <!-- Section 1 body -->
                  <TextBlock Style="{StaticResource BodyTextBlockStyle}" Margin="0,0,0,25" TextWrapping="Wrap">
                      <TextBlock.Text>
                          Your privacy statement here.
                      </TextBlock.Text>
                  </TextBlock>
      
              </StackPanel>
              <!-- Define more Content Sections below as necessary -->
          </StackPanel>
      </SettingsFlyout>
      
      
      
    5. Ajoutez la référence d’assembly et le menu volant Confidentialité au volet Paramètres dans le fichier App.xaml.cs de l’application, afin qu’ils soient visibles pour l’utilisateur.
      
      // add the assembly for the Settings flyout
      using Windows.UI.ApplicationSettings;
      using System.Threading.Tasks;
      
      
      
      
      protected override void onWindowCreated(WindowCreatedEventArgs args)
      {
          SettingsPane.GetForCurrentView().CommandsRequested += onCommandsRequested;
      }
      
      void onCommandsRequested(SettingsPane settingsPane, SettingsPaneCommandsRequestedEventArgs e)
      {
          SettingsCommand privacyCommand = new SettingsCommand("privacy", "Privacy", (handler) =>
          {
              Privacy privacyFlyout = new Privacy();
              privacyFlyout.Show();
          });
          e.Request.ApplicationCommands.Add(privacyCommand);
      }
      
      
    Remarque  Vous pouvez maintenant générer votre application pour vérifier que tout fonctionne correctement.
  2. Créez le menu volant Account avec un bouton de connexion.

    Le code de cette étape définit la disposition du menu volant Compte présenté dans la capture d’écran ci-dessous.

    Capture d’écran du menu volant Compte créé lors de cette étape.
    1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur l’application, puis utilisez la commande Ajouter > Nouvel élément pour ajouter un nouveau menu volant SettingsFlyout.
    2. Dans le navigateur Ajouter un nouvel élément, sélectionnez Installé > Visual C# > Windows Store pour afficher les éléments disponibles.
    3. Sélectionnez Contrôle volant de paramètres dans la liste, entrez Account.xaml dans le champ Nom, puis cliquez sur Ajouter.
    4. Ouvrez Account.xaml, remplacez l’élément SettingsFlyout par celui-ci, puis modifiez les éléments spécifiés en fonction de votre application.
      
      <!-- Replace the app class name in x:Class and xmlns:local    -->
      <!--   with the class name of your app                        -->
      <SettingsFlyout
          x:Class="App.Account"
          xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
          xmlns:local="using:App"
          xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
          xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
          mc:Ignorable="d"
          IconSource="Assets/SmallLogo.png"
          Title="Account"
          d:DesignWidth="346">
      
              <!-- Content Section 1-->
          <StackPanel x:Name="accountName">
              <TextBlock Name="userName" Style="{StaticResource BodyTextBlockStyle}" TextWrapping="Wrap" 
                  Margin="0,0,0,25" Text="You're not signed in."/>
              <!-- both buttons are defined to occupy the same place in the UI -->
              <!-- however only one is visible at a time, to prevent flicker or confusion -->
              <!-- they are defined as Collapsed so neither is visibly by default -->
              <Button x:Name="signInBtn" Click="SignInClick" Content="Sign in" Visibility="Collapsed"/>
              <Button x:Name="signOutBtn" Click="SignOutClick" Content="Sign out" Visibility="Collapsed"/>
          </StackPanel>
      </SettingsFlyout>
      
      
      
    5. Ajoutez la référence d’assembly et le menu volant Compte au volet Paramètres dans le fichier App.xaml.cs de l’application pour qu’ils soient visibles pour l’utilisateur.

      Remarque  Ajoutez le code suivant à la méthode onCommandsRequested dans App.xaml.cs.
      
      
          SettingsCommand accountCommand = new SettingsCommand("account", "Account", (handler) =>
          {
              Account accountFlyout = new Account();
              accountFlyout.Show();
          });
          e.Request.ApplicationCommands.Add(accountCommand);
      }
      
      
    Remarque  Vous ne pouvez pas générer votre application à ce stade, car vous devez d’abord ajouter les gestionnaires des boutons Connexion et Déconnexion. Cette opération est décrite aux étapes suivantes.
  3. Cette étape décrit comment obtenir les informations sur le profil de l’utilisateur dont vous avez besoin pour remplir les champs de texte et afficher le bouton approprié dans le menu volant Compte.

    Ajoutez les références au Kit de développement logiciel (SDK) Live, puis créez une méthode permettant de récupérer le nom de l’utilisateur de son profil de compte Microsoft et ensuite de l’écrire dans un objet TextBlock de l’interface utilisateur. La méthode doit connecter l’utilisateur, si nécessaire.

    Définissez cette méthode dans le fichier de code principal de l’application (App.xaml.cs, par exemple). De cette manière, toutes les pages de votre application peuvent appeler la méthode requise pour afficher le nom de l’utilisateur (si celui-ci est connecté avec son compte Microsoft) ou pour afficher le message indiquant à l’utilisateur qu’il n’est pas connecté (le cas échéant).

    Cet exemple connecte l’utilisateur avec une wl_basic étendue, qui est la plus petite étendue requise pour accéder aux informations sur le profil de l’utilisateur. Pour protéger les données de l’utilisateur contre tout accès non autorisé, votre application doit demander l’étendue la plus restrictive possible qui permet d’accéder aux données souhaitées.

    Important  Il est important que votre application obtienne l’état de connexion de l’utilisateur directement du SDK Live et qu’elle ne mette pas cette valeur en cache. Cette pratique évite que l’état de connexion de l’utilisateur qui est affiché dans votre application ne corresponde plus à l’état de connexion réel de l’utilisateur qui est géré par le SDK Live.
    
    using Microsoft.Live;
    
    
    
    
    public static async Task updateUserName (TextBlock userName, Boolean signIn)
    {
        try
        {
            // Open Live Connect SDK client.
            LiveAuthClient LCAuth = new LiveAuthClient();
            LiveLoginResult LCLoginResult = await LCAuth.InitializeAsync();
            try
            {
                LiveLoginResult loginResult = null;
                if (signIn)
                {
                    // 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.
                    // 
                    //  Change the parameter of LoginAsync to include the scopes 
                    //   required by your app.
                    loginResult = await LCAuth.LoginAsync(new string[] { "wl.basic" });
                }
                else
                {
                    // If we don't want the user to sign in, continue with the current 
                    //  sign-in state.
                    loginResult = LCLoginResult;
                }
                if (loginResult.Status == LiveConnectSessionStatus.Connected)
                {
                    // Create a client session to get the profile data.
                    LiveConnectClient connect = new LiveConnectClient(LCAuth.Session);
    
                    // Get the profile info of the user.
                    LiveOperationResult operationResult = await connect.GetAsync("me");
                    dynamic result = operationResult.Result;
                    if (result != null)
                    {
                        // Update the text of the object passed in to the method. 
                        userName.Text = string.Join(" ", "Hello", result.name, "!");
                    }
                    else
                    {
                        // Handle the case where the user name was not returned. 
                    }
                }
                else
                {
                    // The user hasn't signed in so display this text 
                    //  in place of his or her name.
                    userName.Text = "You're not signed in.";
                }
            }
            catch (LiveAuthException exception)
            {
                // Handle the exception. 
            }
        }
        catch (LiveAuthException exception)
        {
                // Handle the exception. 
        }
        catch (LiveConnectException exception)
        {
                // Handle the exception. 
        }
    }
    
    
    
    Astuce  Vous pouvez appeler cette méthode à partir du code-behind de vos pages d’affichage afin d’indiquer à l’utilisateur s’il est ou non connecté avec son compte Microsoft.
  4. Ajoutez la logique de connexion et de déconnexion au fichier code-behind Account.xaml.cs.

    1. Ajoutez les références au Kit de développement logiciel (SDK) Live, puis créez une méthode permettant d’obtenir l’état de connexion de l’utilisateur et de mettre à jour l’interface utilisateur du menu volant de manière appropriée.

      
      using Microsoft.Live;
      using System.Threading.Tasks;
      
      
      
      
      private async Task SetNameField(Boolean login) {
          // If login == false, just update the name field. 
          await App.updateUserName(this.userName, login);
      
          // Test to see if the user can sign out.
          Boolean userCanSignOut = true;
      
          LiveAuthClient LCAuth = new LiveAuthClient();
          LiveLoginResult LCLoginResult = await LCAuth.InitializeAsync();
      
          if (LCLoginResult.Status == LiveConnectSessionStatus.Connected)
          {
              userCanSignOut = LCAuth.CanLogout;
          }
          
          if (this.userName.Text.Equals("You're not signed in."))
          {
              // Show sign-in button.
              signInBtn.Visibility = Windows.UI.Xaml.Visibility.Visible;
              signOutBtn.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
          }
          else
          {
              // Show sign-out button if they can sign out.
              signOutBtn.Visibility = (userCanSignOut ? Windows.UI.Xaml.Visibility.Visible : Windows.UI.Xaml.Visibility.Collapsed);
              signInBtn.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
          }
      }
      
      
      
    2. Ajoutez cet appel de méthode au constructeur Account() pour initialiser le menu volant lorsqu’il est ouvert par un utilisateur à partir du volet Paramètres.
      
      SetNameField(false);
       
      
      
    3. Ajoutez le code requis pour gérer l’événement qui est déclenché lorsque l’utilisateur appuie sur le bouton Connexion.

      Cette méthode appelle SetNameField pour connecter l’utilisateur et mettre à jour l’interface utilisateur du menu volant Compte.

      
      private async void SignInClick(object sender, RoutedEventArgs e)
      {
        // This call will sign the user in and update the Account flyout UI.
        await SetNameField(true);
      }
      
      
    4. Ajoutez le code requis pour déconnecter l’utilisateur lorsque celui-ci appuie sur le bouton Déconnexion.

      
      private async void SignOutClick(object sender, RoutedEventArgs e)
      {
          try
          {
              // Initialize access to the Live Connect SDK.
              LiveAuthClient LCAuth = new LiveAuthClient();
              LiveLoginResult LCLoginResult = await LCAuth.InitializeAsync();
              // Sign the user out, if he or she is connected;
              //  if not connected, skip this and just update the UI
              if (LCLoginResult.Status == LiveConnectSessionStatus.Connected)
              {
                  LCAuth.Logout();
              }
      
              // At this point, the user should be disconnected and signed out, so
              //  update the UI.
              this.userName.Text = "You're not signed in.";
      
              // Show sign-in button.
              signInBtn.Visibility = Windows.UI.Xaml.Visibility.Visible;
              signOutBtn.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
          }
          catch (LiveConnectException x)
          {
              // Handle exception.
          }
      }
      
      
      
  5. Générez votre application et testez les SettingsFlyouts que vous venez d’ajouter.

    Les commandes Compte et Confidentialité du volet Paramètres doivent s’afficher, comme illustré dans cette capture d’écran.

    Icône Paramètres montrant les commandes Compte et Confidentialité ajoutées lors de cette étape.
  6. Lorsque l’application est exécutée et que l’utilisateur n’est pas connecté avec son compte Microsoft, cet utilisateur voit s’afficher un menu volant similaire à celui-ci lorsqu’il appuie sur la commande Compte dans le volet Paramètres.

    Capture d’écran montrant l’expérience de connexion de l’utilisateur.

    Si l’utilisateur appuie sur le bouton Connexion, les écrans suivants s’affichent.

    1. L’interface utilisateur de connexion avec un compte Microsoft.

      Capture d’écran de l’interface utilisateur de connexion avec un compte Microsoft.

    2. L’interface utilisateur de consentement Live Connect, si l’utilisateur n’a pas encore donné son consentement pour cette application.

      Capture d’écran de l’interface utilisateur de consentement Live Connect.

    3. Après s’être connecté et avoir donné son consentement, l’utilisateur revient dans l’application.
  7. Si l’utilisateur est déjà connecté avec un compte Microsoft et qu’il a la possibilité de se déconnecter, un menu volant semblable au suivant s’affiche.

    Capture d’écran montrant l’expérience de déconnexion de l’utilisateur lorsque celui-ci peut se déconnecter.

  8. Si l’utilisateur est déjà connecté avec un compte Microsoft, mais qu’il n’a pas la possibilité de se déconnecter, un menu volant semblable au suivant s’affiche.

    Capture d’écran montrant l’expérience de déconnexion de l’utilisateur lorsque celui-ci ne peut pas se déconnecter

  9. Après la connexion de l’utilisateur, l’interface utilisateur de l’application est mise à jour pour afficher le nom de l’utilisateur.

    Capture d’écran de l’application affichant le nom de l’utilisateur.
Remarque  Les exemples de code fournis dans cette étape permettent uniquement de définir les menus volants pour le volet Paramètres. Vous devez ensuite ajouter les balises et le code requis dans les pages d’affichage de votre application pour afficher le nom de l’utilisateur.

Connexion des utilisateurs

Il existe deux approches pour connecter les utilisateurs à votre application du Windows Store. Choisissez l’approche qui convient en fonction du moment où votre application a besoin que l’utilisateur se connecte.

  • Si votre application est opérationnelle lorsque l’utilisateur n’est pas connecté, mais que la connexion de cet utilisateur est nécessaire pour mettre en œuvre certains scénarios ou fonctionnalités, l’application doit demander à l’utilisateur de se connecter par le biais d’une interface utilisateur Compte   dans le volet Paramètres, comme décrit précédemment.

    Pour plus d’informations sur la connexion des utilisateurs, voir Connexion des utilisateurs dans la documentation Live Connect.

  • Si votre application n’est pas opérationnelle ou n’offre pas une expérience complète tant que l’utilisateur n’est pas connecté, elle doit afficher la boîte de dialogue de connexion avec un compte Microsoft immédiatement après son démarrage. Pour afficher cette boîte de dialogue, appelez la méthode Microsoft.Live.LiveAuthClient.LoginAsync.

    Voici un exemple :

    
    public LiveConnectSession Session
    {
         get
         {
             return _session;
         }
         set
         {
             _session = value;
         }
    }
    
    private async void InitAuth()
    {
        if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
        {
           authClient = new LiveAuthClient();
           LiveLoginResult authResult = 
               await authClient.LoginAsync(new List<string>() { "wl.signin", "wl.basic", "wl.skydrive" });
           if (authResult.Status == LiveConnectSessionStatus.Connected)
           {
               this.Session = authResult.Session;
           }
        }
    }
    
    

    Pour plus d’informations, voir Connexion des utilisateurs dans la documentation Live Connect.

  • Si votre application est opérationnelle sans que l’utilisateur soit tenu de se connecter au préalable, mais qu’elle fournit des commandes spécifiques qui s’intègrent à des services cloud Microsoft comme Outlook.com et OneDrive, votre application peut afficher l’interface utilisateur de connexion avec un compte Microsoft pour les commandes concernées. Par exemple, une application de retouche photo peut proposer la commande Enregistrer la photo dans OneDrive dans sa barre de l’application. Pour prendre en charge ce scénario, ajoutez le code de cet exemple de commande de connexion de l’utilisateur avec son compte Microsoft dans le gestionnaire des commandes de la barre de l’application, juste avant le code de la commande d’enregistrement de la photo. (Le code requis pour enregistrer la photo n’est pas inclus dans cet exemple.)

    Voici un exemple qui connecte l’utilisateur à l’aide d’une commande de la barre de l’application.

    
    private void AppBarSaveButton_Click(object sender, RoutedEventArgs e)
    {
        InitAuth();
    }
    
    private async void InitAuth()
    {
        if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
        {
            authClient = new LiveAuthClient();
            LiveLoginResult authResult = 
                await authClient.LoginAsync(new List<string>() { "wl.signin", "wl.basic", "wl.skydrive" });
            if (authResult.Status == LiveConnectSessionStatus.Connected)
            {
                // An app-level property for the session.
                App.Session = authResult.Session;
            }
        }
    }
    
    

    Avec l’authentification unique, les utilisateurs voient s’afficher l’interface utilisateur de connexion ou l’interface utilisateur de consentement uniquement s’ils ont besoin de se connecter ou de donner leur consentement. Si les utilisateurs sont déjà connectés avec leur compte Microsoft et qu’ils ont déjà donné leur consentement pour que l’application accède à leurs données, ils ne voient aucune interface utilisateur supplémentaire s’afficher.

    Important  

    Assurez-vous que les utilisateurs sont en mesure de savoir s’ils sont ou non connectés avec leur compte Microsoft.

Déconnexion des utilisateurs

Dans Windows 8, si une application peut se connecter à des ressources en utilisant le compte Microsoft de l’utilisateur, elle doit offrir à l’utilisateur la possibilité de se déconnecter.

Remarque  Si l’utilisateur se connecte à Windows 8 avec un compte Microsoft ou avec un compte local ou de domaine qui est connecté à un compte Microsoft, le fait de fournir un bouton de déconnexion personnalisé n’a aucun effet.

Pour déconnecter un utilisateur, appelez la méthode Microsoft.Live.LiveAuthClient.Logout().

Choses à éviter

Assurez-vous que votre application :

  • n’affiche pas de texte, de contrôles ou de boîtes de dialogue de connexion et de déconnexion autres que ceux décrits précédemment ici. L’utilisation de l’expérience de connexion avec un compte Microsoft permet de conforter vos utilisateurs dans l’idée que votre application ne peut pas accéder directement à leurs informations d’identification de compte Microsoft ;
  • n’affiche aucun contrôle de connexion ou de déconnexion personnalisé ailleurs que dans le volet Paramètres ou dans le cadre du flux de commandes de tâches de l’application.

 

 

Afficher:
© 2015 Microsoft