Continuare l'attività dell'utente, anche su dispositivi diversi

Questo argomento descrive come aiutare gli utenti a riprendere le attività che stava eseguendo nell'app sul PC e tra dispositivi.

Nota

A partire da luglio 2021, gli utenti che hanno la cronologia delle attività sincronizzata nei dispositivi Windows tramite il proprio account Microsoft (MSA) non avranno più la possibilità di caricare una nuova attività in Sequenza temporale. Potranno comunque usare Sequenza temporale e visualizzare la cronologia attività (informazioni su app, siti Web e file recenti) nel PC locale. Gli account connessi ad AAD non saranno influenzati.

Attività utente e sequenza temporale

L'ora di ogni giorno viene ripartita tra più dispositivi. È possibile usare il telefono mentre si è sul bus, un PC durante il giorno e quindi un telefono o un tablet la sera. A partire da Windows 10 build 1803 o successiva, la creazione di un'attività utente fa sì che l'attività venga visualizzata nella sequenza temporale di Windows e nella funzionalità Pick up where I left off di Cortana.) La sequenza temporale è una visualizzazione attività ricca che sfrutta le attività utente per mostrare una visualizzazione cronologica degli elementi su cui si è lavorato. Può anche includere ciò su cui si sta lavorando in tutti i dispositivi.

Windows sequenza temporale

Analogamente, il collegamento del telefono al PC Windows consente di continuare a eseguire le operazioni precedenti nel dispositivo iOS o Android.

Si pensi a userActivity come a un elemento specifico su cui l'utente stava lavorando all'interno dell'app. Ad esempio, se si usa un lettore RSS, userActivity potrebbe essere il feed che si sta leggendo. Se si sta riproducendo un gioco, UserActivity potrebbe essere il livello che si sta riproducendo. Se si è in ascolto di un'app musicale, UserActivity potrebbe essere la playlist che si è in ascolto. Se si sta lavorando a un documento, UserActivity potrebbe essere il punto in cui si è lasciato lavorare su di esso e così via. In breve, userActivity rappresenta una destinazione all'interno dell'app in modo che consenta all'utente di riprendere le attività che stava eseguendo.

Quando si interagisce con userActivity chiamando UserActivity.CreateSession, il sistema crea un record di cronologia che indica l'ora di inizio e di fine per tale UserActivity. Quando si interagisce di nuovo con tale UserActivity nel tempo, vengono registrati più record della cronologia.

Aggiungere attività utente all'app

UserActivity è l'unità di engagement degli utenti in Windows. È formato da tre parti: un URI usato per attivare l'app a cui appartiene l'attività, oggetti visivi e metadati che descrivono l'attività.

  1. ActivationUri viene usato per riprendere l'applicazione con un contesto specifico. In genere, questo collegamento assume la forma di gestore di protocollo per uno schema (ad esempio, "my-app://page2?action=edit") o di un AppUriHandler (ad esempio, http://constoso.com/page2?action=edit) .
  2. VisualElements espone una classe che consente all'utente di identificare visivamente un'attività con un titolo, una descrizione o elementi scheda adattiva.
  3. Il contenuto è infine il punto in cui è possibile archiviare i metadati per l'attività che possono essere usati per raggruppare e recuperare le attività in un contesto specifico. Spesso questa operazione assume la forma di https://schema.org dati.

Per aggiungere un oggetto UserActivity all'app:

  1. Genera oggetti UserActivity quando il contesto dell'utente cambia all'interno dell'app (ad esempio spostamento tra le pagine, nuovo livello di gioco e così via)
  2. Popolare gli oggetti UserActivity con il set minimo di campi obbligatori: ActivityId, ActivationUrie UserActivity.VisualElements.DisplayText.
  3. Aggiungere un gestore di schema personalizzato all'app in modo che possa essere riattivato da userActivity.

UserActivity può essere integrato in un'app con poche righe di codice. Si immagini, ad esempio, questo codice in MainPage.xaml.cs, all'interno della classe MainPage (nota: presuppone 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 prima riga nel metodo GenerateActivityAsync() precedente ottiene l'oggetto UserActivityChannel di un utente. Si tratta del feed in cui verranno pubblicate le attività dell'app. La riga successiva esegue una query sul canale di un'attività denominata MainPage .

  • L'app deve assegnare un nome alle attività in modo che lo stesso ID sia generato ogni volta che l'utente si trova in una posizione specifica nell'app. Ad esempio, se l'app è basata su pagina, usare un identificatore per la pagina. Se il documento è basato sul documento, usare il nome del documento (o un hash del nome).
  • Se nel feed è presente un'attività con lo stesso ID, tale attività verrà restituita dal canale con UserActivity.State impostato su Published. Se non è presente alcuna attività con tale nome, viene restituita una nuova attività con UserActivity.State impostato su New.
  • L'ambito delle attività è l'app. Non è necessario preoccuparsi dell'ID attività in conflitto con gli ID in altre app.

Dopo aver creato o creato UserActivity, specificare gli altri due campi obbligatori: UserActivity.VisualElements.DisplayText e UserActivity.ActivationUri .

Salvare quindi i metadati UserActivity chiamando SaveAsynce infine CreateSession, che restituisce userActivitySession. UserActivitySession è l'oggetto che è possibile usare per gestire quando l'utente è effettivamente coinvolto in UserActivity. Ad esempio, è necessario chiamare Dispose() su UserActivitySession quando l'utente lascia la pagina. Nell'esempio precedente viene chiamato anche Dispose() su prima di chiamare _currentActivity CreateSession() . Questo perché è stato creato un campo membro della pagina e si vuole arrestare qualsiasi attività esistente prima di avviare quella nuova (si noti che è l'operatore condizionale Null che verifica la null prima di eseguire l'accesso ai _currentActivity ? membri).

Poiché, in questo caso, ActivationUri è uno schema personalizzato, è necessario registrare anche il protocollo nel manifesto dell'applicazione. Questa operazione viene eseguita nel file XML Package.appmanifest o tramite la finestra di progettazione.

Per apportare la modifica con la finestra di progettazione, fare doppio clic sul file Package.appmanifest nel progetto per avviare la finestra di progettazione, selezionare la scheda Dichiarazioni e aggiungere una definizione di protocollo. L'unica proprietà che deve essere compilata, per il momento, è Name. Deve corrispondere all'URI specificato in precedenza, my-app .

A questo punto è necessario scrivere codice per indicare all'app cosa fare quando viene attivata da un protocollo. Si eseguirà l'override del metodo OnActivated in App.xaml.cs per passare l'URI alla pagina principale, come illustrato di seguito:

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

Questo codice rileva se l'app è stata attivata tramite un protocollo. In caso contrario, l'app cerca di vedere cosa deve fare l'app per riprendere l'attività per cui viene attivata. Essendo un'app semplice, l'unica attività ripresa da questa app è l'inserimento nella pagina secondaria quando l'app viene visualizzata.

Usare Schede adattive per migliorare l'esperienza della sequenza temporale

Le attività utente vengono visualizzate in Cortana e Sequenza temporale. Quando le attività vengono visualizzate in Sequenza temporale, vengono visualizzate usando il framework delle schede adattive. Se non si specifica una scheda adattiva per ogni attività, Sequenza temporale creerà automaticamente una scheda attività semplice in base al nome e all'icona dell'applicazione, al campo del titolo e al campo di descrizione facoltativo. Di seguito è riportato un esempio di payload della scheda adattiva e della scheda che produce.

Una scheda adattiva]

Esempio di stringa JSON del payload della scheda adattiva:

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

Aggiungere il payload Schede adattive come stringa JSON a UserActivity nel modo seguente:

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

Integrazione multipiattaforma e da servizio a servizio

Se l'app viene eseguita su più piattaforme (ad esempio in Android e iOS) o mantiene lo stato utente nel cloud, è possibile pubblicare UserActivities tramite Microsoft Graph. Dopo l'autenticazione dell'applicazione o del servizio con un account Microsoft, sono bastate due semplici chiamate REST per generare oggetti Attività e Cronologia, usando gli stessi dati descritti in precedenza.

Riepilogo

È possibile usare l'API UserActivity per visualizzare l'app in Sequenza temporale e Cortana.

API principali