Condividi tramite

Abilitare le notifiche push in Android

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

Annotazioni

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. È necessario sostituire <your_package_name> con il nome del pacchetto usato in MainActivity.java. È possibile usare il proprio valore per <your_intent_name>. Usare questo valore nel passaggio 6.

       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 dopo 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 è disabilitato nel passaggio 9. Questo passaggio implementa Configuration.Provider per fornire un oggetto personalizzato WorkFactory, che è responsabile della creazione WorkerManager durante il runtime.

Se l'app è integrata con Funzione di Azure, inizializzare i parametri dell'applicazione nel metodo onCreate(). Il metodo getWorkManagerConfiguration() viene chiamato quando l'applicazione viene avviata, prima che vengano creati oggetti attività, servizio o ricevitore (esclusi i provider di contenuto), in modo che i parametri dell'applicazione possano essere inizializzati prima dell'uso. Per altri dettagli, vedi l'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"
>
  • Last updated on