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

package/android/src/main/java/expo/modules/notifications/notifications/categories/ExpoNotificationCategoriesModule.kt

@@ -0,0 +1,149 @@
+package expo.modules.notifications.notifications.categories
+
+import android.content.Context
+import android.os.Bundle
+import expo.modules.core.errors.InvalidArgumentException
+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.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.records.Required
+import expo.modules.notifications.ModuleNotFoundException
+import expo.modules.notifications.ResultReceiverBody
+import expo.modules.notifications.createDefaultResultReceiver
+import expo.modules.notifications.notifications.categories.serializers.NotificationsCategoriesSerializer
+import expo.modules.notifications.notifications.model.NotificationAction
+import expo.modules.notifications.notifications.model.NotificationCategory
+import expo.modules.notifications.notifications.model.TextInputNotificationAction
+import expo.modules.notifications.service.NotificationsService
+import expo.modules.notifications.service.NotificationsService.Companion.deleteCategory
+import expo.modules.notifications.service.NotificationsService.Companion.getCategories
+import expo.modules.notifications.service.NotificationsService.Companion.setCategory
+
+class NotificationActionRecord : Record {
+  @Field
+  @Required
+  val identifier: String = ""
+
+  @Field
+  @Required
+  val buttonTitle: String = ""
+
+  @Field
+  val textInput: TextInput? = null
+
+  @Field
+  val options = Options()
+
+  class TextInput : Record {
+    @Field
+    @Required
+    val placeholder: String = ""
+  }
+
+  class Options : Record {
+    @Field
+    val opensAppToForeground = true
+  }
+}
+
+open class ExpoNotificationCategoriesModule : Module() {
+
+  protected val serializer by lazy {
+    appContext.legacyModule<NotificationsCategoriesSerializer>()
+      ?: throw ModuleNotFoundException(NotificationsCategoriesSerializer::class)
+  }
+
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationCategoriesModule")
+
+    AsyncFunction("getNotificationCategoriesAsync") { promise: Promise ->
+      getCategories(
+        context,
+        createResultReceiver { resultCode: Int, resultData: Bundle? ->
+          val categories = resultData?.getParcelableArrayList<NotificationCategory>(NotificationsService.NOTIFICATION_CATEGORIES_KEY)
+          if (resultCode == NotificationsService.SUCCESS_CODE && categories != null) {
+            promise.resolve(serializeCategories(categories))
+          } else {
+            promise.reject("ERR_CATEGORIES_FETCH_FAILED", "A list of notification categories could not be fetched.", null)
+          }
+        }
+      )
+    }
+
+    AsyncFunction("setNotificationCategoryAsync", this@ExpoNotificationCategoriesModule::setNotificationCategoryAsync)
+
+    AsyncFunction("deleteNotificationCategoryAsync", this@ExpoNotificationCategoriesModule::deleteNotificationCategoryAsync)
+  }
+
+  private fun createResultReceiver(body: ResultReceiverBody) =
+    createDefaultResultReceiver(null, body)
+
+  open fun setNotificationCategoryAsync(
+    identifier: String,
+    actionArguments: List<NotificationActionRecord>,
+    categoryOptions: Map<String, Any?>?,
+    promise: Promise
+  ) {
+    val actions = mutableListOf<NotificationAction>()
+    for (actionMap in actionArguments) {
+      val textInputOptions = actionMap.textInput
+      if (textInputOptions != null) {
+        actions.add(
+          TextInputNotificationAction(
+            actionMap.identifier,
+            actionMap.buttonTitle,
+            actionMap.options.opensAppToForeground,
+            textInputOptions.placeholder
+          )
+        )
+      } else {
+        actions.add(
+          NotificationAction(
+            actionMap.identifier,
+            actionMap.buttonTitle,
+            actionMap.options.opensAppToForeground,
+          )
+        )
+      }
+    }
+    if (actions.isEmpty()) {
+      throw InvalidArgumentException("Invalid arguments provided for notification category. Must provide at least one action.")
+    }
+    setCategory(
+      context,
+      NotificationCategory(identifier, actions),
+      createResultReceiver { resultCode: Int, resultData: Bundle? ->
+        val category = resultData?.getParcelable<NotificationCategory>(NotificationsService.NOTIFICATION_CATEGORY_KEY)
+        if (resultCode == NotificationsService.SUCCESS_CODE && category != null) {
+          promise.resolve(serializer.toBundle(category))
+        } else {
+          promise.reject("ERR_CATEGORY_SET_FAILED", "The provided category could not be set.", null)
+        }
+      }
+    )
+  }
+
+  open fun deleteNotificationCategoryAsync(identifier: String, promise: Promise) {
+    deleteCategory(
+      context,
+      identifier,
+      createResultReceiver { resultCode: Int, resultData: Bundle? ->
+        if (resultCode == NotificationsService.SUCCESS_CODE) {
+          promise.resolve(resultData?.getBoolean(NotificationsService.SUCCEEDED_KEY))
+        } else {
+          promise.reject("ERR_CATEGORY_DELETE_FAILED", "The category could not be deleted.", null)
+        }
+      }
+    )
+  }
+
+  protected open fun serializeCategories(categories: Collection<NotificationCategory>): List<Bundle?> {
+    return categories.map(serializer::toBundle)
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/categories/serializers/ExpoNotificationsCategoriesSerializer.java

@@ -0,0 +1,67 @@
+package expo.modules.notifications.notifications.categories.serializers;
+
+import android.os.Bundle;
+
+import expo.modules.core.interfaces.InternalModule;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.model.NotificationAction;
+import expo.modules.notifications.notifications.model.NotificationCategory;
+import expo.modules.notifications.notifications.model.TextInputNotificationAction;
+
+public class ExpoNotificationsCategoriesSerializer implements NotificationsCategoriesSerializer, InternalModule {
+  @Override
+  public List<? extends Class> getExportedInterfaces() {
+    return Collections.singletonList(NotificationsCategoriesSerializer.class);
+  }
+
+  @Nullable
+  @Override
+  public Bundle toBundle(@Nullable NotificationCategory category) {
+    if (category == null) {
+      return null;
+    }
+    Bundle serializedCategory = new Bundle();
+    serializedCategory.putString("identifier", getIdentifier(category));
+    serializedCategory.putParcelableArrayList("actions", toBundleList(category.getActions()));
+    // Android doesn't support any category options
+    serializedCategory.putBundle("options", new Bundle());
+    return serializedCategory;
+  }
+
+  protected String getIdentifier(@NonNull NotificationCategory category) {
+    return category.getIdentifier();
+  }
+
+  private ArrayList<Bundle> toBundleList(List<NotificationAction> actions) {
+    ArrayList<Bundle> result = new ArrayList<>();
+    for (NotificationAction action : actions) {
+      result.add(toBundle(action));
+    }
+    return result;
+  }
+
+  private Bundle toBundle(NotificationAction action) {
+    // First we bundle up the options
+    Bundle serializedActionOptions = new Bundle();
+    serializedActionOptions.putBoolean("opensAppToForeground", action.opensAppToForeground());
+
+    Bundle serializedAction = new Bundle();
+    serializedAction.putString("identifier", action.getIdentifier());
+    serializedAction.putString("buttonTitle", action.getTitle());
+    serializedAction.putBundle("options", serializedActionOptions);
+
+    if (action instanceof TextInputNotificationAction) {
+      Bundle serializedTextInputOptions = new Bundle();
+      serializedTextInputOptions.putString("placeholder", ((TextInputNotificationAction) action).getPlaceholder());
+      serializedAction.putBundle("textInput", serializedTextInputOptions);
+    }
+
+    return serializedAction;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/categories/serializers/NotificationsCategoriesSerializer.java

@@ -0,0 +1,11 @@
+package expo.modules.notifications.notifications.categories.serializers;
+
+import android.os.Bundle;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.model.NotificationCategory;
+
+public interface NotificationsCategoriesSerializer {
+  @Nullable
+  Bundle toBundle(@Nullable NotificationCategory category);
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/AbstractNotificationsChannelsProvider.java

@@ -0,0 +1,81 @@
+package expo.modules.notifications.notifications.channels;
+
+import android.content.Context;
+
+import expo.modules.core.ModuleRegistry;
+import expo.modules.core.interfaces.InternalModule;
+
+import java.util.Collections;
+import java.util.List;
+
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelGroupManager;
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelManager;
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer;
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer;
+
+public abstract class AbstractNotificationsChannelsProvider implements NotificationsChannelsProvider, InternalModule {
+  protected final Context mContext;
+  private NotificationsChannelManager mChannelManager;
+  private NotificationsChannelGroupManager mChannelGroupManager;
+  private NotificationsChannelSerializer mChannelSerializer;
+  private NotificationsChannelGroupSerializer mChannelGroupSerializer;
+
+  private ModuleRegistry mModuleRegistry;
+
+  public AbstractNotificationsChannelsProvider(Context context) {
+    mContext = context;
+  }
+
+  public List<? extends Class> getExportedInterfaces() {
+    return Collections.singletonList(NotificationsChannelsProvider.class);
+  }
+
+  @Override
+  public void onCreate(ModuleRegistry moduleRegistry) {
+    mModuleRegistry = moduleRegistry;
+  }
+
+  public final ModuleRegistry getModuleRegistry() {
+    return mModuleRegistry;
+  }
+
+  @Override
+  public final NotificationsChannelManager getChannelManager() {
+    if (mChannelManager == null) {
+      mChannelManager = createChannelManager();
+    }
+    return mChannelManager;
+  }
+
+  @Override
+  public final NotificationsChannelGroupManager getGroupManager() {
+    if (mChannelGroupManager == null) {
+      mChannelGroupManager = createChannelGroupManager();
+    }
+    return mChannelGroupManager;
+  }
+
+  @Override
+  public final NotificationsChannelSerializer getChannelSerializer() {
+    if (mChannelSerializer == null) {
+      mChannelSerializer = createChannelSerializer();
+    }
+    return mChannelSerializer;
+  }
+
+  @Override
+  public final NotificationsChannelGroupSerializer getGroupSerializer() {
+    if (mChannelGroupSerializer == null) {
+      mChannelGroupSerializer = createChannelGroupSerializer();
+    }
+    return mChannelGroupSerializer;
+  }
+
+  protected abstract NotificationsChannelManager createChannelManager();
+
+  protected abstract NotificationsChannelGroupManager createChannelGroupManager();
+
+  protected abstract NotificationsChannelSerializer createChannelSerializer();
+
+  protected abstract NotificationsChannelGroupSerializer createChannelGroupSerializer();
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/AndroidXNotificationsChannelsProvider.java

@@ -0,0 +1,38 @@
+package expo.modules.notifications.notifications.channels;
+
+import android.content.Context;
+
+import expo.modules.notifications.notifications.channels.managers.AndroidXNotificationsChannelGroupManager;
+import expo.modules.notifications.notifications.channels.managers.AndroidXNotificationsChannelManager;
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelGroupManager;
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelManager;
+import expo.modules.notifications.notifications.channels.serializers.ExpoNotificationsChannelGroupSerializer;
+import expo.modules.notifications.notifications.channels.serializers.ExpoNotificationsChannelSerializer;
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer;
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer;
+
+public class AndroidXNotificationsChannelsProvider extends AbstractNotificationsChannelsProvider {
+  public AndroidXNotificationsChannelsProvider(Context context) {
+    super(context);
+  }
+
+  @Override
+  protected NotificationsChannelManager createChannelManager() {
+    return new AndroidXNotificationsChannelManager(mContext, getGroupManager());
+  }
+
+  @Override
+  protected NotificationsChannelGroupManager createChannelGroupManager() {
+    return new AndroidXNotificationsChannelGroupManager(mContext);
+  }
+
+  @Override
+  protected NotificationsChannelSerializer createChannelSerializer() {
+    return new ExpoNotificationsChannelSerializer();
+  }
+
+  @Override
+  protected NotificationsChannelGroupSerializer createChannelGroupSerializer() {
+    return new ExpoNotificationsChannelGroupSerializer(getChannelSerializer());
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/InvalidVibrationPatternException.java

@@ -0,0 +1,14 @@
+package expo.modules.notifications.notifications.channels;
+
+import expo.modules.core.errors.CodedRuntimeException;
+
+public class InvalidVibrationPatternException extends CodedRuntimeException {
+  public InvalidVibrationPatternException(int invalidValueKey, Object invalidValue) {
+    super("Invalid value in vibration pattern, expected all elements to be numbers, got: " + invalidValue + " under " + invalidValueKey);
+  }
+
+  @Override
+  public String getCode() {
+    return "ERR_INVALID_VIBRATION_PATTERN";
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/NotificationChannelGroupManagerModule.kt

@@ -0,0 +1,70 @@
+package expo.modules.notifications.notifications.channels
+
+import android.os.Build
+import expo.modules.core.arguments.ReadableArguments
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ModuleNotFoundException
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelGroupManager
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer
+
+/**
+ * An exported module responsible for exposing methods for managing notification channel groups.
+ */
+class NotificationChannelGroupManagerModule : Module() {
+  private lateinit var groupManager: NotificationsChannelGroupManager
+  private lateinit var groupSerializer: NotificationsChannelGroupSerializer
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationChannelGroupManager")
+
+    OnCreate {
+      val provider = appContext.legacyModule<NotificationsChannelsProvider>()
+        ?: throw ModuleNotFoundException(NotificationsChannelsProvider::class)
+      groupManager = provider.groupManager
+      groupSerializer = provider.groupSerializer
+    }
+
+    AsyncFunction("getNotificationChannelGroupAsync") { groupId: String ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val group = groupManager.getNotificationChannelGroup(groupId)
+        groupSerializer.toBundle(group)
+      } else {
+        null
+      }
+    }
+
+    AsyncFunction("getNotificationChannelGroupsAsync") {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        groupManager
+          .notificationChannelGroups
+          .map(groupSerializer::toBundle)
+      } else {
+        null
+      }
+    }
+
+    AsyncFunction("setNotificationChannelGroupAsync") { groupId: String, groupOptions: ReadableArguments ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val group = groupManager.createNotificationChannelGroup(
+          groupId,
+          getNameFromOptions(groupOptions),
+          groupOptions
+        )
+        groupSerializer.toBundle(group)
+      } else {
+        null
+      }
+    }
+
+    AsyncFunction("deleteNotificationChannelGroupAsync") { groupId: String ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        groupManager.deleteNotificationChannelGroup(groupId)
+      }
+    }
+  }
+
+  private fun getNameFromOptions(groupOptions: ReadableArguments): String {
+    return groupOptions.getString(NotificationsChannelGroupSerializer.NAME_KEY)
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/NotificationChannelManagerModule.kt

@@ -0,0 +1,83 @@
+package expo.modules.notifications.notifications.channels
+
+import android.os.Build
+import android.os.Bundle
+import androidx.annotation.RequiresApi
+import expo.modules.core.arguments.ReadableArguments
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ModuleNotFoundException
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelManager
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer
+import expo.modules.notifications.notifications.enums.NotificationImportance
+import java.util.Objects
+
+/**
+ * An exported module responsible for exposing methods for managing notification channels.
+ */
+open class NotificationChannelManagerModule : Module() {
+  private lateinit var channelManager: NotificationsChannelManager
+  private lateinit var channelSerializer: NotificationsChannelSerializer
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationChannelManager")
+
+    OnCreate {
+      val provider = appContext.legacyModule<NotificationsChannelsProvider>()
+        ?: throw ModuleNotFoundException(NotificationsChannelsProvider::class)
+
+      channelManager = provider.channelManager
+      channelSerializer = provider.channelSerializer
+    }
+
+    AsyncFunction("getNotificationChannelsAsync") {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+        return@AsyncFunction emptyList<Bundle>()
+      }
+
+      return@AsyncFunction channelManager
+        .notificationChannels
+        .map(channelSerializer::toBundle)
+    }
+
+    AsyncFunction("getNotificationChannelAsync") { channelId: String ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val notificationChannel = channelManager.getNotificationChannel(channelId)
+        channelSerializer.toBundle(notificationChannel)
+      } else {
+        null
+      }
+    }
+
+    AsyncFunction("setNotificationChannelAsync") { channelId: String, channelOptions: ReadableArguments ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        val channel = channelManager.createNotificationChannel(
+          channelId,
+          getNameFromOptions(channelOptions),
+          getImportanceFromOptions(channelOptions),
+          channelOptions
+        )
+        channelSerializer.toBundle(channel)
+      } else {
+        null
+      }
+    }
+
+    AsyncFunction("deleteNotificationChannelAsync") { channelId: String ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        channelManager.deleteNotificationChannel(channelId)
+      }
+    }
+  }
+
+  private fun getNameFromOptions(channelOptions: ReadableArguments): CharSequence {
+    return channelOptions.getString(NotificationsChannelSerializer.NAME_KEY)
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  private fun getImportanceFromOptions(channelOptions: ReadableArguments): Int {
+    val enumValue = channelOptions.getInt(NotificationsChannelSerializer.IMPORTANCE_KEY, NotificationImportance.DEFAULT.enumValue)
+    val importance = Objects.requireNonNull(NotificationImportance.fromEnumValue(enumValue))
+    return importance.nativeValue
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/NotificationsChannelsProvider.java

@@ -0,0 +1,13 @@
+package expo.modules.notifications.notifications.channels;
+
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelGroupManager;
+import expo.modules.notifications.notifications.channels.managers.NotificationsChannelManager;
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer;
+import expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer;
+
+public interface NotificationsChannelsProvider {
+  NotificationsChannelManager getChannelManager();
+  NotificationsChannelGroupManager getGroupManager();
+  NotificationsChannelSerializer getChannelSerializer();
+  NotificationsChannelGroupSerializer getGroupSerializer();
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/managers/AndroidXNotificationsChannelGroupManager.java

@@ -0,0 +1,67 @@
+package expo.modules.notifications.notifications.channels.managers;
+
+import android.app.NotificationChannelGroup;
+import android.content.Context;
+import android.os.Build;
+
+import expo.modules.core.arguments.ReadableArguments;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationManagerCompat;
+
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelGroupSerializer.DESCRIPTION_KEY;
+
+public class AndroidXNotificationsChannelGroupManager implements NotificationsChannelGroupManager {
+  private final NotificationManagerCompat mNotificationManager;
+
+  public AndroidXNotificationsChannelGroupManager(Context context) {
+    mNotificationManager = NotificationManagerCompat.from(context);
+  }
+
+  @Nullable
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public NotificationChannelGroup getNotificationChannelGroup(@NonNull String channelGroupId) {
+    return mNotificationManager.getNotificationChannelGroup(channelGroupId);
+  }
+
+  @NonNull
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public List<NotificationChannelGroup> getNotificationChannelGroups() {
+    return mNotificationManager.getNotificationChannelGroups();
+  }
+
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public NotificationChannelGroup createNotificationChannelGroup(@NonNull String groupId, @NonNull CharSequence name, ReadableArguments groupOptions) {
+    NotificationChannelGroup group = new NotificationChannelGroup(groupId, name);
+    configureGroupWithOptions(group, groupOptions);
+    mNotificationManager.createNotificationChannelGroup(group);
+    return group;
+  }
+
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public void deleteNotificationChannelGroup(@NonNull String groupId) {
+     mNotificationManager.deleteNotificationChannelGroup(groupId);
+  }
+
+  // Processing options
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  protected void configureGroupWithOptions(Object maybeGroup, ReadableArguments groupOptions) {
+    if (!(maybeGroup instanceof NotificationChannelGroup)) {
+      return;
+    }
+    NotificationChannelGroup group = (NotificationChannelGroup) maybeGroup;
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      if (groupOptions.containsKey(DESCRIPTION_KEY)) {
+        group.setDescription(groupOptions.getString(DESCRIPTION_KEY));
+      }
+    }
+  }
+}