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

  • Article

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 l’autobus, un PC pendant la journée, puis un téléphone ou une tablette le soir. À partir de Windows 10 build 1803 ou version ultérieure, la création d’une activité utilisateur fait apparaître cette activité dans la chronologie Windows et dans la fonctionnalité De prise en charge de Cortana là où je l’ai laissée. La chronologie est une vue riche 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 chronologie Windows

De même, le fait de lier 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 une Activité utilisateur 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, l’activité utilisateur peut être là où vous n’avez pas travaillé sur celui-ci, et ainsi de suite. En bref, un UserActivity représente une destination au sein de votre application afin de permettre à l’utilisateur de reprendre ce qu’il faisait.

Lorsque vous utilisez 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 cette UserActivity. Lorsque vous réengagerz avec cet UserActivity au fil du temps, plusieurs enregistrements d’historique sont enregistrés pour celle-ci.

Ajouter des activités utilisateur à votre application

Une userActivity est l’unité d’engagement de l’utilisateur dans Windows. Il comprend 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. L’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 au sein de l’application (par exemple, la navigation sur la page, le nouveau niveau de jeu, etc.)
  2. Renseignez les objets UserActivity avec l’ensemble minimal de champs obligatoires : ActivityId, ActivationUri et UserActivity.VisualElements.DisplayText.
  3. Ajoutez un gestionnaire de schémas personnalisé à votre application afin qu’elle puisse être réactivée par un UserActivity.

Une userActivity peut être intégrée à 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é existante 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 si la nouvelle activité est retournée avec UserActivity.State la valeur Nouveau.
  • Les activités sont limitées à votre application. Vous n’avez pas besoin de vous soucier de votre ID d’activité qui entre en collision 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 l’objet UserActivity. Par exemple, nous devons appeler Dispose() sur userActivitySession lorsque l’utilisateur quitte la page. Dans l’exemple ci-dessus, nous appelons Dispose() également sur _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 null avant d’effectuer l’accès membre).

É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. Cela s’effectue 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é à remplir, 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 main, 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 permet de détecter si l’application a été activée via un protocole. Si c’était 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 les activités s’affichent dans la chronologie, nous les affichons à l’aide de l’infrastructure carte adaptative . Si vous ne fournissez pas de carte adaptative pour chaque activité, la chronologie crée automatiquement une activité simple carte en fonction du nom et de l’icône de votre application, du champ titre et du champ de description facultatif. Vous trouverez ci-dessous un exemple de charge utile de carte adaptative et la carte qu’elle produit.

Un carte adaptatif]

Exemple de chaîne JSON adaptative carte charge utile :

{ 
  "$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 des 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ésumé

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

API clés