@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/android/src/main/java/expo/modules/notifications/notifications/model/triggers/FirebaseNotificationTrigger.java

@@ -0,0 +1,61 @@
+package expo.modules.notifications.notifications.model.triggers;
+
+import android.os.Build;
+import android.os.Parcel;
+
+import com.google.firebase.messaging.RemoteMessage;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import expo.modules.notifications.notifications.interfaces.NotificationTrigger;
+
+/**
+ * A trigger representing an incoming remote Firebase notification.
+ */
+public class FirebaseNotificationTrigger implements NotificationTrigger {
+  private RemoteMessage mRemoteMessage;
+
+  public FirebaseNotificationTrigger(RemoteMessage remoteMessage) {
+    mRemoteMessage = remoteMessage;
+  }
+
+  private FirebaseNotificationTrigger(Parcel in) {
+    mRemoteMessage = in.readParcelable(getClass().getClassLoader());
+  }
+
+  public RemoteMessage getRemoteMessage() {
+    return mRemoteMessage;
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeParcelable(mRemoteMessage, 0);
+  }
+
+  public static final Creator<FirebaseNotificationTrigger> CREATOR = new Creator<FirebaseNotificationTrigger>() {
+    @Override
+    public FirebaseNotificationTrigger createFromParcel(Parcel in) {
+      return new FirebaseNotificationTrigger(in);
+    }
+
+    @Override
+    public FirebaseNotificationTrigger[] newArray(int size) {
+      return new FirebaseNotificationTrigger[size];
+    }
+  };
+
+  @Nullable
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public String getNotificationChannel() {
+    if (getRemoteMessage().getData().containsKey("channelId")) {
+      return getRemoteMessage().getData().get("channelId");
+    }
+    return NotificationTrigger.super.getNotificationChannel();
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/presentation/ExpoNotificationPresentationEffectsManager.java

@@ -0,0 +1,63 @@
+package expo.modules.notifications.notifications.presentation;
+
+import android.app.Notification;
+import android.util.Log;
+
+import expo.modules.core.interfaces.InternalModule;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.interfaces.NotificationPresentationEffect;
+import expo.modules.notifications.notifications.interfaces.NotificationPresentationEffectsManager;
+
+public class ExpoNotificationPresentationEffectsManager implements InternalModule, NotificationPresentationEffectsManager {
+  private Collection<NotificationPresentationEffect> mEffects = new ArrayList<>();
+
+  @Override
+  public List<? extends Class> getExportedInterfaces() {
+    return Collections.singletonList(NotificationPresentationEffectsManager.class);
+  }
+
+  @Override
+  public void addEffect(NotificationPresentationEffect effect) {
+    removeEffect(effect);
+    mEffects.add(effect);
+  }
+
+  @Override
+  public void removeEffect(NotificationPresentationEffect effect) {
+    mEffects.remove(effect);
+  }
+
+  @Override
+  public boolean onNotificationPresented(@Nullable String tag, int id, Notification notification) {
+    boolean anyActed = false;
+    for (NotificationPresentationEffect effect : mEffects) {
+      try {
+        anyActed = effect.onNotificationPresented(tag, id, notification) || anyActed;
+      } catch (Exception e) {
+        Log.w("expo-notifications", String.format("Notification presentation effector %s threw an exception for notification (%s, %d): %s", effect.getClass(), tag, id, e.getMessage()));
+        e.printStackTrace();
+      }
+    }
+    return anyActed;
+  }
+
+  @Override
+  public boolean onNotificationPresentationFailed(@Nullable String tag, int id, Notification notification) {
+    boolean anyActed = false;
+    for (NotificationPresentationEffect effect : mEffects) {
+      try {
+        anyActed = effect.onNotificationPresentationFailed(tag, id, notification) || anyActed;
+      } catch (Exception e) {
+        Log.w("expo-notifications", String.format("Notification presentation effector %s threw an exception for notification (%s, %d): %s", effect.getClass(), tag, id, e.getMessage()));
+        e.printStackTrace();
+      }
+    }
+    return anyActed;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/presentation/ExpoNotificationPresentationModule.kt

@@ -0,0 +1,113 @@
+package expo.modules.notifications.notifications.presentation
+
+import android.content.Context
+import android.os.Bundle
+import expo.modules.core.arguments.ReadableArguments
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ResultReceiverBody
+import expo.modules.notifications.createDefaultResultReceiver
+import expo.modules.notifications.notifications.ArgumentsNotificationContentBuilder
+import expo.modules.notifications.notifications.NotificationSerializer
+import expo.modules.notifications.notifications.interfaces.NotificationTrigger
+import expo.modules.notifications.notifications.model.Notification
+import expo.modules.notifications.notifications.model.NotificationContent
+import expo.modules.notifications.notifications.model.NotificationRequest
+import expo.modules.notifications.service.NotificationsService
+import expo.modules.notifications.service.NotificationsService.Companion.dismiss
+import expo.modules.notifications.service.NotificationsService.Companion.dismissAll
+import expo.modules.notifications.service.NotificationsService.Companion.getAllPresented
+import expo.modules.notifications.service.NotificationsService.Companion.present
+
+open class ExpoNotificationPresentationModule : Module() {
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  protected fun createResultReceiver(body: ResultReceiverBody) =
+    createDefaultResultReceiver(null, body)
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationPresenter")
+
+    AsyncFunction("presentNotificationAsync") { identifier: String, payload: ReadableArguments, promise: Promise ->
+      val content = ArgumentsNotificationContentBuilder(context).setPayload(payload).build()
+      val request = createNotificationRequest(identifier, content, null)
+      val notification = Notification(request)
+      present(
+        context,
+        notification,
+        null,
+        createResultReceiver { resultCode: Int, resultData: Bundle? ->
+          if (resultCode == NotificationsService.SUCCESS_CODE) {
+            promise.resolve(identifier)
+          } else {
+            val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+            promise.reject("ERR_NOTIFICATION_PRESENTATION_FAILED", "Notification could not be presented.", e)
+          }
+        }
+      )
+    }
+
+    AsyncFunction("getPresentedNotificationsAsync") { promise: Promise ->
+      getAllPresented(
+        context,
+        createResultReceiver { resultCode: Int, resultData: Bundle? ->
+          val notifications = resultData?.getParcelableArrayList<Notification>(NotificationsService.NOTIFICATIONS_KEY)
+          if (resultCode == NotificationsService.SUCCESS_CODE && notifications != null) {
+            promise.resolve(serializeNotifications(notifications))
+          } else {
+            val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+            promise.reject("ERR_NOTIFICATIONS_FETCH_FAILED", "A list of displayed notifications could not be fetched.", e)
+          }
+        }
+      )
+    }
+
+    AsyncFunction("dismissNotificationAsync", this@ExpoNotificationPresentationModule::dismissNotificationAsync)
+
+    AsyncFunction("dismissAllNotificationsAsync", this@ExpoNotificationPresentationModule::dismissAllNotificationsAsync)
+  }
+
+  protected open fun dismissNotificationAsync(identifier: String, promise: Promise) {
+    dismiss(
+      context,
+      arrayOf(identifier),
+      createResultReceiver { resultCode: Int, resultData: Bundle? ->
+        if (resultCode == NotificationsService.SUCCESS_CODE) {
+          promise.resolve(null)
+        } else {
+          val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+          promise.reject("ERR_NOTIFICATION_DISMISSAL_FAILED", "Notification could not be dismissed.", e)
+        }
+      }
+    )
+  }
+
+  protected open fun dismissAllNotificationsAsync(promise: Promise) {
+    dismissAll(
+      context,
+      createResultReceiver { resultCode: Int, resultData: Bundle? ->
+        if (resultCode == NotificationsService.SUCCESS_CODE) {
+          promise.resolve(null)
+        } else {
+          val e = resultData?.getSerializable(NotificationsService.EXCEPTION_KEY) as? Exception
+          promise.reject("ERR_NOTIFICATIONS_DISMISSAL_FAILED", "Notifications could not be dismissed.", e)
+        }
+      }
+    )
+  }
+
+  protected open fun createNotificationRequest(
+    identifier: String,
+    content: NotificationContent,
+    trigger: NotificationTrigger?
+  ): NotificationRequest {
+    return NotificationRequest(identifier, content, null)
+  }
+
+  protected open fun serializeNotifications(notifications: Collection<Notification>): List<Bundle> {
+    return notifications.map(NotificationSerializer::toBundle)
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/presentation/builders/BaseNotificationBuilder.java

@@ -0,0 +1,50 @@
+package expo.modules.notifications.notifications.presentation.builders;
+
+import android.content.Context;
+
+import expo.modules.notifications.notifications.interfaces.NotificationBuilder;
+import expo.modules.notifications.notifications.model.Notification;
+import expo.modules.notifications.notifications.model.NotificationBehavior;
+import expo.modules.notifications.notifications.model.NotificationContent;
+
+/**
+ * A foundation class for {@link NotificationBuilder} implementations. Takes care
+ * of accepting {@link #mNotification} and {@link #mNotificationBehavior}.
+ */
+public abstract class BaseNotificationBuilder implements NotificationBuilder {
+  private Notification mNotification;
+  private NotificationBehavior mNotificationBehavior;
+  private Context mContext;
+
+  protected BaseNotificationBuilder(Context context) {
+    mContext = context;
+  }
+
+  @Override
+  public NotificationBuilder setNotification(Notification notification) {
+    mNotification = notification;
+    return this;
+  }
+
+  @Override
+  public NotificationBuilder setAllowedBehavior(NotificationBehavior behavior) {
+    mNotificationBehavior = behavior;
+    return this;
+  }
+
+  protected Context getContext() {
+    return mContext;
+  }
+
+  protected Notification getNotification() {
+    return mNotification;
+  }
+
+  protected NotificationContent getNotificationContent() {
+    return getNotification().getNotificationRequest().getContent();
+  }
+
+  protected NotificationBehavior getNotificationBehavior() {
+    return mNotificationBehavior;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/presentation/builders/CategoryAwareNotificationBuilder.java

@@ -0,0 +1,80 @@
+package expo.modules.notifications.notifications.presentation.builders;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.util.Log;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.RemoteInput;
+import expo.modules.notifications.notifications.model.NotificationAction;
+import expo.modules.notifications.notifications.model.NotificationCategory;
+import expo.modules.notifications.notifications.model.NotificationContent;
+import expo.modules.notifications.notifications.model.TextInputNotificationAction;
+import expo.modules.notifications.service.NotificationsService;
+import expo.modules.notifications.service.delegates.SharedPreferencesNotificationCategoriesStore;
+
+public class CategoryAwareNotificationBuilder extends ExpoNotificationBuilder {
+  protected SharedPreferencesNotificationCategoriesStore mStore;
+
+  public CategoryAwareNotificationBuilder(Context context, @NonNull SharedPreferencesNotificationCategoriesStore store) {
+    super(context);
+    mStore = store;
+  }
+
+  @Override
+  protected NotificationCompat.Builder createBuilder() {
+    NotificationCompat.Builder builder = super.createBuilder();
+
+    NotificationContent content = getNotificationContent();
+
+    String categoryIdentifier = content.getCategoryId();
+    if (categoryIdentifier != null) {
+      addActionsToBuilder(builder, categoryIdentifier);
+    }
+
+    if (content.getBadgeCount() != null) {
+      builder.setNumber(content.getBadgeCount().intValue());
+    }
+    
+    return builder;
+  }
+
+  protected void addActionsToBuilder(NotificationCompat.Builder builder, @NonNull String categoryIdentifier) {
+    List<NotificationAction> actions = Collections.emptyList();
+      try {
+        NotificationCategory category = mStore.getNotificationCategory(categoryIdentifier);
+        if (category != null) {
+          actions = category.getActions();
+        }
+      } catch (ClassNotFoundException | IOException e) {
+        Log.e("expo-notifications", String.format("Could not read category with identifier: %s. %s", categoryIdentifier, e.getMessage()));
+        e.printStackTrace();
+      }
+      for (NotificationAction action : actions) {
+        if (action instanceof TextInputNotificationAction) {
+          builder.addAction(buildTextInputAction((TextInputNotificationAction) action));
+        } else {
+          builder.addAction(buildButtonAction(action));
+        }
+      }
+  }
+
+  protected NotificationCompat.Action buildButtonAction(@NonNull NotificationAction action) {
+    PendingIntent intent = NotificationsService.Companion.createNotificationResponseIntent(getContext(), getNotification(), action);
+    return new NotificationCompat.Action.Builder(super.getIcon(), action.getTitle(), intent).build();
+  }
+
+  protected NotificationCompat.Action buildTextInputAction(@NonNull TextInputNotificationAction action) {
+    PendingIntent intent = NotificationsService.Companion.createNotificationResponseIntent(getContext(), getNotification(), action);
+    RemoteInput remoteInput = new RemoteInput.Builder(NotificationsService.USER_TEXT_RESPONSE_KEY)
+      .setLabel(action.getPlaceholder())
+      .build();
+
+    return new NotificationCompat.Action.Builder(super.getIcon(), action.getTitle(), intent).addRemoteInput(remoteInput).build();
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/presentation/builders/ChannelAwareNotificationBuilder.java

@@ -0,0 +1,135 @@
+package expo.modules.notifications.notifications.presentation.builders;
+
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationCompat;
+import expo.modules.notifications.R;
+import expo.modules.notifications.notifications.channels.managers.AndroidXNotificationsChannelGroupManager;
+import expo.modules.notifications.notifications.channels.managers.AndroidXNotificationsChannelManager;
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelManager;
+import expo.modules.notifications.notifications.interfaces.NotificationTrigger;
+import expo.modules.notifications.notifications.model.NotificationRequest;
+
+/**
+ * A notification builder foundation capable of fetching and/or creating
+ * a notification channel to which the notification request should be posted.
+ */
+public abstract class ChannelAwareNotificationBuilder extends BaseNotificationBuilder {
+  private final static String FALLBACK_CHANNEL_ID = "expo_notifications_fallback_notification_channel";
+
+  // Behaviors we will want to impose on received notifications include
+  // being displayed as a heads-up notification. For that we will need
+  // a channel of high importance.
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  private final static int FALLBACK_CHANNEL_IMPORTANCE = NotificationManager.IMPORTANCE_HIGH;
+
+  public ChannelAwareNotificationBuilder(Context context) {
+    super(context);
+  }
+
+  protected NotificationCompat.Builder createBuilder() {
+    return new NotificationCompat.Builder(getContext(), getChannelId());
+  }
+
+  /**
+   * @return A {@link NotificationChannel}'s identifier to use for the notification.
+   */
+  protected String getChannelId() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      // Returning null on incompatible platforms won't be an error.
+      return null;
+    }
+
+    NotificationTrigger trigger = getTrigger();
+    if (trigger == null) {
+      Log.e("notifications", String.format("Couldn't get channel for the notifications - trigger is 'null'. Fallback to '%s' channel", FALLBACK_CHANNEL_ID));
+      return getFallbackNotificationChannel().getId();
+    }
+
+    String channelId = trigger.getNotificationChannel();
+    if (channelId == null) {
+      return getFallbackNotificationChannel().getId();
+    }
+
+    NotificationsChannelManager manager = getNotificationsChannelManager();
+    NotificationChannel channel = manager.getNotificationChannel(channelId);
+    if (channel == null) {
+      Log.e("notifications", String.format("Channel '%s' doesn't exists. Fallback to '%s' channel", channelId, FALLBACK_CHANNEL_ID));
+      return getFallbackNotificationChannel().getId();
+    }
+
+    return channel.getId();
+  }
+
+  @NonNull
+  protected NotificationsChannelManager getNotificationsChannelManager() {
+    return new AndroidXNotificationsChannelManager(getContext(), new AndroidXNotificationsChannelGroupManager(getContext()));
+  }
+
+  /**
+   * Fetches the fallback notification channel, and if it doesn't exist yet - creates it.
+   * <p>
+   * Returns null on {@link NotificationChannel}-incompatible platforms.
+   *
+   * @return Fallback {@link NotificationChannel} or null.
+   */
+  public NotificationChannel getFallbackNotificationChannel() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return null;
+    }
+
+    NotificationChannel channel = getNotificationManager().getNotificationChannel(FALLBACK_CHANNEL_ID);
+    if (channel != null) {
+      return channel;
+    }
+
+    return createFallbackChannel();
+  }
+
+  /**
+   * Creates a fallback channel of {@link #FALLBACK_CHANNEL_ID} ID, name fetched
+   * from Android resources ({@link #getFallbackChannelName()}
+   * and importance set by {@link #FALLBACK_CHANNEL_IMPORTANCE}.
+   *
+   * @return Newly created channel.
+   */
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  protected NotificationChannel createFallbackChannel() {
+    NotificationChannel channel = new NotificationChannel(FALLBACK_CHANNEL_ID, getFallbackChannelName(), FALLBACK_CHANNEL_IMPORTANCE);
+    channel.setShowBadge(true);
+    channel.enableVibration(true);
+    getNotificationManager().createNotificationChannel(channel);
+    return channel;
+  }
+
+  /**
+   * Fetches fallback channel name from Android resources. Overridable by Android resources system
+   * or subclassing.
+   *
+   * @return Name of the fallback channel
+   */
+  protected String getFallbackChannelName() {
+    return getContext().getString(R.string.expo_notifications_fallback_channel_name);
+  }
+
+  private NotificationManager getNotificationManager() {
+    return (NotificationManager) getContext().getSystemService(Context.NOTIFICATION_SERVICE);
+  }
+
+  @Nullable
+  private NotificationTrigger getTrigger() {
+    NotificationRequest request = getNotification().getNotificationRequest();
+    if (request == null) {
+      return null;
+    }
+
+    return request.getTrigger();
+  }
+}