Aktivera push-meddelanden

Artikel
06/01/2023

Med push-meddelanden kan klienter meddelas om inkommande meddelanden och andra åtgärder som utförs i en chatttråd i situationer där mobilappen inte körs i förgrunden. Azure Communication Services stöder en lista över händelser som du kan prenumerera på.

Anteckning

Chatta push-meddelanden stöds för Android SDK i versioner från 1.1.0-beta.4 och 1.1.0. Vi rekommenderar att du använder version 2.0.0 eller senare, eftersom äldre versioner har ett känt problem med registreringsförnyelsen. Steg från 8 till 12 behövs bara för versioner som är lika med eller större än 2.0.0.

Konfigurera Firebase Cloud Messaging för ChatQuickstart-projektet. Slutför stegen Create a Firebase project, Register your app with Firebase, Add a Firebase configuration file, Add Firebase SDKs to your appoch Edit your app manifest i Firebase-dokumentationen.
Skapa en meddelandehubb i samma prenumeration som din Communication Services-resurs, konfigurera dina Firebase Cloud Messaging-inställningar för hubben och länka Notification Hub till din Communication Services-resurs. Se Notification Hub-etablering.

Skapa en ny fil med namnet MyFirebaseMessagingService.java i samma katalog där MainActivity.java finns. Kopiera följande kod till MyFirebaseMessagingService.java. Du måste ersätta <your_package_name> med paketnamnet som används i MainActivity.java. Du kan använda ditt eget värde för <your_intent_name>. Det här värdet används i steg 6 nedan.

   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);
       }
   }

Lägg till följande importinstruktioner överst i filen MainActivity.java:

   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;

Lägg till följande kod i MainActivity klassen :

   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);
                       }
                   });
               }
           });
   }

Uppdatera funktionen onCreate i 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>"));
   }

Placera följande kod under kommentaren <RECEIVE CHAT MESSAGES> i 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
   });

Lägg till fältet xmlns:tools i AndroidManifest.xml filen:

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

Inaktivera standardinitieraren för WorkManager i 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 -->

Lägg till beroendet i WorkManagerbuild.gradle filen:

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

Lägg till en anpassad WorkManager initiering genom att skapa en klass som implementerar 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();
        }
    }

Förklaring till koden ovan: Standardinitieraren WorkManager för har inaktiverats i steg 9. Det här steget implementeras Configuration.Provider för att tillhandahålla en anpassad WorkFactory, som ansvarar för att skapa WorkerManager under körning.

Om appen är integrerad med Azure Function ska initiering av programparametrar läggas till i metoden "onCreate()". Metoden "getWorkManagerConfiguration()" anropas när programmet startas, innan några aktivitets-, tjänst- eller mottagarobjekt (exklusive innehållsleverantörer) har skapats, så att programparametrar kan initieras innan de används. Mer information finns i exempelchattappen.

Lägg till fältet android:name=.MyAppConfiguration , som använder klassnamnet från steg 11, i 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"
>

Aktivera push-meddelanden

Ytterligare resurser