Poursuivre l’activité utilisateur, même sur différents appareils

Cette rubrique explique comment aider les utilisateurs à reprendre ce qu’ils faisaient dans votre application sur leur PC et sur plusieurs appareils.

Notes

À compter de juillet 2021, les utilisateurs dont l’historique des activités est synchronisé sur leurs appareils Windows par le biais de leur compte Microsoft (MSA) n’auront plus la possibilité de charger une nouvelle activité dans Chronologie. Ils pourront toujours utiliser Chronologie et voir l’historique de leurs activités (informations sur les applications récentes, les sites web et les fichiers) sur leur PC local. Les comptes connectés à AAD ne seront pas affectés.

Activités utilisateur et chronologie

Notre temps quotidien est réparti sur plusieurs appareils. Nous pouvons utiliser notre téléphone dans le bus, un PC pendant la journée, puis un téléphone ou une tablette le soir. À partir de Windows 10 build 1803 ou ultérieure, la création d’une activité utilisateur permet d’afficher cette activité dans la chronologie Windows et dans la fonctionnalité Pick up where I left off de Cortana. Chronologie est un affichage complet des tâches qui tire parti des activités utilisateur pour afficher une vue chronologique de ce sur quoi vous avez travaillé. Il peut également inclure ce sur quoi vous travailliez sur plusieurs appareils.

Image de chronologie Windows

De même, la liaison de votre téléphone à votre PC Windows vous permet de continuer ce que vous faisiez précédemment sur votre appareil iOS ou Android.

Considérez un UserActivity comme un élément spécifique sur lequel l’utilisateur travaillait dans votre application. Par exemple, si vous utilisez un lecteur RSS, un UserActivity peut être le flux que vous lisez. Si vous jouez à un jeu, userActivity peut être le niveau auquel vous jouez. Si vous écoutez une application de musique, UserActivity peut être la playlist que vous écoutez. Si vous travaillez sur un document, UserActivity peut être là où vous l’avez arrêté, et ainsi de suite. En bref, un UserActivity représente une destination au sein de votre application, ce qui permet à l’utilisateur de reprendre ce qu’il faisait.

Lorsque vous vous engagez avec un UserActivity en appelant UserActivity.CreateSession, le système crée un enregistrement d’historique indiquant l’heure de début et de fin de cet UserActivity. Lorsque vous vous réengagerz avec cette UserActivity au fil du temps, plusieurs enregistrements d’historique sont enregistrés pour celle-ci.

Ajouter des activités utilisateur à votre application

Un UserActivity est l’unité d’engagement de l’utilisateur dans Windows. Il comporte trois parties : un URI utilisé pour activer l’application à laquelle appartient l’activité, des visuels et des métadonnées qui décrivent l’activité.

  1. ActivationUri est utilisé pour reprendre l’application avec un contexte spécifique. En règle générale, ce lien prend la forme d’un gestionnaire de protocole pour un schéma (par exemple, « my-app://page2?action=edit ») ou d’un AppUriHandler (par exemple, http://contoso.com/page2?action=edit).
  2. VisualElements expose une classe qui permet à l’utilisateur d’identifier visuellement une activité avec un titre, une description ou des éléments de carte adaptative.
  3. Enfin, le contenu est l’endroit où vous pouvez stocker les métadonnées de l’activité qui peuvent être utilisées pour regrouper et récupérer des activités dans un contexte spécifique. Souvent, cela prend la forme de https://schema.org données.

Pour ajouter un UserActivity à votre application :

  1. Générer des objets UserActivity lorsque le contexte de votre utilisateur change dans l’application (par exemple, navigation dans la page, nouveau niveau de jeu, etc.)
  2. Remplissez les objets UserActivity avec l’ensemble minimal de champs obligatoires : ActivityId, ActivationUri et UserActivity.VisualElements.DisplayText.
  3. Ajoutez un gestionnaire de schéma personnalisé à votre application afin qu’elle puisse être réactivée par un UserActivity.

Un UserActivity peut être intégré à une application avec seulement quelques lignes de code. Par exemple, imaginez ce code dans MainPage.xaml.cs, à l’intérieur de la classe MainPage (remarque : suppose using Windows.ApplicationModel.UserActivities;) :

UserActivitySession _currentActivity;
private async Task GenerateActivityAsync()
{
    // Get the default UserActivityChannel and query it for our UserActivity. If the activity doesn't exist, one is created.
    UserActivityChannel channel = UserActivityChannel.GetDefault();
    UserActivity userActivity = await channel.GetOrCreateUserActivityAsync("MainPage");
 
    // Populate required properties
    userActivity.VisualElements.DisplayText = "Hello Activities";
    userActivity.ActivationUri = new Uri("my-app://page2?action=edit");
     
    //Save
    await userActivity.SaveAsync(); //save the new metadata
 
    // Dispose of any current UserActivitySession, and create a new one.
    _currentActivity?.Dispose();
    _currentActivity = userActivity.CreateSession();
}

La première ligne de la GenerateActivityAsync() méthode ci-dessus obtient le UserActivityChannel d’un utilisateur. Il s’agit du flux dans lequel les activités de cette application seront publiées. La ligne suivante interroge le canal d’une activité appelée MainPage.

  • Votre application doit nommer les activités de telle sorte que le même ID soit généré chaque fois que l’utilisateur se trouve à un emplacement particulier dans l’application. Par exemple, si votre application est basée sur une page, utilisez un identificateur pour la page ; si son document est basé, utilisez le nom du document (ou un hachage du nom).
  • S’il existe une activité dans le flux avec le même ID, cette activité est retournée à partir du canal avec UserActivity.State la valeur Publiée). S’il n’y a pas d’activité portant ce nom, et que la nouvelle activité est retournée avec UserActivity.State défini sur Nouveau.
  • Les activités sont limitées à votre application. Vous n’avez pas à vous soucier de l’entrée en collision de votre ID d’activité avec des ID dans d’autres applications.

Après avoir obtenu ou créé UserActivity, spécifiez les deux autres champs obligatoires : UserActivity.VisualElements.DisplayTextet UserActivity.ActivationUri.

Ensuite, enregistrez les métadonnées UserActivity en appelant SaveAsync, puis CreateSession, qui retourne une UserActivitySession. UserActivitySession est l’objet que nous pouvons utiliser pour gérer le moment où l’utilisateur est réellement engagé avec userActivity. Par exemple, nous devons appeler Dispose() sur userActivitySession lorsque l’utilisateur quitte la page. Dans l’exemple ci-dessus, nous appelons Dispose() également on _currentActivity avant d’appeler CreateSession(). Cela est dû au fait que nous avons créé _currentActivity un champ membre de notre page et que nous voulons arrêter toute activité existante avant de commencer la nouvelle (remarque : ? est l’opérateur conditionnel Null qui teste la valeur null avant d’effectuer l’accès aux membres).

Étant donné que, dans ce cas, le ActivationUri est un schéma personnalisé, nous devons également inscrire le protocole dans le manifeste de l’application. Cette opération est effectuée dans le fichier XML Package.appmanifest ou à l’aide du concepteur.

Pour effectuer la modification avec le concepteur, double-cliquez sur le fichier Package.appmanifest dans votre projet pour lancer le concepteur, sélectionnez l’onglet Déclarations et ajoutez une définition de protocole . La seule propriété qui doit être renseignée, pour l’instant, est Name. Il doit correspondre à l’URI que nous avons spécifié ci-dessus, my-app.

Nous devons maintenant écrire du code pour indiquer à l’application ce qu’elle doit faire lorsqu’elle a été activée par un protocole. Nous allons remplacer la OnActivated méthode dans App.xaml.cs pour passer l’URI à la page principale, comme suit :

protected override void OnActivated(IActivatedEventArgs e)
{
    if (e.Kind == ActivationKind.Protocol)
    {
        var uriArgs = e as ProtocolActivatedEventArgs;
        if (uriArgs != null)
        {
            if (uriArgs.Uri.Host == "page2")
            {
                // Navigate to the 2nd page of the  app
            }
        }
    }
    Window.Current.Activate();
}

Ce code détecte si l’application a été activée via un protocole. Si c’est le cas, il cherche à voir ce que l’application doit faire pour reprendre la tâche pour laquelle elle est activée. Étant une application simple, la seule activité que cette application reprend est de vous placer sur la page secondaire lorsque l’application apparaît.

Utiliser des cartes adaptatives pour améliorer l’expérience de chronologie

Les activités utilisateur s’affichent dans Cortana et chronologie. Lorsque des activités s’affichent dans la chronologie, nous les affichons à l’aide de l’infrastructure de carte adaptative . Si vous ne fournissez pas de carte adaptative pour chaque activité, Chronologie crée automatiquement une carte d’activité simple basée sur le nom et l’icône de votre application, le champ titre et le champ de description facultatif. Voici un exemple de charge utile de carte adaptative et la carte qu’elle produit.

Une carte adaptative]

Exemple de chaîne JSON de charge utile de carte adaptative :

{ 
  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json", 
  "type": "AdaptiveCard", 
  "version": "1.0",
  "backgroundImage": "https://winblogs.azureedge.net/win/2017/11/eb5d872c743f8f54b957ff3f5ef3066b.jpg", 
  "body": [ 
    { 
      "type": "Container", 
      "items": [ 
        { 
          "type": "TextBlock", 
          "text": "Windows Blog", 
          "weight": "bolder", 
          "size": "large", 
          "wrap": true, 
          "maxLines": 3 
        }, 
        { 
          "type": "TextBlock", 
          "text": "Training Haiti’s radiologists: St. Louis doctor takes her teaching global", 
          "size": "default", 
          "wrap": true, 
          "maxLines": 3 
        } 
      ] 
    } 
  ]
}

Ajoutez la charge utile cartes adaptatives en tant que chaîne JSON à UserActivity comme suit :

activity.VisualElements.Content = 
Windows.UI.Shell.AdaptiveCardBuilder.CreateAdaptiveCardFromJson(jsonCardText); // where jsonCardText is a JSON string that represents the card

Intégration multiplateforme et service à service

Si votre application s’exécute sur plusieurs plateformes (par exemple sur Android et iOS) ou conserve l’état utilisateur dans le cloud, vous pouvez publier UserActivities via Microsoft Graph. Une fois que votre application ou service est authentifié avec un compte Microsoft, il suffit de deux appels REST simples pour générer des objets Activity et History , en utilisant les mêmes données que celles décrites ci-dessus.

Récapitulatif

Vous pouvez utiliser l’API UserActivity pour faire apparaître votre application dans la chronologie et Cortana.

API clés