Conteúdo de notificação do aplicativo

Este artigo descreve os elementos da interface que podem ser usados numa notificação de aplicação e fornece exemplos de código para gerar o conteúdo das notificações. Para mais informações sobre as notificações da aplicação, consulte Visão Geral das notificações da aplicação. Para um guia sobre como implementar notificações de aplicação, consulte Quickstart: Notificações de aplicação no SDK de Aplicações Windows.

Como Começar

As notificações do aplicativo são definidas com uma carga XML que é definida pelo esquema de notificação do aplicativo. Atualmente, existem duas formas de gerar o payload XML para uma notificação de aplicação. Os exemplos de código neste artigo demonstram ambos os métodos:

  • A Microsoft.Windows.AppNotifications.Builder APIs - Introduzido no SDK de Aplicações Windows 1.2, este namespace fornece APIs que permitem construir facilmente o payload XML para uma notificação de forma programática, sem se preocupar com os detalhes do formato XML. Exemplos de código que utilizam estas APIs encontram-se nos separadores rotulados como "SDK de Aplicações Windows".
  • XML bruto - Se preferir, você pode criar seu próprio código personalizado para gerar cadeias de caracteres XML no formato necessário. Os exemplos de XML bruto estão nas guias rotuladas como "XML".

Instale o Visualizador de notificações. Esta aplicação gratuita para Windows ajuda-te a desenhar notificações interativas para aplicações, proporcionando uma pré-visualização visual instantânea do teu toast enquanto o editas, semelhante ao editor/vista de design XAML do Visual Studio. Veja Visualizador de Notificações para obter mais informações ou descarregar o Visualizador de Notificações da Loja.

Este artigo aborda apenas a criação do conteúdo de notificação do aplicativo. Para informações sobre como enviar uma notificação, consulte a visão geral das notificações da aplicação.

Estrutura de notificação do aplicativo

Alguns componentes importantes e de alto nível de uma carga XML de notificação de aplicativo incluem:

  • : o atributo lançamento desse elemento define quais argumentos serão passados de volta para o seu aplicativo quando o utilizador clicar no toast, permitindo-lhe criar um deep link para o conteúdo correto que o toast estava a exibir. Para saber mais, consulte Visão Geral das notificações da aplicação.
  • visual: Este elemento representa a parte visual da notificação, incluindo o vínculo genérico que contém texto e imagens.
  • ações: Este elemento representa a componente interativa do toast, incluindo entradas e ações.
  • de áudio: Este elemento especifica o áudio reproduzido quando a notificação pop-up é mostrada ao utilizador.
var builder = new AppNotificationBuilder()
    .AddArgument("conversationId", "9813")

    .AddText("Some text")

    .AddButton(new AppNotificationButton("Archive")
        .AddArgument("action", "archive"))

    .SetAudioUri(new Uri("ms-appx:///Sound.mp3"));

Aqui está uma representação visual do conteúdo da notificação do aplicativo:

Uma captura de ecrã de uma notificação de aplicação com etiquetas para a área de atribuição no topo, mostrando o ícone da aplicação e o nome da app Visualizador de Notificações. A parte do meio da notificação é identificada como área visual, que inclui três linhas de texto. A secção inferior da notificação está identificada como área de ação e contém dois botões rotulados Aceitar e Recusar.

Área de atribuição

A área de atribuição está na parte superior da notificação do aplicativo. A partir do Windows 11, o nome e o ícone da sua aplicação são exibidos nesta área. A área de atribuição inclui também um botão de fechar que permite ao utilizador desligar rapidamente a notificação e um menu de reticências que permite ao utilizador desativar rapidamente as notificações da sua aplicação ou aceder à página de Definições do Windows para as notificações da sua aplicação. A área de atribuição é configurada pelo shell e não pode ser anulada no payload toast XML, embora a sua aplicação possa adicionar itens ao menu de contexto dessa área. Para obter mais informações, consulte Ações do menu de contexto.

Visuais

Cada notificação de aplicativo deve especificar um elemento visual, para o qual deve ser fornecida uma vinculação de notificação genérica de alerta e que pode conter texto e imagens. Estes elementos serão renderizados em vários dispositivos Windows, incluindo desktop, telemóveis, tablets e Xbox.

Para todos os atributos suportados na seção visual e os seus elementos filho, consulte Esquema de notificação de aplicativo.

Elementos de texto

Cada notificação de aplicativo deve ter pelo menos um elemento de texto e pode conter dois elementos de texto adicionais, todos do tipo AdaptiveText. Os elementos de texto suportam ligação de dados, o que permite atualizar o conteúdo do texto após a notificação ser exibida. Para mais informações, consulte a barra de progresso das notificações da aplicação e a ligação de dados.

Uma captura de tela de uma notificação de aplicativo com três linhas de texto. A linha superior do texto é negrito.

Pode controlar quantas linhas de texto são exibidas usando o método AppNotificationTextProperties.SetMaxLines . O padrão (e máximo) é de até 2 linhas de texto para o título e até 4 linhas (combinadas) para os dois elementos de descrição adicionais (o segundo e o terceiro AdaptiveText).

var builder = new AppNotificationBuilder()
    .AddArgument("conversationId", 9813)
    .AddText("Adaptive Tiles Meeting", new AppNotificationTextProperties().SetMaxLines(1))
    .AddText("Conf Room 2001 / Building 135")
    .AddText("10:00 AM - 10:30 AM");

Imagem em linha

Por padrão, as imagens são exibidas embutidas, após quaisquer elementos de texto, preenchendo toda a largura da área visual. Use AppNotificationBuilder.SetInlineImage para adicionar uma imagem inline.

Uma captura de tela de uma notificação de aplicativo mostrando o posicionamento padrão da imagem, em linha, preenchendo toda a largura da área visual. 

var builder = new AppNotificationBuilder()
    .AddText("Featured image of the day.")
    .SetInlineImage(new Uri("ms-appx:///Images/InlineImage.png"));

AppNotificationManager.Default.Show(builder.BuildNotification());

Substituição do logótipo da aplicação

Especificar um valor de posicionamento para "appLogoOverride" fará com que a imagem seja exibida num quadrado no lado esquerdo da área visual. Use AppNotificationBuilder.SetAppLogoOverride para definir esta imagem. O nome desta propriedade reflete o comportamento em versões anteriores do Windows, onde a imagem substituía a imagem padrão do logótipo da aplicação. No Windows 11, o logótipo da aplicação é exibido na área de atribuição, por isso não é sobreposto pela colocação da imagem appLogoOverride.

As dimensões da imagem são de 48x48 pixels a 100% de escala. Geralmente, recomendamos fornecer uma versão de cada ativo de ícone para cada fator de escala: 100%, 125%, 150%, 200%e 400%.

Uma captura de ecrã de uma notificação de aplicativo mostrando a colocação da imagem de substituição do logotipo do aplicativo num quadrado no lado esquerdo da área visual da notificação.

var builder = new AppNotificationBuilder()
    .AddText("Featured image of the day.")
    .SetAppLogoOverride(new Uri("ms-appx:///Images/AppLogo.png"));

Recorte de dicas

As diretrizes de estilo da Microsoft recomendam representar as fotografias de perfil com uma imagem circular para proporcionar uma representação consistente das pessoas entre as aplicações e o shell. Passe AppNotificationImageCrop.Circle para SetAppLogoOverride para renderizar a imagem com um corte circular.

Uma captura de ecrã de uma notificação de aplicativo mostrando o logótipo do aplicativo como uma sobreposição da imagem cortada em um círculo no lado esquerdo da área visual da notificação. 

var builder = new AppNotificationBuilder()
    .AddText("Matt sent you a friend request")
    .AddText("Hey, wanna dress up as wizards and ride around on hoverboards?")
    .SetAppLogoOverride(new Uri("ms-appx:///Images/Profile.png"), AppNotificationImageCrop.Circle);

Imagem de herói

As notificações da aplicação podem mostrar uma imagem de herói, que é uma imagem ToastGenericHeroImage em destaque, exibida de forma proeminente no banner do toast e dentro do Centro de Notificações. Use AppNotificationBuilder.SetHeroImage para adicionar uma imagem de herói. As dimensões da imagem são 364x180 pixels com escala de 100%.

Uma captura de tela de uma notificação de aplicativo mostrando o posicionamento da imagem do herói, acima da área de atribuição. 

var builder = new AppNotificationBuilder()
    .AddText("Marry Anne")
    .AddText("Check out where we camped last night!")
    .SetHeroImage(new Uri("ms-appx:///Images/HeroImage.png"));

Restrições de tamanho de imagem

As imagens que usa na notificação do seu app podem ser obtidas de...

  • http://
  • ms-appx:///
  • ms-appdata:///

Para imagens da Web remotas http e https, há limites no tamanho do arquivo de cada imagem individual. O limite é de 3 MB nas ligações normais e 1 MB nas ligações com medidor.

Ligação normal Ligação medida
3 MB 1 MB

Se uma imagem exceder o tamanho do arquivo, ou falhar o download, ou expirar, a imagem será descartada e o restante da notificação será exibida.

Texto de atribuição

Se precisar de referenciar a origem do seu conteúdo, pode usar texto de atribuição. Use AppNotificationBuilder.SetAttributionText para definir o texto de atribuição. Este texto é sempre exibido abaixo de quaisquer elementos de texto, mas acima de imagens embutidas. O texto usa um tamanho um pouco menor do que os elementos de texto padrão para ajudar a distinguir dos elementos de texto normais.

Em versões mais antigas do Windows que não suportam texto de atribuição, o texto será simplesmente exibido como outro elemento de texto (assumindo que não tens já o máximo de três elementos de texto).

Uma captura de ecrã de uma notificação de aplicação a mostrar o texto de atribuição 

var builder = new AppNotificationBuilder()
    .AddText("Marry Anne")
    .AddText("Check out where we camped last night!")
    .SetAttributionText("via SMS");
    .SetHeroImage(new Uri("ms-appx:///Images/HeroImage.png"));

Carimbo temporal personalizado

Pode sobrescrever o carimbo temporal fornecido pelo sistema com o seu próprio carimbo temporal que represente com precisão quando a mensagem/informação/conteúdo foi gerada. Esse carimbo de data/hora é visível na Central de Notificações.

Captura de ecrã de uma notificação no Centro de Notificações com um carimbo de data/hora personalizado

Para saber mais sobre o uso de um carimbo temporal personalizado, consulte Notificações de carimbos de data personalizados na aplicação.

var builder = new AppNotificationBuilder()
    .AddText("Matt sent you a friend request")
    .AddText("Hey, wanna dress up as wizards and ride around on hoverboards?")
    .SetTimeStamp(new DateTime(2017, 04, 15, 19, 45, 00, DateTimeKind.Utc));

Barra de progresso

Pode fornecer uma barra de progresso na notificação da sua aplicação para manter o utilizador informado sobre o progresso das operações, como os downloads. As barras de progresso suportam ligação de dados, o que permite atualizar dinamicamente os valores de progresso após a notificação ser exibida.

Uma captura de ecrã de uma notificação de aplicação a mostrar uma barra de progresso.

Para saber mais sobre o uso de uma barra de progresso, consulte a barra de progresso das notificações da aplicação e a ligação de dados.

Cabeçalhos

Pode agrupar notificações sob cabeçalhos dentro do Centro de Notificações. Por exemplo, você pode agrupar mensagens de um bate-papo em grupo sob um cabeçalho, ou notificações de grupo de um tema comum sob um cabeçalho, ou mais.

Uma captura de tela de uma central de ações mostrando várias notificações para o aplicativo Visualizador de notificações organizado sob um cabeçalho rotulado

Para saber mais sobre o uso de cabeçalhos, consulte os cabeçalhos de notificação da aplicação.

Conteúdo adaptativo

Para além do conteúdo especificado acima, pode também mostrar conteúdo adaptativo adicional que é visível quando o toast é expandido.

Esse conteúdo adicional é especificado usando o Adaptive, sobre o qual você pode saber mais lendo a documentação do Adaptive Tiles.

Observe que qualquer conteúdo adaptável deve estar contido em um AdaptiveGroup. Caso contrário, não será renderizado usando adaptativo.

Colunas e elementos de texto

Aqui está um exemplo em que colunas e alguns elementos de texto adaptáveis avançados são usados. Como os elementos de texto estão dentro de um AdaptiveGroup, eles suportam propriedades de estilo adaptativo ricas.

Uma captura de ecrã de uma notificação de aplicação mostrando grupos de elementos de texto alinhados à esquerda e à direita da área visual da notificação. 

// The Microsoft.Windows.AppNotifications.Builder syntax does not currently support adaptive text elements.

Buttons

Os botões tornam o seu aviso do tipo 'toast' interativo, permitindo que o utilizador execute ações rápidas na notificação do aplicativo sem interromper o seu fluxo de trabalho atual. Por exemplo, os utilizadores podem responder a uma mensagem diretamente de dentro de uma notificação ou eliminar um e-mail sem sequer abrir a aplicação de email. Os botões aparecem na parte expandida da sua notificação. Use AppNotificationButton para definir botões e AppNotificationBuilder.AddButton para os adicionar à notificação.

Para saber mais sobre como implementar botões de ponta a ponta, consulte Visão geral das notificações da aplicação.

Os botões podem ativar um aplicativo das seguintes maneiras:

  • O aplicativo é ativado em primeiro plano, com um argumento que pode ser usado para navegar até uma página/contexto específico.
  • Outro aplicativo é ativado via inicialização de protocolo.
  • A ativação em segundo plano é suportada explicitamente para aplicativos UWP. Para aplicações do SDK de Aplicações Windows, a aplicação é sempre lançada em primeiro plano. O aplicativo pode chamar AppInstance.GetActivatedEventArgs para detetar se a ativação foi iniciada por uma notificação e determinar, a partir dos argumentos passados, se deve iniciar totalmente o aplicativo em primeiro plano ou apenas manipular a notificação e sair.
  • Ações do sistema, como o modo de adiar ou ignorar a notificação, são suportadas tanto para aplicações UWP como para o SDK de Aplicações Windows. As APIs AppNotificationBuilder não suportam este cenário, mas SDK de Aplicações Windows aplicações podem implementar este cenário usando o Microsoft.Windows. AppNotifications.Builder APIs ou XML bruto.

Observação

Você só pode ter até 5 botões (incluindo itens do menu de contexto que discutiremos mais tarde).

Uma captura de ecrã de uma notificação de aplicação mostrando uma linha de texto seguida de uma linha com dois botões definidos por elementos de ação 

var builder = new AppNotificationBuilder()
    .AddText("New product in stock!")
    .AddButton(new AppNotificationButton("See more details")
        .AddArgument("action", "viewDetails"))
        .AddArgument("contentId", "351")
    .AddButton(new AppNotificationButton("Remind me later")
        .AddArgument("action", "remindLater"))
        .AddArgument("contentId", "351");

Botões com ícones

Pode adicionar ícones aos seus botões usando AppNotificationButton.SetIcon. Esses ícones são imagens de 16x16 pixels, transparentes e brancas, com uma escala de 100%%, e não devem ter qualquer preenchimento incluído na própria imagem. Se optar por fornecer ícones numa notificação de uma aplicação, deve fornecer ícones para TODOS os seus botões na notificação, pois isso transforma o estilo dos seus botões em botões de ícones.

Observação

Para acessibilidade, certifique-se de incluir uma versão branca de contraste do ícone (um ícone preto para fundos brancos), para que, quando o usuário ativar o modo Branco de Alto Contraste, seu ícone fique visível. Para obter mais informações, consulte Suporte a notificações de bloco e pop-up parade idioma, escala e alto contraste.

Captura de ecrã de uma notificação de aplicação que utiliza botões com ícones. 

var builder = new AppNotificationBuilder()
    .AddText("Return books to the library.")
    .AddButton(new AppNotificationButton("Accept")
        .AddArgument("action", "accept")
        .SetIcon(new Uri("ms-appx:///Images/Accept.png")))
    .AddButton(new AppNotificationButton("Snooze")
        .AddArgument("action", "snooze")
        .SetIcon(new Uri("ms-appx:///Images/Snooze.png")))
    .AddButton(new AppNotificationButton("Dismiss")
        .AddArgument("action", "dismiss")
        .SetIcon(new Uri("ms-appx:///Images/Dismiss.png")));

Novo no Windows 11 Update: Pode adicionar dicas de ferramentas aos seus ícones com a propriedade HintToolTip em XML. Isto é ideal se os teus botões tiverem ícones mas não conteúdo, pois isso garante que consegues passar texto que o Windows Narrador pode ler. No entanto, se o conteúdo estiver presente, o Narrador lerá o conteúdo, independentemente do que for passado na dica de ferramenta.

var button = new AppNotificationButton("Reply")
    .AddArgument("action", "reply");

if (AppNotificationButton.IsToolTipSupported())
{
    button.ToolTip = "Click to reply.";
}

var builder = new AppNotificationBuilder()
    .AddText("Notification text.")
    .AddButton(button);

Botões com cores

Novo na Atualização Windows 11: Pode adicionar cores vermelhas ou verdes aos seus botões usando AppNotificationButton.SetButtonStyle com AppNotificationButtonStyle. Em XML, adicione o atributo useButtonStyle ao elemento toast e o atributo hint-buttonStyle ao elemento action como visto abaixo.

Uma captura de tela de uma notificação com três botões, os dois botões esquerdos são verdes com ícones para iniciar uma chamada de vídeo ou iniciar uma chamada de áudio. O terceiro botão é vermelho e tem um ícone para rejeitar a chamada. 

var builder = new AppNotificationBuilder()
    .SetScenario(AppNotificationScenario.IncomingCall)
    .AddText("Andrew Bares", new AppNotificationTextProperties()
        .SetIncomingCallAlignment())
      .AddText("Incoming Call - Mobile", new AppNotificationTextProperties()
        .SetIncomingCallAlignment())
      .SetInlineImage(new Uri("ms-appx:///Images/Profile.png"),
        AppNotificationImageCrop.Circle)
    .AddButton(new AppNotificationButton()
        .SetToolTip("Answer Video Call")
        .SetButtonStyle(AppNotificationButtonStyle.Success)
        .SetIcon(new Uri("ms-appx:///Images/Video.png"))
        .AddArgument("videoId", "123"))
    .AddButton(new AppNotificationButton()
        .SetToolTip("Answer Phone Call")
        .SetButtonStyle(AppNotificationButtonStyle.Success)
        .SetIcon(new Uri("ms-appx:///Images/Call.png"))
        .AddArgument("callId", "123"))
    .AddButton(new AppNotificationButton()
        .SetToolTip("Hang Up")
        .SetButtonStyle(AppNotificationButtonStyle.Critical)
        .SetIcon(new Uri("ms-appx:///Images/HangUp.png"))
        .AddArgument("hangUpId", "123"));

Ações do menu de contexto

Pode adicionar ações adicionais do menu contextual ao menu contextual existente que aparece quando o utilizador clica com o botão direito na notificação da aplicação ou seleciona o ícone do menu contextual. Use AppNotificationButton.SetContextMenuPlacement para colocar um botão no menu de contexto em vez da barra de ações.

Observação

Em dispositivos mais antigos, essas ações adicionais do menu de contexto simplesmente aparecerão como botões normais na sua notificação.

As ações adicionais do menu de contexto que você adiciona (como "Silenciar bate-papo em grupo por 1 hora") aparecem acima das duas entradas padrão do sistema.

Toast com menu de contexto 

var builder = new AppNotificationBuilder()
    .AddText("Camping this weekend?")
    .SetAppLogoOverride(new Uri("ms-appx:///images/Reply.png"), AppNotificationImageCrop.Circle)
    .AddButton(new AppNotificationButton("Mute group chat for 1 hour")
        .AddArgument("action", "mute")
        .SetContextMenuPlacement());

Observação

Itens adicionais do menu de contexto contribuem para o limite total de 5 botões em uma notificação do sistema.

A ativação de itens adicionais do menu de contexto é tratada de forma idêntica aos botões de notificações.

Insumos

As entradas são especificadas na região Ações da notificação da aplicação, o que significa que elas só ficam visíveis quando a notificação é expandida.

Caixa de texto de resposta rápida

Para ativar uma caixa de texto de resposta rápida (por exemplo, numa aplicação de mensagens), adicione uma entrada de texto com AppNotificationBuilder.AddTextBox e um botão, e consulte o ID do campo de introdução de texto para que o botão fique exibido ao lado do campo de entrada. O ícone opcional para o botão, se fornecido, deve ser uma imagem de 32x32 pixels sem preenchimento, pixels brancos definidos como transparentes e escala de 100%.

Uma captura de ecrã de uma notificação de aplicação com uma foto de perfil e algumas linhas de texto. Está incluída uma caixa de texto para escrever diretamente na notificação, bem como um botão para enviar a resposta. 

var builder = new AppNotificationBuilder()
    .AddTextBox("textBox", "Type a reply", "Reply")
    .AddButton(AppNotificationButton("Send")
        .AddArguments("action", "Send")
        .SetInputId("textBox"))
    .BuildNotification();

Entradas com barra de botões

Você também pode ter uma (ou muitas) entradas com botões normais exibidos abaixo das entradas.

Uma captura de tela de uma notificação de aplicativo mostrando uma linha de texto, uma caixa de texto e uma linha com dois botões rotulados como 

// The Microsoft.Windows.AppNotifications.Builder syntax does not currently support quick reply text boxes.

Entrada de seleção

Para além das caixas de texto, pode também usar um menu de seleção com AppNotificationBuilder.AddComboBox.

Uma captura de tela de uma notificação de aplicativo mostrando uma linha de texto, uma entrada de seleção com 

var builder = new AppNotificationBuilder()
    .AddText("4th coffee?")
    .AddText("When do you plan to come in tomorrow?")
    .AddComboBox(new AppNotificationComboBox("time")
        .SetTitle("Select an item:")
        .AddItem("breakfast", "Breakfast")
        .AddItem("lunch", "Lunch")
        .AddItem("dinner", "Dinner")
        .SetSelectedItem("lunch"))
    .AddButton(new AppNotificationButton("Reply")
        .AddArgument("action", "reply")
        .AddArgument("threadId", "9218")
        .SetContextMenuPlacement())
    .AddButton(new AppNotificationButton("Call restaurant")
        .AddArgument("action", "videocall")
        .AddArgument("threadId", "9218")
        .SetContextMenuPlacement());

Snooze/dismiss

Usando um menu de seleção e dois botões, podemos criar uma notificação de lembrete que utiliza as ações de adiar e ignorar do sistema. Certifique-se de definir o cenário como "Lembrete" para que a notificação se comporte como um lembrete.

Uma captura de ecrã de uma notificação de aplicação com linhas de texto que descrevem a hora e a localização de uma reunião. Uma caixa de seleção tem

Vinculamos o botão de soneca à entrada do menu de seleção usando a propriedade SelectionBoxId no botão toast.

A sintaxe Microsoft.Windows.AppNotifications.Builder atualmente não suporta a ativação do sistema. Mas este cenário é suportado para aplicações do SDK de Aplicações Windows, e podes criar notificações para este cenário usando XML bruto.

// The Microsoft.Windows.AppNotifications.Builder syntax does not currently support system activation. 
// But this scenario is supported for Windows App SDK apps, and you can build notifications for this 
// scenario using raw XML.

Para usar o sistema adiar e descartar ações:

  • Especifique um ToastButtonSnooze ou ToastButtonDismiss
  • Opcionalmente, especifique uma cadeia de caracteres de conteúdo personalizada:
  • Se você não fornecer uma cadeia de caracteres, usaremos automaticamente cadeias de caracteres localizadas para "Snooze" e "Dismiss".
  • Opcionalmente, especifique o SelectionBoxId:
  • Se não quiser que o utilizador selecione um intervalo de adiamento e, em vez disso, pretender que a sua notificação seja adiada apenas uma vez para um intervalo de tempo definido pelo sistema (que seja consistente em todo o sistema operativo), então não construa nenhuma entrada <>.
  • Se quiser fornecer opções de intervalo de soneca: - Especifique SelectionBoxId na ação de soneca - Faça corresponder o ID da entrada com o SelectionBoxId da ação de soneca - Especifique o valor de ToastSelectionBoxItempara ser um inteiro não negativo que representa o intervalo de soneca em minutos.

Áudio

Use AppNotificationBuilder.SetAudioUri para especificar um ficheiro de áudio personalizado, ou use AppNotificationBuilder.SetAudioEvent para selecionar um som do sistema. O áudio personalizado pode ser referenciado através dos seguintes caminhos:

  • ms-appx:///
  • ms-appdata:///
var builder = new AppNotificationBuilder()
    .AddText("Notification text.")
    .SetAudioUri(new Uri("ms-appx:///Audio/NotificationSound.mp3"));

Como alternativa, pode-se escolher da lista de ms-winsoundeventsque sempre foram suportados em ambas as plataformas.

var builder = new AppNotificationBuilder()
    .AddText("Notification text.")
    .SetAudioEvent(AppNotificationSoundEvent.Alarm, AppNotificationAudioLooping.Loop);

Consulte a página do esquema de áudio para obter informações sobre áudio em notificações de apps. Para saber como enviar uma notificação de aplicação que utilize áudio personalizado, consulte Notificações de áudio personalizadas na aplicação.

Cenários

Para criar notificações importantes, alarmes, lembretes e notificações de chamadas recebidas, utilize AppNotificationBuilder.SetScenario com um valor AppNotificationScenario . O cenário ajusta alguns comportamentos para criar uma experiência de usuário consistente e unificada. Existem quatro valores possíveis de Cenário:

  • Reminder
  • Alarm
  • IncomingCall
  • Urgent

Lembretes

No cenário de lembrete, a notificação permanecerá na tela até que o usuário a dispense ou tome uma ação. No Windows Mobile, a notificação da app também aparece já expandida. Um som de lembrete será reproduzido. Você deve fornecer pelo menos um botão na notificação do aplicativo. Caso contrário, a notificação será tratada como uma notificação normal.

var builder = new AppNotificationBuilder()
    .AddText("Notification text.")
    .SetScenario(AppNotificationScenario.Reminder);

Alarmes

Os alarmes comportam-se da mesma forma que os lembretes, exceto que os alarmes irão adicionalmente repetir o áudio com um som de alarme padrão. Você deve fornecer pelo menos um botão na notificação do aplicativo. Caso contrário, a notificação será tratada como uma notificação normal.

var builder = new AppNotificationBuilder()
    .AddText("Notification text.")
    .SetScenario(AppNotificationScenario.Alarm)
    .AddButton(new AppNotificationButton("Dismiss")
        .AddArgument("action", "dismiss"));

Chamadas recebidas

As notificações de chamadas recebidas são exibidas pré-expandidas em um formato de chamada especial e permanecem na tela do usuário até serem descartadas. O áudio do toque será repetido por padrão. Nos dispositivos Windows Mobile, mostram ecrã completo.

Notificação da aplicação de chamadas recebidas 

var builder = new AppNotificationBuilder()
    .SetScenario(AppNotificationScenario.IncomingCall)
    .AddText("Andrew Bares", new AppNotificationTextProperties()
        .SetIncomingCallAlignment())
    .AddText("incoming call - mobile", new AppNotificationTextProperties()
        .SetIncomingCallAlignment())
      .SetInlineImage(new Uri("ms-appx:///images/profile.png"),
        AppNotificationImageCrop.Circle)
    .AddButton(new AppNotificationButton("Text reply")
        .SetToolTip("Text reply")
        .SetIcon(new Uri("ms-appx:///images/reply.png"))
        .AddArgument("textId", "123"))
    .AddButton(new AppNotificationButton("Reminder")
        .SetToolTip("Reminder")
        .SetIcon(new Uri("ms-appx:///images/reminder.png"))
        .AddArgument("reminderId", "123"))
    .AddButton(new AppNotificationButton("Ignore")
        .SetToolTip("Ignore")
        .SetIcon(new Uri("ms-appx:///images/ignore.png"))
        .AddArgument("ignoreId", "123"))
    .AddButton(new AppNotificationButton("Answer")
        .SetToolTip("Answer")
        .SetIcon(new Uri("ms-appx:///images/answer.png"))
        .AddArgument("answerId", "123"));

Notificações Importantes

Importante

Exiges: Deve estar a executar Windows Insider Preview Build 22546 ou posterior para usar notificações importantes.

Notificações importantes permitem que os usuários tenham mais controle sobre quais aplicativos de 1ª e 3ª parte podem enviar notificações de aplicativos de alta prioridade (urgentes/importantes) que podem quebrar o Focus Assist (Não perturbe). Isso pode ser modificado nas configurações de notificações.

Uma captura de tela de uma notificação urgente do aplicativo que tem um ponto de exclamação na área de atribuição ao lado do nome do aplicativo. A imagem também mostra a notificação do aplicativo iniciado pelo sistema que fornece botões para o usuário permitir ou não notificações urgentes do aplicativo. 

var builder = new AppNotificationBuilder()
    .AddText("Adaptive Tiles Meeting", 
        new AppNotificationTextProperties()
            .SetMaxLines(1))
    .AddText("Conf Room 2001 / Building 135")
    .AddText("10:00 AM - 10:30 AM");

if (AppNotificationBuilder.IsUrgentScenarioSupported())
{
    builder.SetScenario(AppNotificationScenario.Urgent);
}

Localização e acessibilidade

Seus blocos e notificações de aplicativos podem carregar cadeias de caracteres e imagens personalizadas para idioma de exibição, fator de escala de exibição, alto contraste e outros contextos de tempo de execução. Para mais informações, veja Suporte a notificações de bloco e aviso emergente para idioma, escala e alto contraste.

Manuseio de ativação

Para aprender a gerir ativações de aplicações (o utilizador a clicar na sua notificação ou nos botões da notificação), consulte a visão geral das notificações da aplicação.  

  • Last updated on