Nota
O acesso a esta página requer autorização. Podes tentar iniciar sessão ou mudar de diretório.
O acesso a esta página requer autorização. Podes tentar mudar de diretório.
Este tópico descreve como ajudar os utilizadores a retomar o que estavam a fazer na sua aplicação no respetivo PC e entre dispositivos.
Observação
A partir de julho de 2021, os usuários que tiverem o histórico de atividades sincronizado em seus dispositivos Windows por meio de sua Conta da Microsoft (MSA) não terão mais a opção de carregar novas atividades na Linha do tempo. Eles ainda poderão usar a Linha do tempo e ver seu histórico de atividades (informações sobre aplicativos, sites e arquivos recentes) em seu PC local. As contas conectadas ao AAD não serão afetadas.
Atividades do usuário e linha do tempo
O nosso tempo todos os dias está distribuído por vários dispositivos. Podemos usar nosso telefone enquanto estamos no ônibus, um PC durante o dia e, em seguida, um telefone ou tablet à noite. A partir do Windows 10 Build 1803 ou posterior, a criação de uma Atividade de Utilizador faz com que essa atividade apareça na linha do tempo do Windows e no recurso Continuar de onde parei da Cortana. A Linha do tempo é uma exibição de tarefas avançada que aproveita as Atividades do Usuário para mostrar uma visão cronológica do que você tem trabalhado. Ele também pode incluir o que você estava trabalhando em todos os dispositivos.
Da mesma forma, vincular seu telefone ao seu PC Windows permite que você continue o que estava fazendo anteriormente em seu dispositivo iOS ou Android.
Pense numa UserActivity como algo específico no qual o utilizador estava a trabalhar na sua aplicação. Por exemplo, se você estiver usando um leitor RSS, um UserActivity pode ser o feed que você está lendo. Se você estiver jogando um jogo, o UserActivity pode ser o nível que você está jogando. Se estiver a ouvir música numa aplicação, o UserActivity pode ser a lista de reprodução que está a ouvir. Se você estiver trabalhando em um documento, o UserActivity pode estar onde você parou de trabalhar nele, e assim por diante. Em resumo, uma UserActivity representa um destino dentro do seu aplicativo para que permita que o usuário retome o que estava fazendo.
Quando se envolve com uma UserActivity ao chamar UserActivity.CreateSession, o sistema cria um registo de histórico indicando a hora de início e fim dessa UserActivity. À medida que você se envolve novamente com esse UserActivity ao longo do tempo, vários registros de histórico são registrados para ele.
Adicionar Atividades do Usuário ao seu aplicativo
Um UserActivity é a unidade de envolvimento do usuário no Windows. Ele tem três partes: um URI usado para ativar o aplicativo ao qual a atividade pertence, visuais e metadados que descrevem a atividade.
- O ActivationUri é usado para retomar a aplicação com um contexto específico. Normalmente, esse link assume a forma de manipulador de protocolo para um esquema (por exemplo, "my-app://page2?action=edit") ou de um AppUriHandler (por exemplo,
http://contoso.com/page2?action=edit). - VisualElements expõe uma classe que permite ao usuário identificar visualmente uma atividade com um título, descrição ou elementos Adaptive Card.
- Finalmente, o Conteúdo é onde se podem armazenar metadados para a atividade que podem ser usados para agrupar e recuperar atividades num contexto específico. Muitas vezes, isto assume a forma de dados https://schema.org.
Para adicionar um UserActivity ao seu aplicativo:
- Gere objetos UserActivity quando o contexto do usuário mudar dentro do aplicativo (como navegação de página, novo nível de jogo, etc.)
- Preencha objetos UserActivity com o conjunto mínimo de campos obrigatórios: ActivityId , ActivationUri , e UserActivity.VisualElements.DisplayText .
- Adicione um manipulador de esquema personalizado ao seu aplicativo para que ele possa ser reativado por um UserActivity.
Um UserActivity pode ser integrado numa aplicação usando apenas algumas linhas de código. Por exemplo, imagine esse código em MainPage.xaml.cs, dentro da classe MainPage (nota: assume 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();
}
A primeira linha do método MainPage.
- Seu aplicativo deve nomear as atividades de tal forma que a mesma ID seja gerada cada vez que o usuário estiver em um local específico no aplicativo. Por exemplo, se o seu aplicativo for baseado em páginas, use um identificador para a página; se for baseado em documentos, utilize o nome do documento (ou um resumo do nome).
- Se houver uma atividade existente no feed com o mesmo ID, essa atividade será retornada do canal com
UserActivity.Statedefinido como Publicado). Se não houver nenhuma atividade com esse nome e a nova atividade for retornada comUserActivity.Statedefinida como Nova. - As atividades estão limitadas ao seu aplicativo. Não precisa de se preocupar com o facto de o seu ID de atividade colidir com IDs noutras aplicações.
Depois de obter ou criar o UserActivity, especifique os outros dois campos obrigatórios: UserActivity.VisualElements.DisplayTexte UserActivity.ActivationUri.
Em seguida, guarde os metadados de UserActivity chamando SaveAsynce, finalmente, CreateSession, que retorna uma UserActivitySession. O UserActivitySession é o objeto que podemos usar para gerir quando o utilizador está realmente envolvido com o UserActivity. Por exemplo, devemos chamar Dispose() no UserActivitySession quando o usuário sair da página. No exemplo acima, também chamamos Dispose() em _currentActivity antes de chamar CreateSession(). Isso ocorre porque criamos _currentActivity um campo de membro de nossa página e queremos parar qualquer atividade existente antes de iniciar a nova (observação: o é o ? que testa para null antes de executar o acesso de membro).
Uma vez que, neste caso, o ActivationUri é um esquema personalizado, também precisamos registrar o protocolo no manifesto do aplicativo. Isso é feito no arquivo XML Package.appmanifest ou usando o designer.
Para fazer a alteração com o designer, clique duas vezes no arquivo Package.appmanifest no seu projeto para abrir o designer, selecione o separador Declarações e adicione uma definição de Protocolo. A única propriedade que precisa ser completada, por enquanto, é Nome. Ele deve corresponder ao URI que especificamos acima, my-app.
Agora precisamos escrever algum código para dizer ao aplicativo o que fazer quando ele for ativado por um protocolo. Substituiremos o método OnActivated no App.xaml.cs para passar o URI para a página principal, da seguinte forma:
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();
}
O que esse código faz é detetar se o aplicativo foi ativado por meio de um protocolo. Se for o caso, então verifica o que a aplicação deve fazer para retomar a tarefa para a qual está a ser ativada. Sendo um aplicativo simples, a única atividade que este aplicativo retoma é colocá-lo na página secundária quando o aplicativo aparece.
Use cartões adaptáveis para melhorar a experiência da Linha do tempo
As Atividades do Usuário aparecem na Cortana e na Linha do Tempo. Quando as atividades aparecem na Linha do tempo, nós as exibimos usando a estrutura Adaptive Card. Se você não fornecer um cartão adaptável para cada atividade, a Linha do tempo criará automaticamente um cartão de atividade simples com base no nome e ícone do aplicativo, no campo de título e no campo de descrição opcional. Abaixo está um exemplo de carga útil do Adaptive Card e o cartão que ele produz.
]
Exemplo de cadeia JSON de carga útil adaptável da placa:
{
"$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
}
]
}
]
}
Adicione a carga útil dos Adaptive Cards como uma cadeia de caracteres JSON à UserActivity da seguinte forma:
activity.VisualElements.Content =
Windows.UI.Shell.AdaptiveCardBuilder.CreateAdaptiveCardFromJson(jsonCardText); // where jsonCardText is a JSON string that represents the card
Integração de plataformas e entre serviços
Se o seu aplicativo for executado de forma multiplataforma (por exemplo, em Android e iOS) ou mantiver o estado do utilizador na nuvem, poderá publicar atividades de utilizador por meio do Microsoft Graph. Depois de o seu aplicativo ou serviço ser autenticado com uma Conta Microsoft, é necessário apenas fazer duas chamadas REST simples para gerar os objetos de Atividade e de Histórico , utilizando os mesmos dados mencionados acima.
Resumo
Você pode usar a API UserActivity para fazer com que seu aplicativo apareça na Linha do tempo e na Cortana.
- Saiba mais sobre a API UserActivity
- Verifique o código de exemplo .
- Veja Cards Adaptativos mais sofisticados.
- Publique um UserActivity a partir de iOS, Android ou do seu serviço Web através Microsoft Graph.
- Saiba mais sobre o Project Rome no GitHub.