Condividi tramite

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

  • Articolo

Questo argomento descrive come aiutare gli utenti a riprendere ciò che stavano facendo nell'app sul PC e attraverso i dispositivi.

Nota

A partire da luglio 2021, gli utenti con cronologia attività sincronizzata tra i dispositivi Windows tramite l'account Microsoft (MSA) non avranno più la possibilità di caricare una nuova attività nella sequenza temporale. Potranno comunque usare Timeline e visualizzare la cronologia delle attività (informazioni sulle app, i siti Web e i file recenti) nel PC locale. Gli account connessi ad AAD non saranno interessati.

Attività utente e sequenza temporale

Il nostro tempo ogni giorno viene distribuito tra più dispositivi. Si potrebbe usare il telefono mentre si è in autobus, un PC durante il giorno, poi un telefono o un tablet la sera. A partire da Windows 10 Build 1803 o versione successiva, la creazione di una User Activity rende l'attività visualizzata nella sequenza temporale di Windows e in Pick up di Cortana dove ho interrotto la funzionalità. Sequenza temporale è una visualizzazione attività avanzata che sfrutta le attività utente per mostrare una visualizzazione cronologica degli elementi su cui si sta lavorando. Può anche includere ciò che si stava lavorando su tutti i dispositivi.

Immagine della sequenza temporale di Windows

Analogamente, il collegamento del telefono al PC Windows consente di continuare ciò che si stava facendo in precedenza sul dispositivo iOS o Android.

Si pensi a UserActivity come a qualcosa di 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 legge. Se si sta giocando a un gioco, UserActivity potrebbe essere il livello che si sta giocando. Se si sta ascoltando un'app musicale, UserActivity potrebbe essere la playlist che si sta ascoltando. Se si lavora su un documento, UserActivity potrebbe essere il percorso in cui è stato interrotto il lavoro e così via. In breve, userActivity rappresenta una destinazione all'interno dell'app in modo che consenta all'utente di riprendere le operazioni eseguite.

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 UserActivity. Quando si interagisce nuovamente con tale UserActivity nel corso del tempo, vengono registrati più record di cronologia.

Aggiungere attività utente all'app

UserActivity è l'unità di coinvolgimento degli utenti in Windows. Include tre parti: un URI usato per attivare l'app a cui appartiene l'attività, gli oggetti visivi e i 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 del protocollo per uno schema (ad esempio, "my-app://page2?action=edit") o di un Gestore AppUri (ad esempio, http://contoso.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. Infine, Content è la posizione in cui è possibile archiviare i metadati per l'attività che può essere usata per raggruppare e recuperare le attività in un contesto specifico. Spesso, questo assume la forma di dati https://schema.org.

Per aggiungere un elemento UserActivity all'app:

  1. Generare oggetti UserActivity quando il contesto dell'utente cambia all'interno dell'app ,ad esempio lo spostamento di pagine, il nuovo livello di gioco e così via.
  2. Compilare oggetti UserActivity con il set minimo di campi obbligatori: ActivityId, ActivationUri e UserActivity.VisualElements.DisplayText.
  3. Aggiungere un gestore di schemi personalizzato all'app in modo che possa essere riattivato da un oggetto UserActivity.

Un elemento UserActivity può essere integrato in un'app con poche righe di codice. Si supponga, ad esempio, che 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 GenerateActivityAsync() metodo precedente ottiene userActivityChannel dell'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 venga generato ogni volta che l'utente si trova in una determinata posizione nell'app. Ad esempio, se l'app è basata su pagina, usa un identificatore per la pagina; se è basata su documento, usare il nome del documento (o un hash del nome).
  • Se nel feed è presente un'attività esistente con lo stesso ID, tale attività verrà restituita dal canale con UserActivity.State impostato su Pubblicato. Se non è presente alcuna attività con tale nome e viene restituita una nuova attività con UserActivity.State impostato su Nuovo.
  • Le attività hanno come ambito l'app. Non è necessario preoccuparsi dell'ID attività in collisione con gli ID in altre app.

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

Salvare quindi i metadati UserActivity chiamando SaveAsync e infine CreateSession che restituisce una UserActivitySession. UserActivitySession è l'oggetto che è possibile usare per gestire quando l'utente è effettivamente impegnato con UserActivity. Ad esempio, è consigliabile chiamare Dispose() in UserActivitySession quando l'utente lascia la pagina. Nell'esempio precedente viene chiamato anche Dispose() su _currentActivity prima di chiamare CreateSession(). Ciò è dovuto al fatto che è stato creato _currentActivity un campo membro della pagina e si vuole arrestare qualsiasi attività esistente prima di avviarne una nuova (si noti che ? è l'operatore condizionale Null che verifica i valori Null prima di eseguire l'accesso ai 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.

È ora necessario scrivere codice per indicare all'app cosa fare quando è stato attivato da un protocollo. Il metodo verrà sottoposto a override 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();
}

Ciò che questo codice rileva se l'app è stata attivata tramite un protocollo. In caso affermativo, sembra vedere cosa deve fare l'app per riprendere l'attività per cui è in corso l'attivazione. Essendo un'app semplice, l'unica attività ripresa da questa app consiste nell'inserirsi nella pagina secondaria quando l'app viene visualizzata.

Usare le schede adattive per migliorare l'esperienza della sequenza temporale

Le attività utente vengono visualizzate in Cortana e nella sequenza temporale. Quando le attività vengono visualizzate nella sequenza temporale, vengono visualizzate usando il framework della scheda adattiva. Se non si specifica una scheda adattiva per ogni attività, Timeline 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.

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 delle schede adattive come stringa JSON a UserActivity come segue:

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 è in esecuzione in multipiattaforma (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 necessarie solo due semplici chiamate REST per generare oggetti Attività e Cronologia, usando gli stessi dati descritti in precedenza.

Riepilogo

Si può usare l'API UserActivity per visualizzare l'app in Sequenza temporale e Cortana.

API chiave