Abilitare le notifiche push

Le notifiche push consentono ai client di ricevere notifiche per i messaggi in ingresso e altre operazioni che si verificano in un thread di chat in situazioni in cui l'app per dispositivi mobili non è in esecuzione in primo piano. Servizi di comunicazione Azure supporta un elenco di eventi che è possibile sottoscrivere.

Nota

Le notifiche push chat sono supportate per Android SDK nelle versioni a partire dalla versione 1.1.0-beta.4 e 1.1.0. È consigliabile usare la versione 2.0.0 o successiva, poiché le versioni precedenti hanno un problema noto con il rinnovo della registrazione. I passaggi da 8 a 12 sono necessari solo per le versioni uguali o superiori a 2.0.0.

1. Configurare Firebase Cloud Messaging per il progetto ChatQuickstart. Completare i passaggi Create a Firebase project, Add a Firebase configuration fileRegister your app with Firebase, , Add Firebase SDKs to your appe Edit your app manifest nella documentazione di Firebase.

2. Creare un hub di notifica nella stessa sottoscrizione della risorsa servizi di comunicazione, configurare le impostazioni di Firebase Cloud Messaging per l'hub e collegare l'hub di notifica alla risorsa Servizi di comunicazione. Vedere Provisioning dell'hub di notifica.

3. Creare un nuovo file denominato MyFirebaseMessagingService.java nella stessa directory in cui MainActivity.java risiede. Copiare il codice seguente in MyFirebaseMessagingService.java. È necessario sostituire <your_package_name> con il nome del pacchetto usato in MainActivity.java. È possibile usare il proprio valore per <your_intent_name>. Questo valore verrà usato nel passaggio 6 seguente.

      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. Nella parte superiore del file MainActivity.javaaggiungere le istruzioni di importazione seguenti:

      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. Aggiungere il codice seguente alla 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. Aggiornare la funzione onCreate in 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. Inserire il codice seguente sotto il commento <RECEIVE CHAT MESSAGES> in 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
   });

8. Aggiungere il xmlns:tools campo al AndroidManifest.xml file:

    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.azure.android.communication.chat.sampleapp">

9. Disabilitare l'inizializzatore predefinito per WorkManager in 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 -->

10. Aggiungere la WorkManager dipendenza al build.gradle file:

    def work_version = "2.7.1"
    implementation "androidx.work:work-runtime:$work_version"

11. Aggiungere un inizializzatore personalizzato WorkManager creando una classe che implementa 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();
        }
    }

Spiegazione del codice precedente: L'inizializzatore predefinito di WorkManager è stato disabilitato nel passaggio 9. Questo passaggio implementa Configuration.Provider per fornire un 'WorkFactory' personalizzato, responsabile della creazione WorkerManager durante il runtime.

Se l'app è integrata con funzione di Azure, l'inizializzazione dei parametri dell'applicazione deve essere aggiunta nel metodo 'onCreate()'. Il metodo 'getWorkManagerConfiguration()' viene chiamato quando l'applicazione viene avviata, prima che siano stati creati oggetti attività, servizio o ricevitore (esclusi i provider di contenuto), in modo che i parametri dell'applicazione possano essere inizializzati prima di essere usati. Altre informazioni sono disponibili nell'app chat di esempio.

12. Aggiungere il campo, che usa il nome della android:name=.MyAppConfiguration classe dal passaggio 11, in 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"
>