Udostępnij za pośrednictwem

Włącz powiadomienia push

  • 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 działa na pierwszym planie. Usługi Azure Communication Services obsługują 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 z zakresu od 8 do 12 są potrzebne tylko dla wersji równych lub większych niż 2.0.0.

  1. Skonfiguruj usługę Firebase Cloud Messaging dla projektu ChatQuickstart. Wykonaj krokiCreate a Firebase project, , Register your app with Firebase, Add Firebase SDKs to your appAdd a Firebase configuration filei 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 komunikacyjnych. Zobacz Aprowizowanie centrum powiadomień.

  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 pliku 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 WorkManager kodu: domyślny inicjator elementu 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 powinno zostać dodane w metodzie "onCreate()". Metoda "getWorkManagerConfiguration()" jest wywoływana, gdy aplikacja jest uruchamiana, przed utworzeniem jakichkolwiek obiektów działania, usługi lub odbiornika (z wyłączeniem dostawców zawartości), dzięki czemu parametry aplikacji można zainicjować przed rozpoczęciem użycia. 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 elementu 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"
>