Kontynuuj aktywność użytkownika, nawet na różnych urządzeniach

W tym temacie opisano, jak ułatwić użytkownikom wznowienie działania w aplikacji na komputerze i na różnych urządzeniach.

Działania użytkownika i oś czasu

Nasz czas każdego dnia jest rozłożony na wiele urządzeń. Możemy użyć naszego telefonu w autobusie, komputera w ciągu dnia, a następnie telefonu lub tabletu wieczorem. Począwszy od systemu Windows 10 Build 1803 lub nowszego, utworzenie aktywność użytkownika sprawia, że to działanie jest wyświetlane na Osi czasu w systemie Windows i w funkcji Kontynuuj tam, gdzie przerwałem Cortany. Oś czasu to bogaty widok zadań, który korzysta z działań użytkownika w celu wyświetlenia chronologicznego widoku tego, nad czym pracujesz. Może również zawierać elementy, na których pracujesz na różnych urządzeniach.

Podobnie połączenie telefonu z komputerem z systemem Windows umożliwia kontynuowanie tego, co wcześniej robiłeś na urządzeniu z systemem iOS lub Android.

Pomyśl o UserActivity jako o czymś konkretnym, nad czym użytkownik pracował w aplikacji. Jeśli na przykład używasz czytnika RSS, UserActivity może być kanałem, który czytasz. Jeśli grasz w grę, UserActivity może oznaczać poziom, na którym się znajdujesz. Jeśli słuchasz aplikacji do odtwarzania muzyki, UserActivity może być listą odtwarzania, której słuchasz. Jeśli pracujesz nad dokumentem, UserActivity może być miejscem, w którym skończyłeś pracować nad nim, i tak dalej. Krótko mówiąc, UserActivity reprezentuje miejsce docelowe w aplikacji, aby umożliwić użytkownikowi wznowienie działania.

Po nawiązaniu kontaktu z UserActivity przez wywołanie UserActivity.CreateSessionsystem tworzy rekord historii wskazujący godzinę rozpoczęcia i zakończenia dla tego UserActivity. Gdy ponownie zaangażujesz się w to UserActivity z biegiem czasu, rejestrowanych jest wiele rekordów historii.

Dodawanie działań użytkownika do aplikacji

UserActivity jest jednostką zaangażowania użytkowników w systemie Windows. Zawiera trzy części: identyfikator URI używany do aktywowania aplikacji, do którego należy działanie, wizualizacje i metadane opisujące działanie.

1. ActivationUri służy do wznowienia aplikacji z określonym kontekstem. Zazwyczaj ten link przyjmuje formę procedury obsługi protokołu dla schematu (na przykład "my-app://page2?action=edit") lub programu AppUriHandler (na przykład http://contoso.com/page2?action=edit).
2. VisualElements udostępnia klasę, która umożliwia użytkownikowi wizualne identyfikowanie akcji z tytułem, opisem lub elementami karty adaptacyjnej.
3. Na koniec Treść to miejsce, gdzie można przechowywać metadane dla aktywności, które mogą służyć do grupowania i pobierania działań w określonym kontekście. Często przyjmuje formę danych https://schema.org.

Aby dodać UserActivity do aplikacji:

1. Wygeneruj obiekty UserActivity, gdy kontekst użytkownika zmieni się w aplikacji (na przykład nawigacja na stronie, nowy poziom gry itp.)
2. Uzupełnij obiekty UserActivity minimalnym zestawem wymaganych pól: ActivityId, ActivationUrii UserActivity.VisualElements.DisplayText.
3. Dodaj program obsługi schematu niestandardowego do aplikacji, aby można było go ponownie aktywować za pomocą UserActivity.

UserActivity można zintegrować z aplikacją z pomocą zaledwie kilku linii kodu. Wyobraź sobie ten kod w MainPage.xaml.cs, wewnątrz klasy MainPage (uwaga: zakładając 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();
}

Pierwszy wiersz w metodzie GenerateActivityAsync() powyżej pobiera użytkownikowi UserActivityChannel. Jest to kanał informacyjny, do którego zostaną opublikowane działania tej aplikacji. Następny wiersz wysyła zapytanie do kanału działania o nazwie MainPage.

• Aplikacja powinna nazwać działania w taki sposób, aby ten sam identyfikator był generowany za każdym razem, gdy użytkownik znajduje się w określonej lokalizacji w aplikacji. Jeśli na przykład aplikacja jest oparta na stronach, użyj identyfikatora strony; jeśli jest on oparty na dokumencie, użyj nazwy dokumentu (lub skrótu nazwy).
• Jeśli w kanale informacyjnym istnieje aktywność o tym samym identyfikatorze, to ta aktywność zostanie zwrócona z kanału z ustawieniem UserActivity.State na Opublikowana. Jeśli nie ma aktywności o tej nazwie, nowa aktywność zostaje utworzona z UserActivity.State ustawionym na Nowa.
• Działania są ograniczone do twojej aplikacji. Nie musisz martwić się o identyfikatory aktywności kolidujące z identyfikatorami w innych aplikacjach.

Po uzyskaniu lub utworzeniu UserActivity, określ dwa pozostałe wymagane pola: UserActivity.VisualElements.DisplayTexti UserActivity.ActivationUri.

Następnie zapisz metadane UserActivity, wywołując SaveAsync, a na koniec CreateSession, która zwraca UserActivitySession. UserActivitySession jest obiektem, którego możemy użyć do zarządzania, gdy użytkownik faktycznie jest zaangażowany w UserActivity. Na przykład należy wywołać Dispose() w UserActivitySession, gdy użytkownik opuści stronę. W powyższym przykładzie wywołujemy również Dispose() w _currentActivity przed wywołaniem CreateSession(). Dzieje się tak dlatego, że uczyniliśmy polem członkowskim naszej strony i chcemy zatrzymać wszelkie istniejące działania przed rozpoczęciem nowego (uwaga: to operator warunkowy dla wartości null , który sprawdza wartość null przed wykonaniem dostępu do pola członkowskiego).

Ponieważ w tym przypadku ActivationUri jest schematem niestandardowym, musimy również zarejestrować protokół w manifeście aplikacji. Odbywa się to w pliku XML Package.appmanifest lub przy użyciu projektanta.

Aby wprowadzić zmianę w edytorze, kliknij dwukrotnie plik Package.appmanifest w swoim projekcie, aby uruchomić Edytor, wybierz kartę "Deklaracje" i dodaj definicję protokołu. Jedyną właściwością, która musi być na razie wypełniona, jest Nazwa. Powinien on być zgodny z podanym powyżej identyfikatorem URI, my-app.

Teraz musimy napisać kod, aby poinformować aplikację o tym, co należy zrobić, gdy została aktywowana przez protokół. Zastąpimy metodę OnActivated w App.xaml.cs, aby przekazać identyfikator URI na stronę główną, w następujący sposób:

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

Ten kod wykrywa, czy aplikacja została aktywowana za pośrednictwem protokołu. Jeśli tak było, sprawdza, co aplikacja powinna zrobić, aby wznowić zadanie, dla którego jest aktywowana. Będąc prostą aplikacją, jedynym działaniem wznawianym przez tę aplikację jest umieszczenie Cię na stronie dodatkowej po wyświetleniu aplikacji.

Użyj kart adaptacyjnych, aby poprawić doświadczenie osi czasu

Działania użytkownika są wyświetlane w Cortanie i na osi czasu. Gdy działania pojawiają się na Osi czasu, wyświetlamy je przy użyciu systemu kart adaptacyjnych. Jeśli nie udostępnisz karty adaptacyjnej dla każdego działania, oś czasu automatycznie utworzy prostą kartę działania na podstawie nazwy i ikony aplikacji, pola tytułu i opcjonalnego pola opisu. Poniżej znajduje się przykładowe dane karty adaptacyjnej i wygenerowana przez nie karta.

]

Przykładowy ciąg JSON ładunku karty adaptacyjnej:

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

Dodaj ładunek kart adaptacyjnych jako ciąg JSON do UserActivity w następujący sposób:

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

Integracja międzyplatformowa i między usługami

Jeśli aplikacja uruchamia wiele platform (na przykład w systemach Android i iOS) lub utrzymuje stan użytkownika w chmurze, możesz opublikować funkcje UserActivities za pośrednictwem programu Microsoft Graph. Po uwierzytelnieniu aplikacji lub usługi przy użyciu konta Microsoft wystarczą dwa proste wywołania REST, aby wygenerować obiekty Aktywność i Historia, używając tych samych danych, jak opisano powyżej.

Podsumowanie

Możesz użyć interfejsu API UserActivity, aby Twoja aplikacja pojawiała się na osi czasu i w Cortanie.

• Dowiedz się więcej o API UserActivity
• Zapoznaj się z przykładowym kodem .
• Obejrzyj bardziej zaawansowane karty adaptacyjne .
• Opublikuj UserActivity z systemu iOS, Android lub usługi internetowej za pośrednictwem usługi Microsoft Graph.
• Dowiedz się więcej o Project Rome w witrynie GitHub.

Kluczowe interfejsy API

• przestrzeń nazw UserActivities

Tematy pokrewne

• Działania użytkowników (Dokumentacja projektu Rome)
• karty adaptacyjne
• Wizualizator Kart Adaptacyjnych, przykłady
• Procedura aktywacji URI
• Nawiązywanie interakcji z klientami na dowolnej platformie przy użyciu Microsoft Graph, kanału aktywności i kart adaptacyjnych
• Microsoft Graph