Condividi tramite

Abilitare notifiche push

  • Articolo

Le notifiche push consentono ai client di ricevere notifiche per i messaggi in arrivo 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 di 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, perché le versioni precedenti presentano un problema noto con il rinnovo della registrazione. I passaggi da 8 a 12 sono necessari solo per le versioni uguali o maggiori di 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 app, e Edit your app manifest nella documentazione di Firebase.

  2. Creare un hub di notifica nella stessa sottoscrizione della risorsa di Servizi di comunicazione, configurare le impostazioni di Firebase Cloud Messaging per l'hub e collegare l'hub di notifica alla risorsa di 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. Sarà 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 import 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
   });
  1. 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">
  1. 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 -->
  1. Aggiungere la WorkManager dipendenza al build.gradle file:
    def work_version = "2.7.1"
    implementation "androidx.work:work-runtime:$work_version"
  1. 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, che è responsabile della creazione WorkerManager durante il runtime.

Se l'app è integrata con la 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. Altri dettagli sono disponibili nell'app di chat di esempio.

  1. Aggiungere il android:name=.MyAppConfiguration campo , che usa il nome della classe del 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"
>