Condividi tramite

Continuare l'attività dell'utente, anche tra dispositivi

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

Annotazioni

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 nuove attività nella Timeline. 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. Potremmo usare il telefono mentre 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 un'attività utente fa visualizzare l'attività nella sequenza temporale di Windows e nella funzionalità Riprendi da dove avevo interrotto di Cortana. Timeline è un'esperienza avanzata delle attività che sfrutta le Attività Utente per mostrare una vista cronologica di ciò su cui hai lavorato. Può anche includere ciò a cui stavi lavorando su diversi dispositivi.

immagine cronologia 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.

Pensate a un UserActivity come a qualcosa di specifico su cui l'utente stava lavorando nell'app. Ad esempio, se stai usando un lettore RSS, un UserActivity potrebbe essere proprio il feed che stai leggendo. Se stai giocando a un gioco, il UserActivity potrebbe essere il livello che stai giocando. Se stai ascoltando un'app musicale, il UserActivity potrebbe essere la playlist che stai ascoltando. Se stai lavorando su un documento, il UserActivity potrebbe essere il punto in cui hai interrotto il lavoro, e così via. In breve, un UserActivity rappresenta una destinazione all'interno dell'app in modo che consenta all'utente di riprendere le operazioni eseguite.

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

Aggiungi le attività degli utenti alla tua applicazione

Un 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. Il ActivationUri viene usato per riprendere l'applicazione con un contesto specifico. In genere, questo collegamento assume la forma di un gestore di 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 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 una UserActivity alla tua app:

  1. Genera oggetti UserActivity quando cambia il contesto dell'utente all'interno dell'app, ad esempio navigazione tra le pagine, nuovi livelli di gioco, e così via.
  2. Inserire nei campi minimi obbligatori degli oggetti UserActivity : ActivityId, ActivationUrie UserActivity.VisualElements.DisplayText.
  3. Aggiungere un gestore di schemi personalizzato all'app in modo che possa essere riattivato da un UserActivity.

Un UserActivity può essere integrato in un'app con poche righe di codice. Immagina, ad esempio, questo codice in MainPage.xaml.cs, all'interno della classe MainPage (nota: suppone 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 metodo GenerateActivityAsync() precedente ottiene l'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 venga generato ogni volta che l'utente si trova in una determinata posizione nell'app. Ad esempio, se l'app è basata su pagine, usa un identificatore per la pagina; se è basata su documenti, usa 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 impostata su Pubblicato). Se non è presente alcuna attività con quel nome, viene restituita una nuova attività con UserActivity.State impostato su Nuovo.
  • Le attività sono limitate all'app. Non è necessario preoccuparsi che l'ID dell'attività entri in conflitto con gli ID di 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 SaveAsynce infine CreateSession, che restituisce un User ActivitySession. Il UserActivitySession è l'oggetto che è possibile usare per gestire il momento in cui l'utente è effettivamente impegnato con l'UserActivity. Ad esempio, dovremmo chiamare Dispose() sulla UserActivitySession quando l'utente lascia la pagina. Nell'esempio precedente, chiamiamo anche Dispose() su _currentActivity prima di chiamare CreateSession(). Ciò è dovuto al fatto che abbiamo reso _currentActivity un campo membro della nostra pagina e vogliamo arrestare qualsiasi attività esistente prima di iniziarne una nuova (nota: ? è l'operatore condizionale null , che verifica la presenza di null prima di eseguire l'accesso ai membri).

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

Per apportare la modifica con il designer, fare doppio clic sul file Package.appmanifest nel progetto per avviare il designer, selezionare la scheda Dichiarazioni e aggiungere una definizione Protocollo . L'unica proprietà che deve essere compilata, per il momento, è Nome. 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. 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();
}

Ciò che questo codice rileva se l'app è stata attivata tramite un protocollo. Nel caso fosse così, verifica cosa l'app deve fare per riprendere l'attività per cui è stata attivata. Essendo un'app semplice, l'unica attività che riprende è quella di portarti sulla pagina secondaria quando l'app viene aperta.

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à appaiono nella sequenza temporale, le visualizziamo usando il framework 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 delle schede adattive e delle schede 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 delle schede adattive come stringa JSON al UserActivity nel seguente modo:

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 la tua app è multipiattaforma (ad esempio su Android e iOS) o mantiene lo stato utente nel cloud, è possibile pubblicare UserActivities tramite Microsoft Graph. Dopo che l'applicazione o il servizio è stato autenticato con un account Microsoft, sono necessarie solo due semplici chiamate REST per generare gli oggetti attività e cronologia, utilizzando gli stessi dati descritti in precedenza.

Riassunto

Puoi usare l'API UserActivity per far apparire la tua app in Timeline e Cortana.

API chiave

  • Last updated on