Włączanie powiadomień wypychanych

  • Artykuł

Powiadomienia wypychane umożliwiają klientom powiadamianie o przychodzących wiadomościach i innych operacjach występujących w wątku czatu w sytuacjach, w których aplikacja mobilna nie jest uruchomiona na pierwszym planie. Azure Communication Services obsługuje listę zdarzeń, do których można zasubskrybować.

Uwaga

Powiadomienia wypychane czatu są obsługiwane w przypadku zestawu Android SDK w wersjach, począwszy od wersji 1.1.0-beta.4 i 1.1.0. Zaleca się używanie wersji 2.0.0 lub nowszej, ponieważ starsze wersje mają znany problem z odnawianiem rejestracji. Kroki od 8 do 12 są wymagane tylko w przypadku wersji równych lub większych niż 2.0.0.

  1. Skonfiguruj usługę Firebase Cloud Messaging dla projektu ChatQuickstart. Wykonaj kroki Create a Firebase project, , Add a Firebase configuration fileRegister your app with Firebase, Add Firebase SDKs to your appi Edit your app manifest w dokumentacji programu Firebase.

  2. Utwórz centrum powiadomień w ramach tej samej subskrypcji co zasób usług komunikacyjnych, skonfiguruj ustawienia usługi Firebase Cloud Messaging dla centrum i połącz Centrum powiadomień z zasobem usług Communication Services. Zobacz Aprowizowanie usługi Notification Hub.

  3. Utwórz nowy plik o nazwie MyFirebaseMessagingService.java w tym samym katalogu, w którym MainActivity.java się znajduje. Skopiuj następujący kod do MyFirebaseMessagingService.javapliku . Musisz zastąpić <your_package_name> ciąg nazwą pakietu używaną w elemencie MainActivity.java. Możesz użyć własnej wartości dla elementu <your_intent_name>. Ta wartość będzie używana w kroku 6 poniżej.

       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. W górnej części pliku MainActivity.javadodaj następujące instrukcje importowania:

       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. Dodaj następujący kod do MainActivity klasy :

       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. Zaktualizuj funkcję onCreate w pliku 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. Umieść następujący kod poniżej komentarza <RECEIVE CHAT MESSAGES> w pliku 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. xmlns:tools Dodaj pole do AndroidManifest.xml pliku:
    <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. Wyłącz domyślny inicjator dla elementu WorkManager w programie :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. WorkManager Dodaj zależność do build.gradle pliku:
    def work_version = "2.7.1"
    implementation "androidx.work:work-runtime:$work_version"
  1. Dodaj inicjator niestandardowy WorkManager , tworząc klasę implementując Configuration.Providerpolecenie :
    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();
        }
    }

Wyjaśnienie powyższego kodu: Domyślny inicjator elementu WorkManager został wyłączony w kroku 9. Ten krok implementuje Configuration.Provider w celu udostępnienia dostosowanego elementu "WorkFactory", który jest odpowiedzialny za tworzenie WorkerManager w czasie wykonywania.

Jeśli aplikacja jest zintegrowana z funkcją platformy Azure, inicjowanie parametrów aplikacji należy dodać w metodzie "onCreate()". Metoda "getWorkManagerConfiguration()" jest wywoływana, gdy aplikacja jest uruchamiana, przed utworzeniem jakichkolwiek obiektów działania, usługi lub odbiorcy (z wyłączeniem dostawców zawartości), aby można było zainicjować parametry aplikacji przed ich rozpoczęciem. Więcej szczegółów można znaleźć w przykładowej aplikacji do czatu.

  1. android:name=.MyAppConfiguration Dodaj pole , które używa nazwy klasy z kroku 11, do :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"
>