Tutorial: Enviar notificações para dispositivos específicos usando os Hubs de Notificação e o Google Firebase Cloud Messaging

• Android
• iOS
• Windows Runtime 8.1 universal
• Windows Phone Silverlight 8.x

Visão geral

Importante

A partir de junho de 2024, as APIs legadas do FCM não terão mais suporte e serão descontinuadas. Para evitar qualquer interrupção no seu serviço de notificação push, você deve migrar para o protocolo FCM v1 o mais rápido possível.

Este tutorial mostra como usar os Hubs de Notificação do Azure para transmitir notificações de últimas notícias para um aplicativo Android. Ao concluir, você poderá se registrar nas categorias de últimas notícias que desejar e receber notificações por push apenas para essas categorias. Esse cenário é um padrão comum para muitos aplicativos nos quais as notificações precisam ser enviadas para grupos de usuários que tenham anteriormente expressado seu interesse por elas, por exemplo, leitor de RSS, aplicativos para fãs de música, etc.

Os cenários de transmissão são habilitados por meio da inclusão de uma ou mais marcas durante a criação de um registro no hub de notificação. Quando as notificações são enviadas para um rótulo, todos os dispositivos que foram registrados para o rótulo receberão a notificação. Como os rótulos são simplesmente cadeias de caracteres, eles não precisam ser provisionados com antecedência. Para obter mais informações sobre marcações, consulte Roteamento e expressões de marcação dos Hubs de Notificação.

Neste tutorial, você executa as seguintes ações:

• Adicionar a seleção de categorias ao aplicativo móvel.
• Registrado para receber notificações com marcas.
• Enviar notificações marcadas.
• Testar o aplicativo

Pré-requisitos

Este tutorial se baseia no aplicativo criado no Tutorial: Enviar notificações por push para dispositivos Android usando os Hubs de Notificação do Microsoft Azure e o Firebase Cloud Messaging. Antes de iniciar este tutorial, conclua o Tutorial: Enviar notificações por push para dispositivos Android usando os Hubs de Notificação do Microsoft Azure e o Firebase Cloud Messaging.

Adicionar a seleção de categorias ao aplicativo

A primeira etapa é adicionar os elementos da interface do usuário na atividade principal existente, o que permite ao usuário selecionar categorias para o registro. As categorias selecionadas por um usuário são armazenadas no dispositivo. Quando o aplicativo é iniciado, o registro do dispositivo é criado no seu hub de notificação com as categorias selecionadas como rótulos.

1. Abra o res/layout/activity_main.xml file e substitua o conteúdo pelo seguinte:

   <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       tools:context="com.example.breakingnews.MainActivity"
       android:orientation="vertical">
   
           <CheckBox
               android:id="@+id/worldBox"
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="@string/label_world" />
           <CheckBox
               android:id="@+id/politicsBox"
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="@string/label_politics" />
           <CheckBox
               android:id="@+id/businessBox"
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="@string/label_business" />
           <CheckBox
               android:id="@+id/technologyBox"
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="@string/label_technology" />
           <CheckBox
               android:id="@+id/scienceBox"
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="@string/label_science" />
           <CheckBox
               android:id="@+id/sportsBox"
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="@string/label_sports" />
           <Button
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:onClick="subscribe"
               android:text="@string/button_subscribe" />
           <TextView
               android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="Hello World!"
               android:id="@+id/text_hello"
           />
   </LinearLayout>
   

2. Abra o arquivo res/values/strings.xml e adicione as seguintes linhas:

   <string name="button_subscribe">Subscribe</string>
   <string name="label_world">World</string>
   <string name="label_politics">Politics</string>
   <string name="label_business">Business</string>
   <string name="label_technology">Technology</string>
   <string name="label_science">Science</string>
   <string name="label_sports">Sports</string>
   

   O layout geográfico main_activity.xml deve ter a aparência como a da seguinte imagem:

   

3. Crie uma classe Notifications no mesmo pacote que a classe MainActivity.

   import java.util.HashSet;
   import java.util.Set;
   import java.util.concurrent.TimeUnit;
   
   import android.content.Context;
   import android.content.SharedPreferences;
   import android.os.AsyncTask;
   import android.util.Log;
   import android.widget.Toast;
   
   import com.google.android.gms.tasks.OnSuccessListener;
   import com.google.firebase.iid.FirebaseInstanceId;
   import com.google.firebase.iid.InstanceIdResult;
   import com.microsoft.windowsazure.messaging.NotificationHub;
   
   public class Notifications {
       private static final String PREFS_NAME = "BreakingNewsCategories";
       private FirebaseInstanceId fcm;
       private NotificationHub hub;
       private Context context;
       private String senderId;
       public static String FCM_token = "";
       private static final String TAG = "Notifications";
   
       public Notifications(Context context, String hubName, String listenConnectionString) {
           this.context = context;
           this.senderId = senderId;
   
           fcm = FirebaseInstanceId.getInstance();
           hub = new NotificationHub(hubName, listenConnectionString, context);
       }
   
       public void storeCategoriesAndSubscribe(Set<String> categories)
       {
           SharedPreferences settings = context.getSharedPreferences(PREFS_NAME, 0);
           settings.edit().putStringSet("categories", categories).commit();
           subscribeToCategories(categories);
       }
   
       public Set<String> retrieveCategories() {
           SharedPreferences settings = context.getSharedPreferences(PREFS_NAME, 0);
           return settings.getStringSet("categories", new HashSet<String>());
       }
   
       public void subscribeToCategories(final Set<String> categories) {
           new AsyncTask<Object, Object, Object>() {
               @Override
               protected Object doInBackground(Object... params) {
                   try {
                       FirebaseInstanceId.getInstance().getInstanceId().addOnSuccessListener(new OnSuccessListener<InstanceIdResult>() {
                           @Override
                           public void onSuccess(InstanceIdResult instanceIdResult) {
                               FCM_token = instanceIdResult.getToken();
                               Log.d(TAG, "FCM Registration Token: " + FCM_token);
                           }
                       });
   
                       TimeUnit.SECONDS.sleep(1);
   
                       String templateBodyFCM = "{\"data\":{\"message\":\"$(messageParam)\"}}";
   
                       hub.registerTemplate(FCM_token,"simpleFCMTemplate", templateBodyFCM,
                               categories.toArray(new String[categories.size()]));
                   } catch (Exception e) {
                       Log.e("MainActivity", "Failed to register - " + e.getMessage());
                       return e;
                   }
                   return null;
               }
   
               protected void onPostExecute(Object result) {
                   String message = "Subscribed for categories: "
                           + categories.toString();
                   Toast.makeText(context, message,
                           Toast.LENGTH_LONG).show();
               }
           }.execute(null, null, null);
       }
   
   }
   

   Essa classe usa o armazenamento local para armazenar as categorias de notícias que este dispositivo deverá receber. Ela também contém métodos para se registrar nessas categorias.

4. Na classe MainActivity, adicione um campo para Notifications:

   private Notifications notifications;
   

5. Em seguida, atualize o método onCreate conforme mostrado no código a seguir. Você se registrará nos Hubs de Notificação no método subscribeToCategories da classe Notifications.

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
   
       mainActivity = this;
   
       FirebaseService.createChannelAndHandleNotifications(getApplicationContext());
       notifications = new Notifications(this, NotificationSettings.HubName, NotificationSettings.HubListenConnectionString);
       notifications.subscribeToCategories(notifications.retrieveCategories());
   }
   

   Confirme se o nome do hub e a cadeia de caracteres de conexão estão definidas corretamente na classe NotificationSettings.

   Observação

   Como as credenciais que são distribuídas com um aplicativo cliente não são geralmente seguras, você só deve distribuir a chave para acesso de escuta com o aplicativo cliente. O acesso de escuta permite que seu aplicativo se registre para receber notificações, mas os registros existentes não podem ser modificados e as notificações não podem ser enviadas. A chave de acesso completo é usada em um serviço back-end protegido para enviar notificações e alterar os registros existentes.

6. Em seguida, adicione as seguintes importações:

   import android.widget.CheckBox;
   import java.util.HashSet;
   import java.util.Set;
   import android.view.View;
   

7. Adicione o seguinte método subscribe para manipular o evento de clique do botão assinar:

   public void subscribe(View sender) {
       final Set<String> categories = new HashSet<String>();
   
       CheckBox world = (CheckBox) findViewById(R.id.worldBox);
       if (world.isChecked())
           categories.add("world");
       CheckBox politics = (CheckBox) findViewById(R.id.politicsBox);
       if (politics.isChecked())
           categories.add("politics");
       CheckBox business = (CheckBox) findViewById(R.id.businessBox);
       if (business.isChecked())
           categories.add("business");
       CheckBox technology = (CheckBox) findViewById(R.id.technologyBox);
       if (technology.isChecked())
           categories.add("technology");
       CheckBox science = (CheckBox) findViewById(R.id.scienceBox);
       if (science.isChecked())
           categories.add("science");
       CheckBox sports = (CheckBox) findViewById(R.id.sportsBox);
       if (sports.isChecked())
           categories.add("sports");
   
       notifications.storeCategoriesAndSubscribe(categories);
   }
   

   Esse método cria uma lista de categorias e usa a classe Notifications para armazenar a lista no armazenamento local e registrar as marcas correspondentes com o hub de notificação. Quando as categorias são alteradas, o registro é recriado com as novas categorias.

Seu aplicativo agora é capaz de armazenar um conjunto de categorias no armazenamento local do dispositivo e registrar com o hub de notificação, sempre que o usuário alterar a seleção de categorias.

Registrar-se para receber notificações

Estas etapas registram com o hub de notificação na inicialização, usando as categorias que foram armazenadas no armazenamento local.

1. Confirme se o seguinte código existe no final do método onCreate na classe MainActivity:

   notifications.subscribeToCategories(notifications.retrieveCategories());
   

   Esse código garante que o aplicativo recupere as categorias do armazenamento local e solicite um registro para essas categorias toda vez que ele for iniciado.

2. Em seguida, atualize o método onStart() na classe MainActivity como a seguir:

   @Override
   protected void onStart() {
   
       super.onStart();
       isVisible = true;
   
       Set<String> categories = notifications.retrieveCategories();
   
       CheckBox world = (CheckBox) findViewById(R.id.worldBox);
       world.setChecked(categories.contains("world"));
       CheckBox politics = (CheckBox) findViewById(R.id.politicsBox);
       politics.setChecked(categories.contains("politics"));
       CheckBox business = (CheckBox) findViewById(R.id.businessBox);
       business.setChecked(categories.contains("business"));
       CheckBox technology = (CheckBox) findViewById(R.id.technologyBox);
       technology.setChecked(categories.contains("technology"));
       CheckBox science = (CheckBox) findViewById(R.id.scienceBox);
       science.setChecked(categories.contains("science"));
       CheckBox sports = (CheckBox) findViewById(R.id.sportsBox);
       sports.setChecked(categories.contains("sports"));
   }
   

   Esse código atualiza a atividade principal com base no status de categorias salvas anteriormente.

O aplicativo agora está completo e pode armazenar um conjunto de categorias no armazenamento local do dispositivo utilizado para registrá-las com o hub de notificação, sempre que o usuário alterar a seleção de categorias. Em seguida, defina um back-end que possa enviar notificações de categoria para esse aplicativo.

Enviar notificações marcadas

Nesta seção, você envia as últimas notícias como notificações de modelo marcadas, de um aplicativo de console do .NET.

1. No Visual Studio, crie um novo aplicativo de console em Visual C#:

   1. No menu, selecione Arquivo>Novo>Projeto.
   2. Em Criar um projeto, selecione Aplicativo de Console (.NET Framework) para C# na lista de modelos e selecione Avançar.
   3. Insira um nome do aplicativo.
   4. Para Solução, escolha Adicionar à solução e selecione Criar para criar o projeto.

2. Selecione Ferramentas>Gerenciador de Pacotes NuGet>Console do Gerenciador do NuGet e, em seguida, na janela do console, execute o seguinte comando:

   Install-Package Microsoft.Azure.NotificationHubs
   

   Essa ação adiciona uma referência ao SDK dos Hubs de Notificação do Azure usando o pacote NuGet Microsoft.Azure.NotificationHubs.

3. Abra o arquivo Program.cs e adicione a seguinte instrução using:

   using Microsoft.Azure.NotificationHubs;
   

4. Na classe Program , adicione o seguinte método ou substitua-o, se ele já existir:

   private static async void SendTemplateNotificationAsync()
   {
       // Define the notification hub.
       NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<connection string with full access>", "<hub name>");
   
       // Apple requires the apns-push-type header for all requests
       var headers = new Dictionary<string, string> {{"apns-push-type", "alert"}};
   
       // Create an array of breaking news categories.
       var categories = new string[] { "World", "Politics", "Business", "Technology", "Science", "Sports"};
   
       // Send the notification as a template notification. All template registrations that contain
       // "messageParam" and the proper tags will receive the notifications.
       // This includes APNS, GCM/FCM, WNS, and MPNS template registrations.
   
       Dictionary<string, string> templateParams = new Dictionary<string, string>();
   
       foreach (var category in categories)
       {
           templateParams["messageParam"] = "Breaking " + category + " News!";
           await hub.SendTemplateNotificationAsync(templateParams, category);
       }
   }
   

   Esse código envia uma notificação de modelo para cada uma das seis marcas na matriz de cadeia de caracteres. O uso de marcas garante que os dispositivos recebam notificações somente para as categorias de marcas.

5. No código anterior, substitua os espaços reservados <hub name> e <connection string with full access> pelo nome do hub de notificação e a cadeia de conexão por DefaultFullSharedAccessSignature do painel do hub de notificação.

6. No método Main(), adicione as seguintes linhas:

    SendTemplateNotificationAsync();
    Console.ReadLine();
   

7. Compile o aplicativo de console.

Testar o aplicativo

1. No Android Studio, execute o aplicativo no emulador ou dispositivo Android. A interface do usuário do aplicativo fornece um conjunto de alternâncias que permite escolher as categorias às quais assinar.

2. Habilite uma ou mais alternâncias de categorias e depois clique em Assinar. O aplicativo converte as categorias selecionadas em rótulos e solicita um novo registro do dispositivo para os rótulos selecionados do hub de notificação. As categorias registradas são retornadas e exibidas em uma caixa de diálogo.

   

3. Execute o aplicativo de console do .NET, que envia notificações para cada categoria. As notificações para as categorias selecionadas são exibidas como notificações do sistema.

   

Próximas etapas

Neste tutorial, você enviou notificações de notícias a dispositivos específicos Android que foram registrados para as categorias. Para saber como enviar notificações por push a usuários específicos, avance ao seguinte tutorial:

Enviar notificações por push para usuários específicos