expo-notifications 0.24.1 → 0.25.0

package/CHANGELOG.md

@@ -10,6 +10,24 @@
 
 ### 💡 Others
 
+## 0.25.0 — 2023-10-17
+
+### 🛠 Breaking changes
+
+- Dropped support for Android SDK 21 and 22. ([#24201](https://github.com/expo/expo/pull/24201) by [@behenate](https://github.com/behenate))
+
+### 🐛 Bug fixes
+
+- Send background notifications through when the app is in the foreground ([#24684](https://github.com/expo/expo/pull/24684) by [@kadikraman](https://github.com/kadikraman))
+
+### 💡 Others
+
+- Migrated codebase to use Expo Modules API. ([#24499](https://github.com/expo/expo/pull/24499) by [@lukmccall](https://github.com/lukmccall))
+
+## 0.24.2 — 2023-09-18
+
+_This version does not introduce any user-facing changes._
+
 ## 0.24.1 — 2023-09-15
 
 ### 💡 Others

package/android/build.gradle

@@ -3,15 +3,20 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '0.24.1'
-
-buildscript {
-  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-  if (expoModulesCorePlugin.exists()) {
-    apply from: expoModulesCorePlugin
-    applyKotlinExpoModulesCorePlugin()
+version = '0.25.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+if (expoModulesCorePlugin.exists()) {
+  apply from: expoModulesCorePlugin
+  applyKotlinExpoModulesCorePlugin()
+  // Remove this check, but keep the contents after SDK49 support is dropped
+  if (safeExtGet("expoProvidesDefaultConfig", false)) {
+    useExpoPublishing()
+    useCoreDependencies()
   }
+}
 
+buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
   ext.safeExtGet = { prop, fallback ->
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
@@ -35,23 +40,44 @@ buildscript {
   }
 }
 
-afterEvaluate {
-  publishing {
-    publications {
-      release(MavenPublication) {
-        from components.release
+// Remove this if and it's contents, when support for SDK49 is dropped
+if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+  afterEvaluate {
+    publishing {
+      publications {
+        release(MavenPublication) {
+          from components.release
+        }
       }
-    }
-    repositories {
-      maven {
-        url = mavenLocal().url
+      repositories {
+        maven {
+          url = mavenLocal().url
+        }
       }
     }
   }
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 33)
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    compileSdkVersion safeExtGet("compileSdkVersion", 33)
+
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 23)
+      targetSdkVersion safeExtGet("targetSdkVersion", 33)
+    }
+
+    publishing {
+      singleVariant("release") {
+        withSourcesJar()
+      }
+    }
+
+    lintOptions {
+      abortOnError false
+    }
+  }
 
   def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
   if (agpVersion.tokenize('.')[0].toInteger() < 8) {
@@ -67,34 +93,27 @@ android {
 
   namespace "expo.modules.notifications"
   defaultConfig {
-    minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 21
-    versionName '0.24.1'
+    versionName '0.25.0'
   }
 
-  lintOptions {
-    abortOnError false
-  }
-  publishing {
-    singleVariant("release") {
-      withSourcesJar()
-    }
-  }
   buildFeatures {
     buildConfig true
   }
 }
 
 dependencies {
-  implementation project(':expo-modules-core')
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  }
 
   api 'androidx.core:core:1.5.0'
   api 'androidx.lifecycle:lifecycle-runtime:2.2.0'
   api 'androidx.lifecycle:lifecycle-process:2.2.0'
   api 'androidx.lifecycle:lifecycle-common-java8:2.2.0'
 
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
 
   api 'com.google.firebase:firebase-messaging:22.0.0'
 

package/android/src/main/java/expo/modules/notifications/Exceptions.kt

@@ -0,0 +1,22 @@
+package expo.modules.notifications
+
+import expo.modules.kotlin.exception.CodedException
+import kotlin.reflect.KClass
+
+class ModuleNotFoundException(moduleClass: KClass<*>) :
+  CodedException(message = "$moduleClass module not found")
+
+class NotificationWasAlreadyHandledException(val id: String) : CodedException("Failed to handle notification $id, it has already been handled.")
+
+fun expo.modules.kotlin.Promise.toLegacyPromise(): expo.modules.core.Promise {
+  val newPromise = this
+  return object : expo.modules.core.Promise {
+    override fun resolve(value: Any?) {
+      newPromise.resolve(value)
+    }
+
+    override fun reject(c: String?, m: String?, e: Throwable?) {
+      newPromise.reject(c ?: "unknown", m, e)
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/NotificationsPackage.java

@@ -2,50 +2,20 @@ package expo.modules.notifications;
 
 import android.content.Context;
 
+import java.util.Arrays;
+import java.util.List;
+
 import expo.modules.core.BasePackage;
 import expo.modules.core.ExportedModule;
 import expo.modules.core.interfaces.InternalModule;
 import expo.modules.core.interfaces.SingletonModule;
-
-import java.util.Arrays;
-import java.util.List;
-
-import expo.modules.notifications.badge.BadgeModule;
-import expo.modules.notifications.serverregistration.ServerRegistrationModule;
 import expo.modules.notifications.notifications.NotificationManager;
-import expo.modules.notifications.notifications.background.ExpoBackgroundNotificationTasksModule;
 import expo.modules.notifications.notifications.categories.ExpoNotificationCategoriesModule;
 import expo.modules.notifications.notifications.categories.serializers.ExpoNotificationsCategoriesSerializer;
 import expo.modules.notifications.notifications.channels.AndroidXNotificationsChannelsProvider;
-import expo.modules.notifications.notifications.channels.NotificationChannelGroupManagerModule;
-import expo.modules.notifications.notifications.channels.NotificationChannelManagerModule;
-import expo.modules.notifications.notifications.emitting.NotificationsEmitter;
-import expo.modules.notifications.notifications.handling.NotificationsHandler;
-import expo.modules.notifications.notifications.presentation.ExpoNotificationPresentationModule;
-import expo.modules.notifications.notifications.scheduling.NotificationScheduler;
-import expo.modules.notifications.permissions.NotificationPermissionsModule;
 import expo.modules.notifications.tokens.PushTokenManager;
-import expo.modules.notifications.tokens.PushTokenModule;
 
 public class NotificationsPackage extends BasePackage {
-  @Override
-  public List<ExportedModule> createExportedModules(Context context) {
-    return Arrays.asList(
-      new BadgeModule(context),
-      new PushTokenModule(context),
-      new NotificationsEmitter(context),
-      new NotificationsHandler(context),
-      new NotificationScheduler(context),
-      new ServerRegistrationModule(context),
-      new NotificationPermissionsModule(context),
-      new NotificationChannelManagerModule(context),
-      new ExpoNotificationPresentationModule(context),
-      new NotificationChannelGroupManagerModule(context),
-      new ExpoNotificationCategoriesModule(context),
-      new ExpoBackgroundNotificationTasksModule(context)
-    );
-  }
-
   @Override
   public List<SingletonModule> createSingletonModules(Context context) {
     return Arrays.asList(

package/android/src/main/java/expo/modules/notifications/Utils.kt

@@ -0,0 +1,19 @@
+package expo.modules.notifications
+
+import android.os.Bundle
+import android.os.Handler
+import android.os.ResultReceiver
+
+typealias ResultReceiverBody = (resultCode: Int, resultData: Bundle?) -> Unit
+
+internal fun createDefaultResultReceiver(
+  handler: Handler?,
+  body: ResultReceiverBody,
+): ResultReceiver {
+  return object : ResultReceiver(handler) {
+    override fun onReceiveResult(resultCode: Int, resultData: Bundle?) {
+      super.onReceiveResult(resultCode, resultData)
+      body(resultCode, resultData)
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/badge/BadgeHelper.kt

@@ -0,0 +1,24 @@
+package expo.modules.notifications.badge
+
+import android.content.Context
+import android.util.Log
+import me.leolin.shortcutbadger.ShortcutBadgeException
+import me.leolin.shortcutbadger.ShortcutBadger
+
+object BadgeHelper {
+  var badgeCount = 0
+    get() = synchronized(this) { field }
+    private set(value) = synchronized(this) { field = value }
+
+  fun setBadgeCount(context: Context, badgeCount: Int): Boolean {
+    return try {
+      ShortcutBadger.applyCountOrThrow(context.applicationContext, badgeCount)
+      BadgeHelper.badgeCount = badgeCount
+      true
+    } catch (e: ShortcutBadgeException) {
+      Log.d("expo-notifications", "Could not have set badge count: ${e.message}", e)
+      e.printStackTrace()
+      false
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/badge/BadgeModule.kt

@@ -1,37 +1,22 @@
 package expo.modules.notifications.badge
 
-import android.content.Context
-import android.util.Log
-import expo.modules.core.ExportedModule
-import expo.modules.core.Promise
-import expo.modules.core.interfaces.ExpoMethod
-import me.leolin.shortcutbadger.ShortcutBadgeException
-import me.leolin.shortcutbadger.ShortcutBadger
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
 
-class BadgeModule(context: Context) : ExportedModule(context) {
-  override fun getName(): String = "ExpoBadgeModule"
+class BadgeModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoBadgeModule")
 
-  @ExpoMethod
-  fun getBadgeCountAsync(promise: Promise) {
-    promise.resolve(badgeCount)
-  }
-
-  @ExpoMethod
-  fun setBadgeCountAsync(badgeCount: Int, promise: Promise) {
-    try {
-      ShortcutBadger.applyCountOrThrow(context.applicationContext, badgeCount)
-      BadgeModule.badgeCount = badgeCount
-      promise.resolve(true)
-    } catch (e: ShortcutBadgeException) {
-      Log.d("expo-notifications", "Could not have set badge count: ${e.message}", e)
-      e.printStackTrace()
-      promise.resolve(false)
+    AsyncFunction("getBadgeCountAsync") {
+      BadgeHelper.badgeCount
     }
-  }
 
-  companion object {
-    var badgeCount = 0
-      get() = synchronized(this) { field }
-      set(value) = synchronized(this) { field = value }
+    AsyncFunction("setBadgeCountAsync") { badgeCount: Int ->
+      BadgeHelper.setBadgeCount(
+        appContext.reactContext ?: throw Exceptions.ReactContextLost(),
+        badgeCount
+      )
+    }
   }
 }

package/android/src/main/java/expo/modules/notifications/notifications/background/BackgroundRemoteNotificationTaskConsumer.java

@@ -7,9 +7,6 @@ import android.os.Bundle;
 import android.os.PersistableBundle;
 import android.util.Log;
 
-import androidx.lifecycle.Lifecycle;
-import androidx.lifecycle.ProcessLifecycleOwner;
-
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -26,7 +23,7 @@ import expo.modules.interfaces.taskManager.TaskInterface;
 import expo.modules.interfaces.taskManager.TaskManagerUtilsInterface;
 
 /**
- * Represents a task to be run when the app is backgrounded and receives a remote push
+ * Represents a task to be run when the app is receives a remote push
  * notification. Map of current tasks is maintained in {@link FirebaseMessagingDelegate}.
  */
 public class BackgroundRemoteNotificationTaskConsumer extends TaskConsumer implements TaskConsumerInterface {
@@ -59,9 +56,8 @@ public class BackgroundRemoteNotificationTaskConsumer extends TaskConsumer imple
 
   public void scheduleJob(Bundle bundle) {
     Context context = getContext();
-    boolean isInForeground = ProcessLifecycleOwner.get().getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.RESUMED);
 
-    if (context != null && mTask != null && !isInForeground) {
+    if (context != null && mTask != null) {
       PersistableBundle data = new PersistableBundle();
       // Bundles are not persistable, so let's convert to a JSON string
       data.putString(NOTIFICATION_KEY, bundleToJson(bundle).toString());

package/android/src/main/java/expo/modules/notifications/notifications/background/ExpoBackgroundNotificationTasksModule.kt

@@ -0,0 +1,33 @@
+package expo.modules.notifications.notifications.background
+
+import expo.modules.interfaces.taskManager.TaskManagerInterface
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ModuleNotFoundException
+
+class ExpoBackgroundNotificationTasksModule : Module() {
+  private lateinit var taskManager: TaskManagerInterface
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoBackgroundNotificationTasksModule")
+    OnCreate {
+      taskManager = appContext.legacyModule()
+        ?: throw ModuleNotFoundException(TaskManagerInterface::class)
+    }
+
+    AsyncFunction("registerTaskAsync") { taskName: String ->
+      taskManager.registerTask(
+        taskName,
+        BackgroundRemoteNotificationTaskConsumer::class.java,
+        emptyMap()
+      )
+    }
+
+    AsyncFunction("unregisterTaskAsync") { taskName: String ->
+      taskManager.unregisterTask(
+        taskName,
+        BackgroundRemoteNotificationTaskConsumer::class.java
+      )
+    }
+  }
+}

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/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)
+  }
+}