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

package/android/src/main/java/expo/modules/notifications/notifications/enums/NotificationImportance.java

@@ -0,0 +1,48 @@
+package expo.modules.notifications.notifications.enums;
+
+import androidx.core.app.NotificationManagerCompat;
+
+public enum NotificationImportance {
+  UNSPECIFIED(NotificationManagerCompat.IMPORTANCE_UNSPECIFIED, 1),
+  NONE(NotificationManagerCompat.IMPORTANCE_NONE, 2),
+  MIN(NotificationManagerCompat.IMPORTANCE_MIN, 3),
+  LOW(NotificationManagerCompat.IMPORTANCE_LOW, 4),
+  DEFAULT(NotificationManagerCompat.IMPORTANCE_DEFAULT, 5),
+  HIGH(NotificationManagerCompat.IMPORTANCE_HIGH, 6),
+  MAX(NotificationManagerCompat.IMPORTANCE_MAX, 7),
+  UNKNOWN(NotificationManagerCompat.IMPORTANCE_DEFAULT, 0);
+
+  private final int mNativeImportance;
+  private final int mEnumValue;
+
+  NotificationImportance(int nativeImportance, int enumValue) {
+    mNativeImportance = nativeImportance;
+    mEnumValue = enumValue;
+  }
+
+  public int getNativeValue() {
+    return mNativeImportance;
+  }
+
+  public int getEnumValue() {
+    return mEnumValue;
+  }
+
+  public static NotificationImportance fromEnumValue(int value) {
+    for (NotificationImportance importance : NotificationImportance.values()) {
+      if (importance.getEnumValue() == value) {
+        return importance;
+      }
+    }
+    return NotificationImportance.UNKNOWN;
+  }
+
+  public static NotificationImportance fromNativeValue(int value) {
+    for (NotificationImportance importance : NotificationImportance.values()) {
+      if (importance.getNativeValue() == value) {
+        return importance;
+      }
+    }
+    return NotificationImportance.UNKNOWN;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/enums/NotificationPriority.java

@@ -0,0 +1,51 @@
+package expo.modules.notifications.notifications.enums;
+
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+
+/**
+ * An enum allowing easy conversion between platform enum and native priority.
+ */
+public enum NotificationPriority {
+  MIN(NotificationCompat.PRIORITY_MIN, "min"),
+  LOW(NotificationCompat.PRIORITY_LOW, "low"),
+  DEFAULT(NotificationCompat.PRIORITY_DEFAULT, "default"),
+  HIGH(NotificationCompat.PRIORITY_HIGH, "high"),
+  MAX(NotificationCompat.PRIORITY_MAX, "max");
+
+  private final int mNativePriority;
+  private final String mEnumValue;
+
+  NotificationPriority(int nativePriority, String enumValue) {
+    mNativePriority = nativePriority;
+    mEnumValue = enumValue;
+  }
+
+  public int getNativeValue() {
+    return mNativePriority;
+  }
+
+  public String getEnumValue() {
+    return mEnumValue;
+  }
+
+  @Nullable
+  public static NotificationPriority fromEnumValue(String value) {
+    for (NotificationPriority priority : NotificationPriority.values()) {
+      if (priority.getEnumValue().equalsIgnoreCase(value)) {
+        return priority;
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  public static NotificationPriority fromNativeValue(int value) {
+    for (NotificationPriority priority : NotificationPriority.values()) {
+      if (priority.getNativeValue() == value) {
+        return priority;
+      }
+    }
+    return null;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/enums/NotificationVisibility.java

@@ -0,0 +1,44 @@
+package expo.modules.notifications.notifications.enums;
+
+import android.app.Notification;
+
+public enum NotificationVisibility {
+  PUBLIC(Notification.VISIBILITY_PUBLIC, 1),
+  PRIVATE(Notification.VISIBILITY_PRIVATE, 2),
+  SECRET(Notification.VISIBILITY_SECRET, 3),
+  UNKNOWN(Notification.VISIBILITY_PUBLIC, 0);
+
+  private final int mNativeVisibility;
+  private final int mEnumValue;
+
+  NotificationVisibility(int nativeVisibility, int enumValue) {
+    mNativeVisibility = nativeVisibility;
+    mEnumValue = enumValue;
+  }
+
+  public int getNativeValue() {
+    return mNativeVisibility;
+  }
+
+  public int getEnumValue() {
+    return mEnumValue;
+  }
+
+  public static NotificationVisibility fromEnumValue(int value) {
+    for (NotificationVisibility visibility : NotificationVisibility.values()) {
+      if (visibility.getEnumValue() == value) {
+        return visibility;
+      }
+    }
+    return NotificationVisibility.UNKNOWN;
+  }
+
+  public static NotificationVisibility fromNativeValue(int value) {
+    for (NotificationVisibility visibility : NotificationVisibility.values()) {
+      if (visibility.getNativeValue() == value) {
+        return visibility;
+      }
+    }
+    return NotificationVisibility.UNKNOWN;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/handling/NotificationsHandler.kt

@@ -0,0 +1,127 @@
+package expo.modules.notifications.notifications.handling
+
+import android.os.Handler
+import android.os.HandlerThread
+import expo.modules.core.ModuleRegistry
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.notifications.NotificationWasAlreadyHandledException
+import expo.modules.notifications.notifications.interfaces.NotificationListener
+import expo.modules.notifications.notifications.interfaces.NotificationManager
+import expo.modules.notifications.notifications.model.Notification
+import expo.modules.notifications.notifications.model.NotificationBehavior
+import expo.modules.notifications.toLegacyPromise
+
+class NotificationBehaviourRecord : Record {
+  @Field
+  val shouldShowAlert: Boolean = false
+
+  @Field
+  val shouldPlaySound: Boolean = false
+
+  @Field
+  val shouldSetBadge: Boolean = false
+
+  @Field
+  val priority: String? = null
+}
+
+/**
+ * [NotificationListener] responsible for managing app's reaction to incoming
+ * notification.
+ *
+ *
+ * It is responsible for managing lifecycles of [SingleNotificationHandlerTask]s
+ * which are responsible: one for each notification. This module serves as holder
+ * for all of them and a proxy through which app responds with the behavior.
+ */
+open class NotificationsHandler : Module(), NotificationListener {
+  private lateinit var notificationManager: NotificationManager
+  private lateinit var moduleRegistry: ModuleRegistry
+
+  /**
+   * [HandlerThread] which is the host to the notifications handler.
+   */
+  private lateinit var notificationsHandlerThread: HandlerThread
+
+  /**
+   * [Handler] on which lifecycle events are executed.
+   */
+  private lateinit var handler: Handler
+
+  private val tasksMap = mutableMapOf<String, SingleNotificationHandlerTask>()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationsHandlerModule")
+
+    OnCreate {
+      moduleRegistry = appContext.legacyModuleRegistry
+
+      // Register the module as a listener in NotificationManager singleton module.
+      // Deregistration happens in onDestroy callback.
+      notificationManager = requireNotNull(moduleRegistry.getSingletonModule("NotificationManager", NotificationManager::class.java))
+      notificationManager.addListener(this@NotificationsHandler)
+      notificationsHandlerThread = HandlerThread("NotificationsHandlerThread - " + this.javaClass.toString())
+      notificationsHandlerThread.start()
+      handler = Handler(notificationsHandlerThread.looper)
+    }
+
+    OnDestroy {
+      notificationManager.removeListener(this@NotificationsHandler)
+
+      tasksMap.values.forEach(SingleNotificationHandlerTask::stop)
+
+      // We don't have to use `quitSafely` here, cause all tasks were stopped
+      notificationsHandlerThread.quit()
+    }
+
+    AsyncFunction("handleNotificationAsync", this@NotificationsHandler::handleNotificationAsync)
+  }
+
+  /**
+   * Called by the app with [NotificationBehaviourRecord] representing requested behavior
+   * that should be applied to the notification.
+   *
+   * @param identifier Identifier of the task which asked for behavior.
+   * @param behavior   Behavior to apply to the notification.
+   * @param promise    Promise to resolve once the notification is successfully presented
+   * or fails to be presented.
+   */
+  private fun handleNotificationAsync(identifier: String, behavior: NotificationBehaviourRecord, promise: Promise) {
+    val task = tasksMap[identifier]
+      ?: throw NotificationWasAlreadyHandledException(identifier)
+
+    with(behavior) {
+      task.handleResponse(
+        NotificationBehavior(shouldShowAlert, shouldPlaySound, shouldSetBadge, priority),
+        promise.toLegacyPromise()
+      )
+    }
+  }
+
+  /**
+   * Callback called by [NotificationManager] to inform its listeners of new messages.
+   * Starts up a new [SingleNotificationHandlerTask] which will take it on from here.
+   *
+   * @param notification Notification received
+   */
+  override fun onNotificationReceived(notification: Notification) {
+    val context = appContext.reactContext ?: return
+    val task = SingleNotificationHandlerTask(context, handler, moduleRegistry, notification, this)
+    tasksMap[task.identifier] = task
+    task.start()
+  }
+
+  /**
+   * Callback called once [SingleNotificationHandlerTask] finishes.
+   * A cue for removal of the task.
+   *
+   * @param task Task that just fulfilled its responsibility.
+   */
+  fun onTaskFinished(task: SingleNotificationHandlerTask) {
+    tasksMap.remove(task.identifier)
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/handling/SingleNotificationHandlerTask.java

@@ -0,0 +1,131 @@
+package expo.modules.notifications.notifications.handling;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.ResultReceiver;
+
+import expo.modules.core.ModuleRegistry;
+import expo.modules.core.Promise;
+import expo.modules.core.interfaces.services.EventEmitter;
+
+import expo.modules.notifications.notifications.NotificationSerializer;
+import expo.modules.notifications.notifications.model.Notification;
+import expo.modules.notifications.notifications.model.NotificationBehavior;
+import expo.modules.notifications.service.NotificationsService;
+
+/**
+ * A "task" responsible for managing response to a single notification.
+ */
+public class SingleNotificationHandlerTask {
+  /**
+   * Name of the event asking the delegate for behavior.
+   */
+  private final static String HANDLE_NOTIFICATION_EVENT_NAME = "onHandleNotification";
+  /**
+   * Name of the event emitted if the delegate doesn't respond in time.
+   */
+  private final static String HANDLE_NOTIFICATION_TIMEOUT_EVENT_NAME = "onHandleNotificationTimeout";
+
+  /**
+   * Seconds since sending the {@link #HANDLE_NOTIFICATION_EVENT_NAME} until the task
+   * is considered timed out.
+   */
+  private final static int SECONDS_TO_TIMEOUT = 3;
+
+  private Handler mHandler;
+  private EventEmitter mEventEmitter;
+  private Notification mNotification;
+  private NotificationBehavior mBehavior;
+  private Context mContext;
+  private NotificationsHandler mDelegate;
+
+  private Runnable mTimeoutRunnable = SingleNotificationHandlerTask.this::handleTimeout;
+
+  /* package */ SingleNotificationHandlerTask(Context context, Handler handler, ModuleRegistry moduleRegistry, Notification notification, NotificationsHandler delegate) {
+    mContext = context;
+    mHandler = handler;
+    mEventEmitter = moduleRegistry.getModule(EventEmitter.class);
+    mNotification = notification;
+    mDelegate = delegate;
+  }
+
+  /**
+   * @return Identifier of the task.
+   */
+  /* package */ String getIdentifier() {
+    return mNotification.getNotificationRequest().getIdentifier();
+  }
+
+  /**
+   * Starts the task, i.e. sends an event to the app's delegate and starts a timeout
+   * after which the task finishes itself.
+   */
+  /* package */ void start() {
+    Bundle eventBody = new Bundle();
+    eventBody.putString("id", getIdentifier());
+    eventBody.putBundle("notification", NotificationSerializer.toBundle(mNotification));
+    mEventEmitter.emit(HANDLE_NOTIFICATION_EVENT_NAME, eventBody);
+
+    mHandler.postDelayed(mTimeoutRunnable, SECONDS_TO_TIMEOUT * 1000);
+  }
+
+  /**
+   * Stops the task abruptly (in case the app is being destroyed and there is no reason
+   * to wait for the response anymore).
+   */
+  /* package */ void stop() {
+    finish();
+  }
+
+  /**
+   * Informs the task of a response - behavior requested by the app.
+   *
+   * @param behavior Behavior requested by the app
+   * @param promise  Promise to fulfill once the behavior is applied to the notification.
+   */
+  /* package */ void handleResponse(NotificationBehavior behavior, final Promise promise) {
+    mBehavior = behavior;
+    mHandler.post(new Runnable() {
+      @Override
+      public void run() {
+        NotificationsService.Companion.present(mContext, mNotification, mBehavior, new ResultReceiver(mHandler) {
+          @Override
+          protected void onReceiveResult(int resultCode, Bundle resultData) {
+            super.onReceiveResult(resultCode, resultData);
+            if (resultCode == NotificationsService.SUCCESS_CODE) {
+              promise.resolve(null);
+            } else {
+              Exception e = (Exception) resultData.getSerializable(NotificationsService.EXCEPTION_KEY);
+              promise.reject("ERR_NOTIFICATION_PRESENTATION_FAILED", "Notification presentation failed.", e);
+            }
+          }
+        });
+        finish();
+      }
+    });
+  }
+
+  /**
+   * Callback called by {@link #mTimeoutRunnable} after timeout time elapses.
+   * <p>
+   * Sends a timeout event to the app.
+   */
+  private void handleTimeout() {
+    Bundle eventBody = new Bundle();
+    eventBody.putString("id", getIdentifier());
+    eventBody.putBundle("notification", NotificationSerializer.toBundle(mNotification));
+    mEventEmitter.emit(HANDLE_NOTIFICATION_TIMEOUT_EVENT_NAME, eventBody);
+
+    finish();
+  }
+
+  /**
+   * Callback called when the task fulfills its responsibility. Clears up {@link #mHandler}
+   * and informs {@link #mDelegate} of the task's state.
+   */
+  private void finish() {
+    mHandler.removeCallbacks(mTimeoutRunnable);
+    mDelegate.onTaskFinished(this);
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/interfaces/NotificationBuilder.java

@@ -0,0 +1,35 @@
+package expo.modules.notifications.notifications.interfaces;
+
+import expo.modules.notifications.notifications.model.Notification;
+import expo.modules.notifications.notifications.model.NotificationBehavior;
+import expo.modules.notifications.notifications.model.NotificationContent;
+
+/**
+ * An object capable of building a {@link Notification} based
+ * on a {@link NotificationContent} spec.
+ */
+public interface NotificationBuilder {
+  /**
+   * Pass in a {@link Notification} based on which the Android notification should be based.
+   *
+   * @param notification {@link Notification} on which the notification should be based.
+   * @return The same instance of {@link NotificationBuilder} updated with the notification.
+   */
+  NotificationBuilder setNotification(Notification notification);
+
+  /**
+   * Pass in a {@link NotificationBehavior} if you want to override the behavior
+   * of the notification, i.e. whether it should show a heads-up alert, set badge, etc.
+   *
+   * @param behavior {@link NotificationBehavior} to which the presentation effect should conform.
+   * @return The same instance of {@link NotificationBuilder} updated with the remote message.
+   */
+  NotificationBuilder setAllowedBehavior(NotificationBehavior behavior);
+
+  /**
+   * Builds the Android notification based on passed in data.
+   *
+   * @return Built notification.
+   */
+  android.app.Notification build();
+}

package/android/src/main/java/expo/modules/notifications/notifications/interfaces/NotificationListener.java

@@ -0,0 +1,37 @@
+package expo.modules.notifications.notifications.interfaces;
+
+import com.google.firebase.messaging.FirebaseMessagingService;
+
+import expo.modules.notifications.notifications.model.Notification;
+import expo.modules.notifications.notifications.model.NotificationResponse;
+
+/**
+ * Interface used to register in {@link NotificationManager}
+ * and be notified of new message events.
+ */
+public interface NotificationListener {
+  /**
+   * Callback called when new notification is received.
+   *
+   * @param notification Notification received
+   */
+  default void onNotificationReceived(Notification notification) {
+  }
+
+  /**
+   * Callback called when new notification response is received.
+   *
+   * @param response Notification response received
+   * @return Whether the notification response has been handled
+   */
+  default boolean onNotificationResponseReceived(NotificationResponse response) {
+    return false;
+  }
+
+  /**
+   * Callback called when some notifications are dropped.
+   * See {@link FirebaseMessagingService#onDeletedMessages()}
+   */
+  default void onNotificationsDropped() {
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/interfaces/NotificationManager.java

@@ -0,0 +1,22 @@
+package expo.modules.notifications.notifications.interfaces;
+
+/**
+ * Interface of a singleton module responsible
+ * for dispatching new remote message events to {@link NotificationListener}s.
+ */
+public interface NotificationManager {
+  /**
+   * Registers a {@link NotificationListener}.
+   *
+   * @param listener Listener to be notified of new message events.
+   */
+  void addListener(NotificationListener listener);
+
+  /**
+   * Unregisters a {@link NotificationListener}.
+   *
+   * @param listener Listener previously registered
+   *                 with {@link NotificationManager#addListener(NotificationListener)}.
+   */
+  void removeListener(NotificationListener listener);
+}

package/android/src/main/java/expo/modules/notifications/notifications/interfaces/NotificationPresentationEffect.java

@@ -0,0 +1,11 @@
+package expo.modules.notifications.notifications.interfaces;
+
+import android.app.Notification;
+
+import androidx.annotation.Nullable;
+
+public interface NotificationPresentationEffect {
+  boolean onNotificationPresented(@Nullable String tag, int id, Notification notification);
+
+  boolean onNotificationPresentationFailed(@Nullable String tag, int id, Notification notification);
+}

package/android/src/main/java/expo/modules/notifications/notifications/interfaces/NotificationPresentationEffectsManager.java

@@ -0,0 +1,7 @@
+package expo.modules.notifications.notifications.interfaces;
+
+public interface NotificationPresentationEffectsManager extends NotificationPresentationEffect {
+  void addEffect(NotificationPresentationEffect effector);
+
+  void removeEffect(NotificationPresentationEffect effector);
+}

package/android/src/main/java/expo/modules/notifications/notifications/interfaces/NotificationTrigger.java

@@ -0,0 +1,19 @@
+package expo.modules.notifications.notifications.interfaces;
+
+import android.os.Build;
+import android.os.Parcelable;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+/**
+ * An interface specifying source of the notification, to be implemented
+ * by concrete classes.
+ */
+public interface NotificationTrigger extends Parcelable {
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  default String getNotificationChannel() {
+    return null;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/interfaces/SchedulableNotificationTrigger.java

@@ -0,0 +1,20 @@
+package expo.modules.notifications.notifications.interfaces;
+
+import java.io.Serializable;
+import java.util.Date;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.service.delegates.SharedPreferencesNotificationsStore;
+
+/**
+ * A notification trigger that is serializable - this ensures {@link SharedPreferencesNotificationsStore}
+ * is capable of storing it in the device's memory.
+ */
+public interface SchedulableNotificationTrigger extends NotificationTrigger, Serializable {
+  /**
+   * @return Next date at which the notification should be triggered. Returns `null`
+   * if the notification will not trigger in the future (it can be removed then).
+   */
+  @Nullable
+  Date nextTriggerDate();
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/Notification.java

@@ -0,0 +1,59 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.util.Date;
+
+/**
+ * A class representing a single notification received at a particular moment ({@link #mDate}).
+ */
+public class Notification implements Parcelable {
+  private NotificationRequest mRequest;
+  private Date mDate;
+
+  public Notification(NotificationRequest request) {
+    this(request, new Date());
+  }
+
+  public Notification(NotificationRequest request, Date date) {
+    mRequest = request;
+    mDate = date;
+  }
+
+  protected Notification(Parcel in) {
+    mRequest = in.readParcelable(getClass().getClassLoader());
+    mDate = new Date(in.readLong());
+  }
+
+  public Date getDate() {
+    return mDate;
+  }
+
+  public NotificationRequest getNotificationRequest() {
+    return mRequest;
+  }
+
+  public static final Creator<Notification> CREATOR = new Creator<Notification>() {
+    @Override
+    public Notification createFromParcel(Parcel in) {
+      return new Notification(in);
+    }
+
+    @Override
+    public Notification[] newArray(int size) {
+      return new Notification[size];
+    }
+  };
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeParcelable(mRequest, 0);
+    dest.writeLong(mDate.getTime());
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/NotificationAction.java

@@ -0,0 +1,63 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.io.Serializable;
+
+/**
+ * A class representing a single notification action button.
+ */
+public class NotificationAction implements Parcelable, Serializable {
+  private final String mIdentifier;
+  private final String mTitle;
+  private final boolean mOpensAppToForeground;
+
+  public NotificationAction(String identifier, String title, boolean opensAppToForeground) {
+    mIdentifier = identifier;
+    mTitle = title;
+    mOpensAppToForeground = opensAppToForeground;
+  }
+
+  protected NotificationAction(Parcel in) {
+    mIdentifier = in.readString();
+    mTitle = in.readString();
+    mOpensAppToForeground = in.readByte() != 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeString(mIdentifier);
+    dest.writeString(mTitle);
+    dest.writeByte((byte) (mOpensAppToForeground ? 1 : 0));
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  public static final Creator<NotificationAction> CREATOR = new Creator<NotificationAction>() {
+    @Override
+    public NotificationAction createFromParcel(Parcel in) {
+      return new NotificationAction(in);
+    }
+
+    @Override
+    public NotificationAction[] newArray(int size) {
+      return new NotificationAction[size];
+    }
+  };
+
+  public String getIdentifier() {
+    return mIdentifier;
+  }
+
+  public String getTitle() {
+    return mTitle;
+  }
+
+  public boolean opensAppToForeground() {
+    return mOpensAppToForeground;
+  }
+}