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

Questo argomento descrive come aiutare gli utenti a riprendere le operazioni eseguite nell'app nel proprio PC e in tutti i dispositivi.

Nota

A partire da luglio 2021, gli utenti con cronologia attività sincronizzati tra i dispositivi Windows tramite l'account Microsoft (MSA) non avranno più l'opzione di caricare nuove attività nella sequenza temporale. Saranno comunque in grado di usare la sequenza temporale e di visualizzare la cronologia delle attività (informazioni sulle app recenti, siti Web e file) sul pc locale. Gli account connessi AAD non saranno interessati.

Attività utente e sequenza temporale

Il nostro tempo ogni giorno viene distribuito in più dispositivi. Potremmo usare il nostro telefono mentre sul bus, un PC durante il giorno, poi un telefono o tablet alla sera. A partire da Windows 10 Build 1803 o versioni successive, la creazione di un'attività utente rende l'attività visualizzata nella sequenza temporale di Windows e nella selezione di Cortana in cui è stata interrotta la funzionalità. La sequenza temporale è una visualizzazione attività avanzata che sfrutta le attività utente per mostrare una visualizzazione cronologica di ciò che 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 qualcosa di specifico su cui l'utente lavora all'interno dell'app. Ad esempio, se si usa un lettore RSS, un oggetto UserActivity potrebbe essere il feed lettore. Se si sta giocando un gioco, UserActivity potrebbe essere il livello che si sta giocando. Se si ascolta un'app musicale, UserActivity potrebbe essere la playlist a cui si è in ascolto. Se si lavora su un documento, l'oggetto UserActivity potrebbe essere il luogo in cui è stato interrotto il funzionamento e così via. In breve, un oggetto UserActivity rappresenta una destinazione all'interno dell'app in modo che consenta all'utente di riprendere le operazioni eseguite.

Quando si interagisce con un oggetto UserActivity chiamando UserActivity.CreateSession, il sistema crea un record di cronologia che indica l'ora di inizio e fine per l'oggetto UserActivity. Man mano che si interagisce con l'oggetto UserActivity nel 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 che appartiene all'attività, agli oggetti visivi e ai metadati che descrivono l'attività.

  1. L'ActivationUri viene usato per riprendere l'applicazione con un contesto specifico. In genere, questo collegamento assume la forma del gestore del protocollo per uno schema ,ad esempio "my-app://page2?action=edit") o di un AppUriHandler (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 della 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 https://schema.org dati.

Per aggiungere un oggetto UserActivity all'app:

  1. Generare oggetti UserActivity quando il contesto dell'utente cambia all'interno dell'app (ad esempio lo spostamento di pagina, il nuovo livello di gioco e così via)
  2. Popolare gli 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 oggetto UserActivity può essere integrato in un'app con poche righe di codice. Ad esempio, immaginare 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 del GenerateActivityAsync() metodo precedente ottiene UserActivityChannel di un utente. Questo è il feed a 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 posizione specifica nell'app. Ad esempio, se l'app è basata su pagina, usare un identificatore per la pagina; se in base al 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 impostata su Nuovo.
  • Le attività sono con ambito per 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.DisplayTexte UserActivity.ActivationUri.

Salvare quindi i metadati UserActivity chiamando SaveAsync e infine CreateSession, che restituisce un Oggetto UserActivitySession. UserActivitySession è l'oggetto che è possibile usare per gestire quando l'utente è effettivamente impegnato con UserActivity. Ad esempio, è consigliabile chiamare Dispose()UserActivitySession quando l'utente lascia la pagina. Nell'esempio precedente viene anche chiamato Dispose()_currentActivity prima di chiamare CreateSession(). Questo perché è stato creato _currentActivity un campo membro della pagina e si vuole arrestare qualsiasi attività esistente prima di iniziare il nuovo (nota: l'operatore ?condizionale null che verifica per Null prima di eseguire l'accesso membro).

Poiché, in questo caso, l'oggetto 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 un codice per indicare all'app cosa fare quando è stato attivato da un protocollo. Verrà eseguito l'override del OnActivated metodo in App.xaml.cs per passare l'URI alla pagina principale, ad esempio:

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 esegue rileva se l'app è stata attivata tramite un protocollo. Se fosse, sembra che l'app debba eseguire per riprendere l'attività per cui viene attivata. Essendo un'app semplice, l'unica attività ripresa dall'app viene messa nella pagina secondaria quando viene visualizzata l'app.

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 nella sequenza temporale, vengono visualizzate usando il framework della scheda adattiva . Se non si specifica una scheda adattiva per ogni attività, la sequenza temporale creerà automaticamente una scheda attività semplice in base al nome e all'icona dell'applicazione, al campo titolo e al campo descrizione facoltativo. Di seguito è riportato un esempio di payload della scheda adattiva e la scheda che produce.

Scheda adattiva]

Stringa JSON del payload della scheda adattiva di esempio:

{ 
  "$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 all'oggetto UserActivity come illustrato di seguito:

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 esegue 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, è sufficiente usare due semplici chiamate REST per generare oggetti Attività e Cronologia usando gli stessi dati descritti in precedenza.

Riepilogo

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

API chiave