Tiles e Background Tasks no UWP

Globalcode – Open4education
Trilha – Universal Windows
Diego Castro | João Ronaldo
Evangelistas Técnicos
www.talkitbr.com

Diego Castro
/dfdcastro
www.talkitbr.com
/talkitbr
João Ronaldo Cunha
/joaoronaldo.cunha
www.talkitbr.com
/talkitbr /joaocunhaeld

Agenda
Live Tiles
Tiles
Tile Templates
Secondary Tiles
Adaptive Tile
Demo
Background Execution
Criando Background Tasks

Tiles

Live State
Plate
App Icon
Short Name
Badge
Content
Plate
Short Name
Badge
App Icon
Content
Anatomia
Semi-Live State
Plate
App Logo
Short Name
Badge
Plate
App Logo
Short Name
Badge
Basic State
Plate
App Logo
Short Name
Plate
App Logo
Short Name

Atualizando
Programado
Configurar com “ScheduledTileNotification”
Periódico
Pull URL 30m / 60m / 6h / 12h / 24h
Local
Update em foreground/background
Push
Push services

Responsive Tiles
Tiles não são sempre dos
mesmos tamanhos
Se adaptam de acordo
com a densidade do
dispositivo
Alta densidadeBaixa densidade

Tile Templates

Basic Templates

Templates Legados
O template que você precisa já
existe?
Templates anteriores ainda
são válidos!

Secondary Tiles

O que é
Deep-link no seu app
Separação de conteúdo
Conteúdo relevante para o
usuário

Adaptive Tile

XML
<tile>
<visual>
<binding template="TileSmall">
<text>Small</text>
</binding>
<binding template="TileMedium">
<text>Medium</text>
</binding>
<binding template="TileWide">
<text>Wide</text>
</binding>
<binding template="TileLarge">
<text>Large</text>
</binding>
</visual>
</tile>

O que podemos fazer

Demo

Background Tasks

O que é
Tarefa que executa em plano de fundo
(background)
Permite executar código da aplicação mesmo
quando ela não estiver em execução.
Usado para:
Atualização de Live Tiles;
Notificações;
Atualização de banco de dados;
Entre outros.

Criando Background Task
Analisar custo
O SO está sobrecarregado? Vale a pena executar o
background task num determinado momento?
Tratar o cancelamento da task
Toda background task pode ser cancelada
Executar em deferral
Background task não pode executar de forma
assíncrona.
Indicar progresso

public async void Run(IBackgroundTaskInstance taskInstance)
{
var cost = BackgroundWorkCost.CurrentBackgroundWorkCost;
if (cost == BackgroundWorkCostValue.High)
{
return;
}
var cancel = new System.Threading.CancellationTokenSource();
taskInstance.Canceled += (s, e) =>
{
cancel.Cancel();
cancel.Dispose();
};
var deferral = taskInstance.GetDeferral();
try
{
await Task.Run(async () =>
{
for (int i = 0; i < 10; i++)
{
taskInstance.Progress = (uint)i * 10;
await Task.Delay(2000);
}
}, cancel.Token);
}
finally
{
deferral.Complete();
}
}
Analisar Custo

{
{
return;
}
{
cancel.Cancel();
cancel.Dispose();
};
try
{
{
for (int i = 0; i < 10; i++)
{
}
}, cancel.Token);
}
finally
{
}
}
Tratar cancelamento

{
{
return;
}
{
cancel.Cancel();
cancel.Dispose();
};
try
{
{
for (int i = 0; i < 10; i++)
{
}
}, cancel.Token);
}
finally
{
}
}
Executar em deferral

{
{
return;
}
{
cancel.Cancel();
cancel.Dispose();
};
try
{
{
for (int i = 0; i < 10; i++)
{
}
}, cancel.Token);
}
finally
{
}
}
Indicar progresso

No Windows 10 uma aplicação pode ter muitas
background tasks.
Seja consciente! Executar várias background tasks
pode prejudicar a experiência do usuário.

Requisitando Acesso
A aplicação precisa requisitar acesso para rodar
Background Tasks
O Windows 10 não exibe mais a caixa de diálogo,
assim como já era no Windows Phone 8.1.
BackgroundAccessStatus allowed = await BackgroundExecutionManager.RequestAccessAsync();
switch (allowed)
{
// allowed
case BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity: break;
case BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity: break;
// denied
case BackgroundAccessStatus.Denied: break;
// cancelled
case BackgroundAccessStatus.Unspecified: break;
}

Registrando
Registramos a Background Task usando o
BackgroundExecutionManager.
Neste momento definimos o trigger e as condições
para rodar a background task.
var task = new BackgroundTaskBuilder
{
Name = nameof(MyBackgroundTask),
CancelOnConditionLoss = false,
TaskEntryPoint = typeof(MyBackgroundTask).ToString(),
};
task.SetTrigger(new SystemTrigger(SystemTriggerType.InternetAvailable, false));
task.AddCondition(new SystemCondition(SystemConditionType.userPresent));
task.Register();

Especificando no manifest
No manifest da aplicação registramos uma
extensão da aplicação definindo nossa Task.
Atenção para os tipos definidos para o Background
Task.
<Applications>
<Application Id="App"
<Extensions>
<Extension Category="windows.backgroundTasks" EntryPoint="SampleApp.Tasks.MyBackgroundTask">
<BackgroundTasks>
<Task Type="systemEvent" />

</BackgroundTasks>
</Extension>
</Extensions>
</Application>
</Applications>

Executando a Task
A execução de um Background Task é
determinada:
Por trigger.
Por zero ou mais condições.
Posso registrar uma task com diferentes triggers e
diferentes condições.

Windows8.1
SystemTrigger
TimeTrigger
MaintenanceTrigger
DeviceUseTrigger
DeviceServicingTrigger
PushNotificationTrigger
Phone8.1
CachedFileUpdaterTrigger
DeviceConnectionChangeTrigger
GattCharacteristicNotificationTrigger
RfcommConnectionTrigger
LocationTrigger
Windows10
AppointmentStoreNotificationTrigger
ContactStoreNotificationTrigger
EmailStoreNotificationTrigger
BluetoothLEAdvertisementWatcherTrigger
BluetoothLEAdvertisementPublisherTrigger
DeviceWatcherTrigger
ActivitySensorTrigger
SensorDataThresholdTrigger
ToastNotificationHistoryChangedTrigger
ToastNotificationActionTrigger
ApplicationTrigger
MediaProcessingTrigger
SocketActivityTrigger
Executando a Task
Triggers

Executando a Task
Triggers -Time Trigger
Time Trigger deve ter ao menos 15 minutos para
ser recorrente.
Definir trigger menor faz com que ele seja
executado somente uma vez.
// ...
task.SetTrigger(new TimeTrigger(15, false));
task.AddCondition(new SystemCondition(SystemConditionType.UserPresent));
task.Register();
// ...

Executando a Task
Condições do Sistema
User Present
User Not Present
Internet Available
Internet Not Available
Session Connected
Session Disconnected
Free Network Available
Se a rede não tem taxa
para tráfego de dados
Work Cost Not High

Tempo Execução da Task
Cancel
(5 seconds)
Memory
Run
(25 seconds)
Default tasks
Mínimo 25 segundos de
execução
5 segundos após receber
sinal de cancelamento.
Memory
Run
(no end)
End
(no warning, for now)
Long-running tasks
Inclui triggers: Application,
Maintenance e DeviceUse

Restrições
Quiet hours
Somente quando não estiver sendo usado pelo usuário.
Não são emitidas notificações
Nenhuma background task é executada
Tarefas em andamento são canceladas

Restrições
Economia de Bateria
Usuários definem as aplicações que podem executar em
Background
Número de tasks controlado
Identifica tasks abusivas

Debug e Log
Visual Studio pode disparar background tasks.
Log é registrado em:
Application & Services Logs > Microsoft >
BackgroundTaskInfrastructure

Dúvidas?

Contatos
/dfdcastro
www.talkitbr.com
/joaoronaldo.cunha
/talkitbr
/talkitbr

Obrigado!

Tiles e Background Tasks no UWP

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Tiles e Background Tasks no UWP

Semelhante a Tiles e Background Tasks no UWP (20)

Mais de Diego Castro

Mais de Diego Castro (6)

Tiles e Background Tasks no UWP

Notas do Editor