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

package/THIRD_PARTY_NOTICES.txt

@@ -0,0 +1,4 @@
+License from package.json:
+==============================
+
+MIT

package/android/build.gradle

@@ -0,0 +1,125 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+group = 'host.exp.exponent'
+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
+  }
+
+  // Ensures backward compatibility
+  ext.getKotlinVersion = {
+    if (ext.has("kotlinVersion")) {
+      ext.kotlinVersion()
+    } else {
+      ext.safeExtGet("kotlinVersion", "1.8.10")
+    }
+  }
+
+  repositories {
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
+  }
+}
+
+// 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
+        }
+      }
+    }
+  }
+}
+
+android {
+  // 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) {
+    compileOptions {
+      sourceCompatibility JavaVersion.VERSION_11
+      targetCompatibility JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+      jvmTarget = JavaVersion.VERSION_11.majorVersion
+    }
+  }
+
+  namespace "expo.modules.notifications"
+  defaultConfig {
+    versionCode 21
+    versionName '0.25.0'
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+}
+
+dependencies {
+  // 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'
+
+
+  api 'com.google.firebase:firebase-messaging:22.0.0'
+
+  api 'me.leolin:ShortcutBadger:1.1.22@aar'
+
+  if (project.findProject(':expo-modules-test-core')) {
+    testImplementation project(':expo-modules-test-core')
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,39 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+
+  <application>
+    <service
+      android:name=".service.ExpoFirebaseMessagingService"
+      android:exported="false">
+      <intent-filter android:priority="-1">
+        <action android:name="com.google.firebase.MESSAGING_EVENT" />
+      </intent-filter>
+    </service>
+
+    <receiver
+      android:name=".service.NotificationsService"
+      android:enabled="true"
+      android:exported="false">
+      <intent-filter android:priority="-1">
+        <action android:name="expo.modules.notifications.NOTIFICATION_EVENT" />
+
+        <action android:name="android.intent.action.BOOT_COMPLETED" />
+        <action android:name="android.intent.action.REBOOT" />
+        <action android:name="android.intent.action.QUICKBOOT_POWERON" />
+        <action android:name="com.htc.intent.action.QUICKBOOT_POWERON" />
+
+        <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+      </intent-filter>
+    </receiver>
+
+    <activity android:name=".service.NotificationForwarderActivity"
+      android:theme="@android:style/Theme.Translucent.NoTitleBar"
+      android:exported="false"
+      android:excludeFromRecents="true"
+      android:noHistory="true"
+      android:launchMode="standard"
+      android:taskAffinity=""
+      />
+  </application>
+</manifest>

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

@@ -0,0 +1,34 @@
+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 expo.modules.notifications.notifications.NotificationManager;
+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.tokens.PushTokenManager;
+
+public class NotificationsPackage extends BasePackage {
+  @Override
+  public List<SingletonModule> createSingletonModules(Context context) {
+    return Arrays.asList(
+      new PushTokenManager(),
+      new NotificationManager()
+    );
+  }
+
+  @Override
+  public List<InternalModule> createInternalModules(Context context) {
+    return Arrays.asList(
+      new AndroidXNotificationsChannelsProvider(context),
+      new ExpoNotificationsCategoriesSerializer()
+    );
+  }
+}

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

@@ -0,0 +1,22 @@
+package expo.modules.notifications.badge
+
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class BadgeModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoBadgeModule")
+
+    AsyncFunction("getBadgeCountAsync") {
+      BadgeHelper.badgeCount
+    }
+
+    AsyncFunction("setBadgeCountAsync") { badgeCount: Int ->
+      BadgeHelper.setBadgeCount(
+        appContext.reactContext ?: throw Exceptions.ReactContextLost(),
+        badgeCount
+      )
+    }
+  }
+}

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

@@ -0,0 +1,149 @@
+package expo.modules.notifications.notifications;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.net.Uri;
+import android.util.Log;
+
+import org.json.JSONObject;
+import expo.modules.core.arguments.ReadableArguments;
+
+import java.util.List;
+import java.util.Map;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.channels.InvalidVibrationPatternException;
+import expo.modules.notifications.notifications.enums.NotificationPriority;
+import expo.modules.notifications.notifications.model.NotificationContent;
+
+public class ArgumentsNotificationContentBuilder extends NotificationContent.Builder {
+  private static final String TITLE_KEY = "title";
+  private static final String SUBTITLE_KEY = "subtitle";
+  private static final String TEXT_KEY = "body";
+  private static final String BODY_KEY = "data";
+  private static final String SOUND_KEY = "sound";
+  private static final String VIBRATE_KEY = "vibrate";
+  private static final String PRIORITY_KEY = "priority";
+  private static final String BADGE_KEY = "badge";
+  private static final String COLOR_KEY = "color";
+  private static final String AUTO_DISMISS_KEY = "autoDismiss";
+  private static final String CATEGORY_IDENTIFIER_KEY = "categoryIdentifier";
+  private static final String STICKY_KEY = "sticky";
+
+  private SoundResolver mSoundResolver;
+
+  public ArgumentsNotificationContentBuilder(Context context) {
+    mSoundResolver = new SoundResolver(context);
+  }
+
+  public NotificationContent.Builder setPayload(ReadableArguments payload) {
+    this.setTitle(payload.getString(TITLE_KEY))
+      .setSubtitle(payload.getString(SUBTITLE_KEY))
+      .setText(payload.getString(TEXT_KEY))
+      .setBody(getBody(payload))
+      .setPriority(getPriority(payload))
+      .setBadgeCount(getBadgeCount(payload))
+      .setColor(getColor(payload))
+      .setAutoDismiss(getAutoDismiss(payload))
+      .setCategoryId(getCategoryId(payload))
+      .setSticky(getSticky(payload));
+
+    if (shouldPlayDefaultSound(payload)) {
+      useDefaultSound();
+    } else {
+      setSound(getSound(payload));
+    }
+
+    if (shouldUseDefaultVibrationPattern(payload)) {
+      useDefaultVibrationPattern();
+    } else {
+      setVibrationPattern(getVibrationPattern(payload));
+    }
+    return this;
+  }
+
+  protected Number getBadgeCount(ReadableArguments payload) {
+    return payload.containsKey(BADGE_KEY) ? payload.getInt(BADGE_KEY) : null;
+  }
+
+  protected Number getColor(ReadableArguments payload) {
+    try {
+      return payload.containsKey(COLOR_KEY) ? Color.parseColor(payload.getString(COLOR_KEY)) : null;
+    } catch (IllegalArgumentException e) {
+      Log.e("expo-notifications", "Could not have parsed color passed in notification.");
+      return null;
+    }
+  }
+
+  protected boolean shouldPlayDefaultSound(ReadableArguments payload) {
+    if (payload.get(SOUND_KEY) instanceof Boolean) {
+      return payload.getBoolean(SOUND_KEY);
+    }
+
+    // do not play a default sound only if the value is a valid Uri
+    return getSound(payload) == null;
+  }
+
+  protected Uri getSound(ReadableArguments payload) {
+    String soundValue = payload.getString(SOUND_KEY);
+    return mSoundResolver.resolve(soundValue);
+  }
+
+  @Nullable
+  protected JSONObject getBody(ReadableArguments payload) {
+    try {
+      Map body = payload.getMap(BODY_KEY);
+      if (body != null) {
+        return new JSONObject(body);
+      }
+      return null;
+    } catch (NullPointerException e) {
+      return null;
+    }
+  }
+
+  protected boolean shouldUseDefaultVibrationPattern(ReadableArguments payload) {
+    return !payload.getBoolean(VIBRATE_KEY, true);
+  }
+
+  protected long[] getVibrationPattern(ReadableArguments payload) {
+    try {
+      List<?> vibrateJsonArray = payload.getList(VIBRATE_KEY);
+      if (vibrateJsonArray != null) {
+        long[] pattern = new long[vibrateJsonArray.size()];
+        for (int i = 0; i < vibrateJsonArray.size(); i++) {
+          if (vibrateJsonArray.get(i) instanceof Number) {
+            pattern[i] = ((Number) vibrateJsonArray.get(i)).longValue();
+          } else {
+            throw new InvalidVibrationPatternException(i, vibrateJsonArray.get(i));
+          }
+        }
+        return pattern;
+      }
+    } catch (InvalidVibrationPatternException e) {
+      Log.w("expo-notifications", "Failed to set custom vibration pattern from the notification: " + e.getMessage());
+    }
+
+    return null;
+  }
+
+  protected NotificationPriority getPriority(ReadableArguments payload) {
+    String priorityString = payload.getString(PRIORITY_KEY);
+    return NotificationPriority.fromEnumValue(priorityString);
+  }
+
+  protected boolean getAutoDismiss(ReadableArguments payload) {
+    // TODO(sjchmiela): the default value should be determined by NotificationContent.Builder
+    return payload.getBoolean(AUTO_DISMISS_KEY, true);
+  }
+
+  @Nullable
+  protected String getCategoryId(ReadableArguments payload) {
+    return payload.getString(CATEGORY_IDENTIFIER_KEY, null);
+  }
+
+  protected boolean getSticky(ReadableArguments payload) {
+    // TODO: the default value should be determined by NotificationContent.Builder
+    return payload.getBoolean(STICKY_KEY, false);
+  }
+}

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

@@ -0,0 +1,203 @@
+package expo.modules.notifications.notifications;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.net.Uri;
+import android.util.Log;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.enums.NotificationPriority;
+import expo.modules.notifications.notifications.model.NotificationContent;
+
+public class JSONNotificationContentBuilder extends NotificationContent.Builder {
+  private static final String TITLE_KEY = "title";
+  private static final String TEXT_KEY = "message";
+  private static final String SUBTITLE_KEY = "subtitle";
+  private static final String SOUND_KEY = "sound";
+  private static final String BODY_KEY = "body";
+  private static final String VIBRATE_KEY = "vibrate";
+  private static final String PRIORITY_KEY = "priority";
+  private static final String BADGE_KEY = "badge";
+  private static final String COLOR_KEY = "color";
+  private static final String AUTO_DISMISS_KEY = "autoDismiss";
+  private static final String CATEGORY_IDENTIFIER_KEY = "categoryId";
+  private static final String STICKY_KEY = "sticky";
+
+
+  private SoundResolver mSoundResolver;
+
+  public JSONNotificationContentBuilder(Context context) {
+    mSoundResolver = new SoundResolver(context);
+  }
+
+  public NotificationContent.Builder setPayload(JSONObject payload) {
+    this.setTitle(getTitle(payload))
+      .setSubtitle(getSubtitle(payload))
+      .setText(getText(payload))
+      .setBody(getBody(payload))
+      .setPriority(getPriority(payload))
+      .setBadgeCount(getBadgeCount(payload))
+      .setColor(getColor(payload))
+      .setAutoDismiss(getAutoDismiss(payload))
+      .setCategoryId(getCategoryId(payload))
+      .setSticky(getSticky(payload));
+
+    if (shouldPlayDefaultSound(payload)) {
+      useDefaultSound();
+    } else {
+      setSound(getSound(payload));
+    }
+
+    if (shouldUseDefaultVibrationPattern(payload)) {
+      useDefaultVibrationPattern();
+    } else {
+      setVibrationPattern(getVibrationPattern(payload));
+    }
+    return this;
+  }
+
+  protected String getTitle(JSONObject payload) {
+    try {
+      return payload.getString(TITLE_KEY);
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  protected String getText(JSONObject payload) {
+    try {
+      return payload.getString(TEXT_KEY);
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  protected String getSubtitle(JSONObject payload) {
+    try {
+      return payload.getString(SUBTITLE_KEY);
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  protected Number getBadgeCount(JSONObject payload) {
+    try {
+      return payload.has(BADGE_KEY) ? payload.getInt(BADGE_KEY) : null;
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  protected boolean shouldPlayDefaultSound(JSONObject payload) {
+    try {
+      // value is an explicit boolean
+      return payload.getBoolean(SOUND_KEY);
+    } catch (JSONException e) {
+      // do nothing
+    }
+
+    // do not play a default sound only if the value is a valid Uri
+    return getSound(payload) == null;
+  }
+
+  protected Uri getSound(JSONObject payload) {
+    try {
+      payload.getBoolean(SOUND_KEY);
+      // value is an explicit boolean
+      return null;
+    } catch (JSONException e) {
+      // it's not a boolean, let's handle it as a string
+    }
+
+    try {
+      String soundValue = payload.getString(SOUND_KEY);
+      return mSoundResolver.resolve(soundValue);
+    } catch (JSONException e) {
+      // if it's neither a boolean nor a string we can't handle it
+    }
+    return null;
+  }
+
+  @Nullable
+  protected JSONObject getBody(JSONObject payload) {
+    try {
+      return new JSONObject(payload.optString(BODY_KEY));
+    } catch (JSONException | NullPointerException e) {
+      return null;
+    }
+  }
+
+  protected boolean shouldUseDefaultVibrationPattern(JSONObject payload) {
+    return !payload.optBoolean(VIBRATE_KEY, true);
+  }
+
+  protected long[] getVibrationPattern(JSONObject payload) {
+    try {
+      JSONArray vibrateJsonArray = payload.optJSONArray(VIBRATE_KEY);
+      if (vibrateJsonArray != null) {
+        long[] pattern = new long[vibrateJsonArray.length()];
+        for (int i = 0; i < vibrateJsonArray.length(); i++) {
+          pattern[i] = vibrateJsonArray.getLong(i);
+        }
+        return pattern;
+      }
+    } catch (JSONException e) {
+      Log.w("expo-notifications", "Failed to set custom vibration pattern from the notification: " + e.getMessage());
+    }
+
+    return null;
+  }
+
+  protected NotificationPriority getPriority(JSONObject payload) {
+    String priorityString = payload.optString(PRIORITY_KEY);
+    return NotificationPriority.fromEnumValue(priorityString);
+  }
+
+  protected Number getColor(JSONObject payload) {
+    try {
+      return payload.has(COLOR_KEY) ? Color.parseColor(payload.getString(COLOR_KEY)) : null;
+    } catch (IllegalArgumentException e) {
+      Log.e("expo-notifications", "Could not have parsed color passed in notification.");
+    } catch (JSONException e) {
+      Log.e("expo-notifications", "Could not have parsed a non-string color value passed in notification.");
+    }
+    return null;
+  }
+
+  protected boolean getAutoDismiss(JSONObject payload) {
+    if (payload.has(AUTO_DISMISS_KEY)) {
+      try {
+        return payload.getBoolean(AUTO_DISMISS_KEY);
+      } catch (JSONException e) {
+        Log.e("expo-notifications", "Could not have parsed a boolean autoDismiss value passed in notification, falling back to a default value.");
+      }
+    }
+    // TODO(sjchmiela): the default value should be determined by NotificationContent.Builder
+    return true;
+  }
+
+  @Nullable
+  protected String getCategoryId(JSONObject payload) {
+    try {
+      return payload.getString(CATEGORY_IDENTIFIER_KEY);
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  protected boolean getSticky(JSONObject payload) {
+    if (payload.has(STICKY_KEY)) {
+      try {
+        return payload.getBoolean(STICKY_KEY);
+      } catch (JSONException e) {
+        Log.e("expo-notifications", "Could not have parsed a boolean sticky value passed in notification, falling back to a default value.");
+      }
+    }
+    // TODO: the default value should be determined by NotificationContent.Builder
+    return false;
+  }
+}