Compartilhar via

Habilitar as notificações por push

  • Artigo

As notificações por push permitem que os clientes sejam notificados para mensagens de entrada e outras operações que ocorrem em um thread de chat em situações em que o aplicativo móvel não está em execução em primeiro plano. Os Serviços de Comunicação do Azure dão suporte a uma lista de eventos que você pode assinar.

Observação

Há suporte para notificações por push de chat para o SDK do Android em versões a partir da versão 1.1.0-beta.4 e 1.1.0. É recomendável que você use a versão 2.0.0 ou mais recente, pois as versões mais antigas têm um problema conhecido com a renovação do registro. As etapas de 8 a 12 só são necessárias para versões iguais ou maiores que 2.0.0.

  1. Configure o Firebase Cloud Messaging para o projeto ChatQuickstart. Conclua as etapas Create a Firebase project, Register your app with Firebase, Add a Firebase configuration file, Add Firebase SDKs to your app e Edit your app manifest na Documentação do Firebase.

  2. Crie um Hub de Notificações na mesma assinatura que o recurso de serviços de comunicação, defina as configurações de mensagens de nuvem do Firebase para o hub e vincule o Hub de Notificações ao recurso de Serviços de Comunicação. Confira Provisionamento do Hub de Notificações.

  3. Crie um novo arquivo chamado MyFirebaseMessagingService.java no mesmo diretório em que MainActivity.java reside. Copie o seguinte código dentro de MyFirebaseMessagingService.java. Você precisará substituir <your_package_name> pelo nome do pacote usado em MainActivity.java. Você pode usar seu valor para <your_intent_name>. Esse valor será usado na etapa 6 abaixo.

       package <your_package_name>;

   import android.content.Intent;
   import android.util.Log;

   import androidx.localbroadcastmanager.content.LocalBroadcastManager;

   import com.azure.android.communication.chat.models.ChatPushNotification;
   import com.google.firebase.messaging.FirebaseMessagingService;
   import com.google.firebase.messaging.RemoteMessage;

   import java.util.concurrent.Semaphore;

   public class MyFirebaseMessagingService extends FirebaseMessagingService {
       private static final String TAG = "MyFirebaseMsgService";
       public static Semaphore initCompleted = new Semaphore(1);

       @Override
       public void onMessageReceived(RemoteMessage remoteMessage) {
           try {
               Log.d(TAG, "Incoming push notification.");

               initCompleted.acquire();

               if (remoteMessage.getData().size() > 0) {
                   ChatPushNotification chatPushNotification =
                       new ChatPushNotification().setPayload(remoteMessage.getData());
                   sendPushNotificationToActivity(chatPushNotification);
               }

               initCompleted.release();
           } catch (InterruptedException e) {
               Log.e(TAG, "Error receiving push notification.");
           }
       }

       private void sendPushNotificationToActivity(ChatPushNotification chatPushNotification) {
           Log.d(TAG, "Passing push notification to Activity: " + chatPushNotification.getPayload());
           Intent intent = new Intent("<your_intent_name>");
           intent.putExtra("PushNotificationPayload", chatPushNotification);
           LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
       }
   }

  4. Na parte superior de MainActivity.java, adicione as seguintes instruções de importação:

       import android.content.BroadcastReceiver;
   import android.content.Context;
   import android.content.Intent;
   import android.content.IntentFilter;

   import androidx.localbroadcastmanager.content.LocalBroadcastManager;
   import com.azure.android.communication.chat.models.ChatPushNotification;
   import com.google.android.gms.tasks.OnCompleteListener;
   import com.google.android.gms.tasks.Task;
   import com.google.firebase.messaging.FirebaseMessaging;

  5. Adicione o código a seguir à classe MainActivity:

       private BroadcastReceiver firebaseMessagingReceiver = new BroadcastReceiver() {
       @Override
       public void onReceive(Context context, Intent intent) {
           ChatPushNotification pushNotification =
               (ChatPushNotification) intent.getParcelableExtra("PushNotificationPayload");

           Log.d(TAG, "Push Notification received in MainActivity: " + pushNotification.getPayload());

           boolean isHandled = chatAsyncClient.handlePushNotification(pushNotification);
           if (!isHandled) {
               Log.d(TAG, "No listener registered for incoming push notification!");
           }
       }
   };


   private void startFcmPushNotification() {
       FirebaseMessaging.getInstance().getToken()
           .addOnCompleteListener(new OnCompleteListener<String>() {
               @Override
               public void onComplete(@NonNull Task<String> task) {
                   if (!task.isSuccessful()) {
                       Log.w(TAG, "Fetching FCM registration token failed", task.getException());
                       return;
                   }

                   // Get new FCM registration token
                   String token = task.getResult();

                   // Log and toast
                   Log.d(TAG, "Fcm push token generated:" + token);
                   Toast.makeText(MainActivity.this, token, Toast.LENGTH_SHORT).show();

                   chatAsyncClient.startPushNotifications(token, new Consumer<Throwable>() {
                       @Override
                       public void accept(Throwable throwable) {
                           Log.w(TAG, "Registration failed for push notifications!", throwable);
                       }
                   });
               }
           });
   }

  6. Atualizar a função onCreate em MainActivity.

       @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       LocalBroadcastManager
           .getInstance(this)
           .registerReceiver(
               firebaseMessagingReceiver,
               new IntentFilter("<your_intent_name>"));
   }

  7. Coloque o seguinte código abaixo do comentário <RECEIVE CHAT MESSAGES> em MainActivity:

   startFcmPushNotification();

   chatAsyncClient.addPushNotificationHandler(CHAT_MESSAGE_RECEIVED, (ChatEvent payload) -> {
       Log.i(TAG, "Push Notification CHAT_MESSAGE_RECEIVED.");
       ChatMessageReceivedEvent event = (ChatMessageReceivedEvent) payload;
       // You code to handle ChatMessageReceived event
   });
  1. Adicione o campoxmlns:tools ao arquivoAndroidManifest.xml:
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.azure.android.communication.chat.sampleapp">
  1. Desabilite o inicializador padrão para WorkManager em AndroidManifest.xml:
    <!-- Disable the default initializer of WorkManager so that we could override it in MyAppConfiguration  -->
    <provider
        android:name="androidx.startup.InitializationProvider"
        android:authorities="${applicationId}.androidx-startup"
        android:exported="false"
        tools:node="merge">
      <!-- If you are using androidx.startup to initialize other components -->
      <meta-data
          android:name="androidx.work.WorkManagerInitializer"
          android:value="androidx.startup"
          tools:node="remove" />
    </provider>
    <!-- End of Disabling default initializer of WorkManager -->
  1. Adicione a dependência WorkManager ao seu arquivo build.gradle:
    def work_version = "2.7.1"
    implementation "androidx.work:work-runtime:$work_version"
  1. Adicione um inicializador personalizado WorkManager criando uma classe implementando Configuration.Provider:
    public class MyAppConfiguration extends Application implements Configuration.Provider {
        Consumer<Throwable> exceptionHandler = new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) {
                Log.i("YOUR_TAG", "Registration failed for push notifications!" + throwable.getMessage());
            }
        };
    
        @Override
        public void onCreate() {
            super.onCreate();
            // Initialize application parameters here
            WorkManager.initialize(getApplicationContext(), getWorkManagerConfiguration());
        }
    
        @NonNull
        @Override
        public Configuration getWorkManagerConfiguration() {
            return new Configuration.Builder().
                setWorkerFactory(new RegistrationRenewalWorkerFactory(COMMUNICATION_TOKEN_CREDENTIAL, exceptionHandler)).build();
        }
    }

Explicação para o código acima: o inicializador padrão de WorkManager foi desabilitado na etapa 9. Esta etapa implementa Configuration.Provider para fornecer um 'WorkFactory' personalizado, que é responsável por criar WorkerManager durante o runtime.

Se o aplicativo estiver integrado ao Azure Function, a inicialização dos parâmetros do aplicativo deverá ser adicionada no método 'onCreate()'. O método 'getWorkManagerConfiguration()' é chamado quando o aplicativo está sendo iniciado, antes de qualquer atividade, serviço ou objeto receptor (excluindo provedores de conteúdo) ser criado, para que os parâmetros do aplicativo possam ser inicializados antes de serem usados. Mais detalhes podem ser encontrados no aplicativo de chat de exemplo.

  1. Adicione o campo android:name=.MyAppConfiguration, que usa o nome da classe da etapa 11, em AndroidManifest.xml:
<application
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:roundIcon="@mipmap/ic_launcher_round"
      android:theme="@style/Theme.AppCompat"
      android:supportsRtl="true"
      android:name=".MyAppConfiguration"
>