Código gerado pelo assistente de notificação por push

Usando um assistente no Visual Studio, você pode gerar notificações por push de um serviço móvel criado com os Serviços Móveis do Azure. O assistente do Visual Studio gera código para ajudá-lo a começar. Este tópico explica como o assistente modifica seu projeto, o que o código gerado faz, como usar esse código e o que você pode fazer ao lado para aproveitar ao máximo as notificações por push. Consulte visão geral dos Serviços de Notificação por Push (WNS) do Windows.

Como o assistente modifica seu projeto

O assistente de notificação por push modifica seu projeto das seguintes maneiras:

Adiciona uma referência ao Cliente Gerenciado dos Serviços Móveis (MobileServicesManagedClient.dll). Não aplicável a projetos JavaScript.
Adiciona um arquivo em uma subpasta em serviços e nomeia o arquivo push.register.cs, push.register.vb, push.register.cpp ou push.register.js.
Cria uma tabela de canais no servidor de banco de dados para o serviço móvel. A tabela contém informações necessárias para enviar notificações por push para instâncias de aplicativo.
Cria scripts para quatro funções: excluir, inserir, ler e atualizar.
Cria um script com uma API personalizada, notifyallusers.js, que envia uma notificação por push para todos os clientes.
Adiciona uma declaração ao arquivo App.xaml.cs, App.xaml.vb ou App.xaml.cpp ou adiciona uma declaração a um novo arquivo, service.js, para projetos JavaScript. A declaração declara um objeto MobileServiceClient, que contém as informações necessárias para se conectar ao serviço móvel. Você pode acessar esse objeto MobileServiceClient, chamado MyServiceNameClient, em qualquer página do aplicativo usando o nome App.MyServiceNameClient.

O arquivo services.js contém o seguinte código:

var <mobile-service-name>Client = new Microsoft.WindowsAzure.MobileServices.MobileServiceClient(
                "https://<mobile-service-name>.azure-mobile.net/",
                "<your client secret>");

Registro para notificações por push

No push.register.*, o método UploadChannel registra o dispositivo para receber notificações por push. A Loja controla as instâncias instaladas do seu aplicativo e fornece o canal de notificação por push. See PushNotificationChannelManager.

O código do cliente é semelhante ao back-end do JavaScript e ao back-end do .NET. Por padrão, quando você adiciona notificações por push para um serviço de back-end JavaScript, uma chamada de exemplo para notificar a API personalizada doAllUsers é inserida no método UploadChannel.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;

namespace App2
{
    internal class mymobileservice1234Push
    {
        public async static void UploadChannel()
        {
            var channel = await Windows.Networking.PushNotifications.PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

            try
            {
                await App.mymobileservice1234Client.GetPush().RegisterNativeAsync(channel.Uri);
                await App.mymobileservice1234Client.InvokeApiAsync("notifyAllUsers");
            }
            catch (Exception exception)
            {
                HandleRegisterException(exception);
            }
        }

        private static void HandleRegisterException(Exception exception)
        {
            
        }
    }
}

Imports Microsoft.WindowsAzure.MobileServices
Imports Newtonsoft.Json.Linq

Friend Class mymobileservice1234Push
    Public Shared Async Sub UploadChannel()
        Dim channel = Await Windows.Networking.PushNotifications.PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync()

        Try
            Await App.mymobileservice1234Client.GetPush().RegisterNativeAsync(channel.Uri)
            Await App.mymobileservice1234Client.GetPush().RegisterNativeAsync(channel.Uri, New String() {"tag1", "tag2"})
            Await App.mymobileservice1234Client.InvokeApiAsync("notifyAllUsers")
        Catch exception As Exception
            HandleRegisterException(exception)
        End Try
    End Sub

    Private Shared Sub HandleRegisterException(exception As Exception)

    End Sub
End Class

#include "pch.h"
#include "services\mobile services\mymobileservice1234\mymobileservice1234Push.h"

using namespace AzureMobileHelper;

using namespace web;
using namespace concurrency;

using namespace Windows::Networking::PushNotifications;

void mymobileservice1234Push::UploadChannel()
{
    create_task(PushNotificationChannelManager::CreatePushNotificationChannelForApplicationAsync()).
    then([] (PushNotificationChannel^ newChannel) 
    {
        return mymobileservice1234MobileService::GetClient().get_push().register_native(newChannel->Uri->Data());
    }).then([]()
    {
        return mymobileservice1234MobileService::GetClient().invoke_api(L"notifyAllUsers");
    }).then([](task<json::value> result)
    {
        try
        {
            result.wait();
        }
        catch(...)
        {
            HandleExceptionsComingFromTheServer();
        }
    });
}

void mymobileservice1234Push::HandleExceptionsComingFromTheServer()
{
}

(function () {
    "use strict";

    var app = WinJS.Application;
    var activation = Windows.ApplicationModel.Activation;

    app.addEventListener("activated", function (args) {
        if (args.detail.kind == activation.ActivationKind.launch) {
            Windows.Networking.PushNotifications.PushNotificationChannelManager.createPushNotificationChannelForApplicationAsync()
                .then(function (channel) {
                    mymobileserviceclient1234Client.push.registerNative(channel.Uri, new Array("tag1", "tag2"))
                    return mymobileservice1234Client.push.registerNative(channel.uri);
                })
                .done(function (registration) {
                    return mymobileservice1234Client.invokeApi("notifyAllUsers");
                }, function (error) {
                    // Error

                });
        }
    });
})();

As marcas de notificação por push fornecem uma maneira de restringir as notificações a um subconjunto de clientes. Você pode usar o método registerNative (ou RegisterNativeAsync) para registrar todas as notificações via push sem especificar tags, ou você pode registrar-se com tags fornecendo o segundo argumento, uma matriz de tags. Se você se registrar com uma ou mais marcas, receberá apenas notificações que correspondam a essas marcas.

Scripts do lado do servidor (somente backend JavaScript)

Para serviços móveis que usam o back-end JavaScript, os scripts do lado do servidor são executados quando ocorrem operações de exclusão, inserção, leitura ou atualização. Os scripts não implementam essas operações, mas são executados quando uma chamada do cliente para a API REST do Windows Mobile dispara esses eventos. Em seguida, os scripts passam o controle para as próprias operações chamando request.execute ou request.respond para emitir uma resposta ao contexto de chamada. Consulte a Referência da API REST dos Serviços Móveis do Azure .

Uma variedade de funções estão disponíveis no script do lado do servidor. Consulte Registrar operações de tabela nos Serviços Móveis do Azure. Para obter uma referência a todas as funções disponíveis, consulte referência do script do servidor de Serviços Móveis.

O seguinte código de API personalizado em Notifyallusers.js também é criado:

exports.post = function(request, response) {
    response.send(statusCodes.OK,{ message : 'Hello World!' })
    
    // The following call is for illustration purpose only
    // The call and function body should be moved to a script in your app
    // where you want to send a notification
    sendNotifications(request);
};

// The following code should be moved to appropriate script in your app where notification is sent
function sendNotifications(request) {
    var payload = '<?xml version="1.0" encoding="utf-8"?><toast><visual><binding template="ToastText01">' +
        '<text id="1">Sample Toast</text></binding></visual></toast>';
    var push = request.service.push; 
    push.wns.send(null,
        payload,
        'wns/toast', {
            success: function (pushResponse) {
                console.log("Sent push:", pushResponse);
            }
        });
}

A função sendNotifications envia uma única notificação como uma notificação de "toast". Você também pode usar outros tipos de notificações por push.

Dica Para obter informações sobre como obter ajuda durante a edição de scripts, consulte Habilitando o IntelliSense para JavaScript do lado do servidor.

Tipos de notificação por push

O Windows dá suporte a notificações que não são notificações por push. Para obter informações gerais sobre notificações, consulte Escolhendo um método de entrega de notificação.

As notificações do sistema são fáceis de usar e você pode examinar um exemplo no código Insert.js na tabela do canal que é gerada para você. Se você planeja usar notificações de bloco ou selo, deve criar um modelo XML para o bloco e o selo e especificar a codificação de informações empacotadas no modelo. Consulte Trabalhando com blocos, selos e notificações do sistema.

Como o Windows responde a notificações por push, ele pode lidar com a maioria dessas notificações quando o aplicativo não está em execução. Por exemplo, uma notificação por push pode informar um usuário quando uma nova mensagem de email está disponível mesmo quando o aplicativo de email local não está em execução. O Windows lida com uma notificação toast exibindo uma mensagem, como a primeira linha de uma mensagem de texto. O Windows lida com uma notificação de mosaico ou símbolo atualizando o mosaico dinâmico de um aplicativo para refletir o número de novas mensagens de email. Dessa forma, você pode solicitar que os usuários do seu aplicativo verifiquem se há novas informações. Seu aplicativo pode receber notificações brutas quando estiver em execução e você pode usá-las para enviar dados ao seu aplicativo. Se o aplicativo não estiver em execução, você poderá configurar uma tarefa em segundo plano para monitorar notificações por push.

Você deve usar notificações por push de acordo com as diretrizes para aplicativos do Windows, pois essas notificações usam os recursos de um usuário e podem distrair se forem usadas em excesso. Consulte Diretrizes e lista de verificação para notificações por push.

Se estiver atualizando blocos dinâmicos com notificações por push, você também deverá seguir as diretrizes em Diretrizes e lista de verificação de blocos e emblemas.

Next steps

Usando os Serviços de Notificação por Push do Windows (WNS)

Você pode chamar os Serviços de Notificação por Push do Windows (WNS) diretamente se os Serviços Móveis não fornecerem flexibilidade suficiente, se você quiser escrever o código do servidor no C# ou no Visual Basic ou se você já tiver um serviço de nuvem e quiser enviar notificações por push dele. Ao chamar o WNS diretamente, você pode enviar notificações por push de seu próprio serviço de nuvem, como uma função de trabalho que monitora dados de um banco de dados ou de outro serviço Web. Seu serviço de nuvem deve se autenticar com o WNS para enviar notificações por push para seus aplicativos. Consulte Como autenticar com o Serviço de Notificação por Push do Windows (JavaScript) ou (C#/C++/VB).

Você também pode enviar notificações por push executando uma tarefa agendada em seu serviço móvel. Consulte Agendar trabalhos recorrentes nos Serviços Móveis.

Aviso Depois de executar o assistente de notificação por push uma vez, não execute o assistente uma segunda vez para adicionar código de registro para outro serviço móvel. Executar o assistente mais de uma vez por projeto gera código que resulta em chamadas sobrepostas para o método CreatePushNotificationChannelForApplicationAsync, o que leva a uma exceção de runtime. Se você quiser se registrar para notificações por push para mais de um serviço móvel, execute o assistente uma vez e, em seguida, reescreva o código de registro para garantir que as chamadas para CreatePushNotificationChannelForApplicationAsync não sejam executadas ao mesmo tempo. Por exemplo, você pode fazer isso movendo o código gerado pelo assistente em push.register.* (incluindo a chamada para CreatePushNotificationChannelForApplicationAsync) fora do evento OnLaunched, mas as especificidades disso dependerão da arquitetura do aplicativo.

Comentários

Esta página foi útil?

Last updated on 2025-07-29