Benutzeraktivitäten auch auf allen Geräten fortsetzen

In diesem Thema wird beschrieben, wie Sie Benutzern dabei helfen können, ihre Aktivitäten in Ihrer App auf ihrem PC und auf allen Geräten fortzusetzen.

Benutzeraktivitäten und Zeitachse

Unsere Zeit täglich verteilt sich auf mehrere Geräte. Wir könnten unser Handy im Bus, tagsüber einen PC und abends ein Handy oder Tablet verwenden. Ab Windows 10 Build 1803 wird das Erstellen einer -Benutzeraktivität so angezeigt, dass diese Aktivität in der Windows-Zeitachse und in Cortanas „Da weitermachen, wo ich aufgehört habe“-Funktion erscheint. Die Zeitachse ist eine umfangreiche Aufgabenansicht, die Benutzeraktivitäten nutzt, um eine chronologische Ansicht dessen zu zeigen, woran Sie gearbeitet haben. Es kann auch umfassen, an dem Sie auf verschiedenen Geräten gearbeitet haben.

Ebenso ermöglicht es das Verknüpfen Ihres Smartphones mit Ihrem Windows-PC, das fortzusetzen, was Sie zuvor auf Ihrem iOS- oder Android-Gerät gemacht haben.

Stellen Sie sich eine UserActivity- als etwas Spezifisches vor, an dem der Benutzer in Ihrer App gearbeitet hat. Wenn Sie beispielsweise einen RSS-Reader verwenden, könnte eine Benutzeraktivität der Feed sein, den Sie lesen. Wenn Sie ein Spiel spielen, könnte die UserActivity das Level sein, das Sie spielen. Wenn Sie eine Musik-App verwenden, könnte die UserActivity- die Wiedergabeliste sein, die Sie sich anhören. Wenn Sie an einem Dokument arbeiten, könnte das UserActivity- an der Stelle sein, wo Sie aufgehört haben zu arbeiten, und so weiter. Kurz gesagt stellt ein UserActivity- ein Ziel in Ihrer App dar, sodass der Benutzer seine Aktivitäten fortsetzen kann.

Wenn Sie mit einer UserActivity interagieren, indem Sie UserActivity.CreateSessionausführen, erstellt das System einen Verlaufsdatensatz, der die Start- und Endzeit für diese UserActivityangibt. Wenn Sie im Laufe der Zeit erneut mit diesem UserActivity- interagieren, werden mehrere Verlaufseinträge dafür aufgezeichnet.

Hinzufügen von Benutzeraktivitäten zu Ihrer App

Ein UserActivity ist die Einheit des Nutzerengagements in Windows. Sie besteht aus drei Teilen: einem URI, der zum Aktivieren der App verwendet wird, zu der die Aktivität gehört, visuellen Elementen und Metadaten, die die Aktivität beschreiben.

1. Die ActivationUri wird verwendet, um die Anwendung mit einem bestimmten Kontext fortzusetzen. In der Regel verwendet dieser Link die Form des Protokollhandlers für ein Schema (z. B. "my-app://page2?action=edit") oder eines AppUriHandlers (z. B. http://contoso.com/page2?action=edit).
2. VisualElements stellt eine Klasse bereit, mit der der Benutzer eine Aktivität visuell anhand eines Titels, einer Beschreibung oder adaptiven Kartenelementen identifizieren kann.
3. Schließlich können Sie im Bereich Inhalt Metadaten für die Aktivität speichern, die zum Gruppieren und Abrufen von Aktivitäten unter einem bestimmten Kontext verwendet werden können. Häufig tritt dies in der Form von den https://schema.org-Daten auf.

So fügen Sie Ihrer App eine UserActivity hinzu:

1. Generieren Sie UserActivity- Objekte, wenn sich der Kontext des Benutzers innerhalb der App ändert (z. B. Seitennavigation, neue Spielebene usw.)
2. Füllen Sie UserActivity--Objekte mit dem minimalen Satz der erforderlichen Felder auf: ActivityId, ActivationUriund UserActivity.VisualElements.DisplayText.
3. Fügen Sie Ihrer App einen benutzerdefinierten Schemahandler hinzu, damit sie von einer UserActivityerneut aktiviert werden kann.

Ein UserActivity kann mit nur wenigen Codezeilen in eine App integriert werden. Beispielsweise, stellen Sie sich diesen Code in MainPage.xaml.cs, in der MainPage-Klasse vor (Hinweis: setzt voraus, 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();
}

Die erste Zeile der obigen GenerateActivityAsync()-Methode ruft den UserActivityChanneleines Benutzers ab. Dies ist der Feed, in dem die Aktivitäten dieser App veröffentlicht werden. Die nächste Zeile fragt den Kanal einer Aktivität mit dem Namen MainPageab.

• Ihre App sollte Aktivitäten so benennen, dass dieselbe ID jedes Mal generiert wird, wenn sich der Benutzer an einem bestimmten Ort in der App befindet. Wenn Ihre App beispielsweise seitenbasiert ist, verwenden Sie einen Bezeichner für die Seite; wenn sie dokumentenbasiert ist, verwenden Sie den Namen des Dokuments (oder einen Hash des Namens).
• Wenn im Feed eine Aktivität mit derselben ID vorhanden ist, wird diese Aktivität vom Kanal zurückgegeben, wobei UserActivity.State auf Veröffentlichtfestgelegt ist). Wenn keine Aktivität mit diesem Namen vorhanden ist und eine neue Aktivität zurückgegeben wird, dann wird UserActivity.State auf Newfestgelegt.
• Aktivitäten sind auf die Funktionen Ihrer App beschränkt. Sie müssen sich keine Sorgen machen, dass Ihre Aktivitäts-ID mit den IDs in anderen Apps kollidiert.

Nach dem Abrufen oder Erstellen der UserActivity-, geben Sie die beiden anderen erforderlichen Felder an: UserActivity.VisualElements.DisplayTextund UserActivity.ActivationUri.

Speichern Sie als Nächstes die UserActivity--Metadaten, indem Sie SaveAsyncaufrufen, und rufen Sie schließlich CreateSessionauf, die eine UserActivitySessionzurückgibt. Die UserActivitySession- ist das Objekt, mit dem wir verwalten können, wann der Benutzer tatsächlich mit der UserActivity-beschäftigt ist. Beispielsweise sollten wir Dispose() für die UserActivitySession- aufrufen, wenn der Benutzer die Seite verlässt. Im obigen Beispiel rufen wir auch Dispose() für _currentActivity auf, bevor wir CreateSession()aufrufen. Dies liegt daran, dass wir _currentActivity zu einem Mitgliedsfeld unserer Seite gemacht haben und alle vorhandenen Aktivitäten beenden möchten, bevor wir die neue Aktivität starten (Hinweis: ? ist der Null-bedingte Operator, der auf Null testet, bevor der Mitgliedszugriff erfolgt).

Da die ActivationUri in diesem Fall ein benutzerdefiniertes Schema ist, müssen wir das Protokoll auch im Anwendungsmanifest registrieren. Dies erfolgt in der XML-Datei "Package.appmanifest" oder mithilfe des Designers.

Um die Änderung mit dem Designer vorzunehmen, doppelklicken Sie in Ihrem Projekt auf die Datei "Package.appmanifest", um den Designer zu starten, wählen Sie die Registerkarte Deklarationen aus, und fügen Sie eine Protokoll- Definition hinzu. Die einzige Eigenschaft, die jetzt ausgefüllt werden muss, ist Name. Er sollte mit dem oben angegebenen URI übereinstimmen, my-app.

Jetzt müssen wir Code schreiben, um der App mitzuteilen, was zu tun ist, wenn sie von einem Protokoll aktiviert wurde. Wir überschreiben die OnActivated-Methode in App.xaml.cs, um den URI an die Hauptseite weiterzugeben, folgendermaßen:

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();
}

Dieser Code erkennt, ob die App über ein Protokoll aktiviert wurde. Wenn dies der Fall war, wird angezeigt, was die App tun soll, um die Aufgabe fortzusetzen, für die sie aktiviert wird. Als einfache Anwendung ist die einzige Aktion, die diese App ausführt, Sie auf die sekundäre Seite zu bringen, wenn Sie die App öffnen.

Verwenden Sie Adaptive Cards, um das Timeline-Erlebnis zu verbessern

Benutzeraktivitäten werden in Cortana und der Zeitachse angezeigt. Wenn Aktivitäten in der Zeitachse angezeigt werden, zeigen wir sie mithilfe des Adaptive Card Frameworks an. Wenn Sie keine adaptive Karte für jede Aktivität bereitstellen, erstellt die Zeitachse automatisch eine einfache Aktivitätskarte auf Basis Ihres Anwendungsnamens und -symbols sowie des Titelfelds und des optionalen Beschreibungsfelds. Im Folgenden sehen Sie ein Beispiel für eine Nutzlast für Adaptive Karten und die Karte, die sie erzeugt.

]

Beispiel-JSON-Zeichenfolge für adaptive Kartennutzlast:

{ 
  "$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 
        } 
      ] 
    } 
  ]
}

Fügen Sie die Nutzlast adaptiver Karten als JSON-Zeichenfolge zur UserActivity wie folgt hinzu:

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

Plattformübergreifende und Dienst-zu-Dienst-Integration

Wenn Ihre App plattformübergreifend ausgeführt wird (z. B. unter Android und iOS) oder den Benutzerstatus in der Cloud verwaltet, können Sie UserActivities über Microsoft Graph-veröffentlichen. Nachdem Ihre Anwendung oder Ihr Dienst mit einem Microsoft-Konto authentifiziert wurde, werden nur zwei einfache REST-Aufrufe benötigt, um Activity und History-Objekte zu generieren, wobei die gleichen Daten wie oben beschrieben verwendet werden.

Zusammenfassung

Sie können die UserActivity-API verwenden, um Ihre App in der Zeitachse und in Cortana erscheinen zu lassen.

• Erfahren Sie mehr über die UserActivity API
• Sehen Sie sich den Beispielcode an.
• Weitere Details zu komplexeren adaptiven Karten finden Sie unter .
• Veröffentlichen Sie eine UserActivity aus iOS, Android oder Ihrem Webdienst über Microsoft Graph.
• Erfahren Sie mehr über Project Rome auf GitHub.

Wichtige APIs

• UserActivities-Namespace

Zugehörige Themen

• Benutzeraktivitäten (Project Rome Docs)
• Adaptive Karten
• Adaptive Karten-Visualizer, Beispiele
• Umgang mit URI-Aktivierungen
• Die Interaktion mit Ihren Kunden auf jeder Plattform mithilfe des Microsoft Graph-, Aktivitätsfeeds und adaptiver Karten
• Microsoft Graph