Włączanie powiadomień push w systemie Android

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

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> nazwą pakietu używaną w pliku MainActivity.java. Możesz użyć własnej wartości dla elementu <your_intent_name>. Użyj tej wartości w kroku 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. 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 po komentarzu <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
   });

8. 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">

9. Wyłącz domyślny inicjalizator dla WorkManager w 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 -->

10. Dodaj zależność WorkManager do pliku build.gradle.

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

11. Dodaj niestandardowy inicjator WorkManager przez utworzenie klasy implementującej 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();
        }
    }

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

Jeśli aplikacja jest zintegrowana z funkcją platformy Azure, zainicjuj parametry aplikacji 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), dzięki czemu parametry aplikacji można zainicjować przed użyciem. Aby uzyskać więcej informacji, zobacz przykładową aplikację do czatu.

12. 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"
>

Powiązane artykuły

• Migruj powiadomienia push Android SDK do FCM v1
• Zarejestruj się do powiadomień push Android SDK przy użyciu FCM v1