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

package/android/src/main/java/expo/modules/notifications/notifications/triggers/DailyTrigger.java

@@ -0,0 +1,76 @@
+package expo.modules.notifications.notifications.triggers;
+
+import android.os.Parcel;
+
+import java.util.Calendar;
+import java.util.Date;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.interfaces.SchedulableNotificationTrigger;
+
+/**
+ * A schedulable trigger representing a notification to be scheduled once per day.
+ */
+public class DailyTrigger extends ChannelAwareTrigger implements SchedulableNotificationTrigger {
+  private int mHour;
+  private int mMinute;
+
+  public DailyTrigger(int hour, int minute, @Nullable String channelId) {
+    super(channelId);
+    mHour = hour;
+    mMinute = minute;
+  }
+
+  private DailyTrigger(Parcel in) {
+    super(in);
+    mHour = in.readInt();
+    mMinute = in.readInt();
+  }
+
+  public int getHour() {
+    return mHour;
+  }
+
+  public int getMinute() {
+    return mMinute;
+  }
+
+  @Nullable
+  @Override
+  public Date nextTriggerDate() {
+    Calendar nextTriggerDate = Calendar.getInstance();
+    nextTriggerDate.set(Calendar.HOUR_OF_DAY, mHour);
+    nextTriggerDate.set(Calendar.MINUTE, mMinute);
+    nextTriggerDate.set(Calendar.SECOND, 0);
+    nextTriggerDate.set(Calendar.MILLISECOND, 0);
+    Calendar rightNow = Calendar.getInstance();
+    if (nextTriggerDate.before(rightNow)) {
+      nextTriggerDate.add(Calendar.DATE, 1);
+    }
+    return nextTriggerDate.getTime();
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeInt(mHour);
+    dest.writeInt(mMinute);
+  }
+
+  public static final Creator<DailyTrigger> CREATOR = new Creator<DailyTrigger>() {
+    @Override
+    public DailyTrigger createFromParcel(Parcel in) {
+      return new DailyTrigger(in);
+    }
+
+    @Override
+    public DailyTrigger[] newArray(int size) {
+      return new DailyTrigger[size];
+    }
+  };
+}

package/android/src/main/java/expo/modules/notifications/notifications/triggers/DateTrigger.java

@@ -0,0 +1,64 @@
+package expo.modules.notifications.notifications.triggers;
+
+import android.os.Parcel;
+
+import java.util.Date;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.interfaces.SchedulableNotificationTrigger;
+
+/**
+ * A schedulable trigger representing notification to be scheduled only once at a given moment of time.
+ */
+public class DateTrigger extends ChannelAwareTrigger implements SchedulableNotificationTrigger {
+  private Date mTriggerDate;
+
+  public DateTrigger(long timestamp, @Nullable String channelId) {
+    super(channelId);
+    mTriggerDate = new Date(timestamp);
+  }
+
+  private DateTrigger(Parcel in) {
+    super(in);
+    mTriggerDate = new Date(in.readLong());
+  }
+
+  public Date getTriggerDate() {
+    return mTriggerDate;
+  }
+
+  @Nullable
+  @Override
+  public Date nextTriggerDate() {
+    Date now = new Date();
+
+    if (mTriggerDate.before(now)) {
+      return null;
+    }
+
+    return mTriggerDate;
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeLong(mTriggerDate.getTime());
+  }
+
+  public static final Creator<DateTrigger> CREATOR = new Creator<DateTrigger>() {
+    @Override
+    public DateTrigger createFromParcel(Parcel in) {
+      return new DateTrigger(in);
+    }
+
+    @Override
+    public DateTrigger[] newArray(int size) {
+      return new DateTrigger[size];
+    }
+  };
+}

package/android/src/main/java/expo/modules/notifications/notifications/triggers/TimeIntervalTrigger.java

@@ -0,0 +1,87 @@
+package expo.modules.notifications.notifications.triggers;
+
+import android.os.Parcel;
+
+import java.util.Date;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.interfaces.SchedulableNotificationTrigger;
+
+/**
+ * A schedulable trigger representing notification to be scheduled after X milliseconds,
+ * optionally repeating.
+ * <p>
+ * <i>Note: The implementation ensures that the trigger times do not drift away too much from the
+ * * initial time, so eg. a trigger started at 11111000 time repeated every 1000 ms should always
+ * * trigger around …000 timestamp.</i>
+ */
+public class TimeIntervalTrigger extends ChannelAwareTrigger implements SchedulableNotificationTrigger {
+  private Date mTriggerDate;
+  private long mTimeInterval;
+  private boolean mRepeats;
+
+  public TimeIntervalTrigger(long timeInterval, boolean repeats, @Nullable String channelId) {
+    super(channelId);
+    mTimeInterval = timeInterval;
+    mTriggerDate = new Date(new Date().getTime() + mTimeInterval * 1000);
+    mRepeats = repeats;
+  }
+
+  private TimeIntervalTrigger(Parcel in) {
+    super(in);
+    mTriggerDate = new Date(in.readLong());
+    mTimeInterval = in.readLong();
+    mRepeats = in.readByte() == 1;
+  }
+
+  public boolean isRepeating() {
+    return mRepeats;
+  }
+
+  public long getTimeInterval() {
+    return mTimeInterval;
+  }
+
+  @Nullable
+  @Override
+  public Date nextTriggerDate() {
+    Date now = new Date();
+
+    if (mRepeats) {
+      while (mTriggerDate.before(now)) {
+        mTriggerDate.setTime(mTriggerDate.getTime() + mTimeInterval * 1000);
+      }
+    }
+
+    if (mTriggerDate.before(now)) {
+      return null;
+    }
+
+    return mTriggerDate;
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeLong(mTriggerDate.getTime());
+    dest.writeLong(mTimeInterval);
+    dest.writeByte((byte) (mRepeats ? 1 : 0));
+  }
+
+  public static final Creator<TimeIntervalTrigger> CREATOR = new Creator<TimeIntervalTrigger>() {
+    @Override
+    public TimeIntervalTrigger createFromParcel(Parcel in) {
+      return new TimeIntervalTrigger(in);
+    }
+
+    @Override
+    public TimeIntervalTrigger[] newArray(int size) {
+      return new TimeIntervalTrigger[size];
+    }
+  };
+}

package/android/src/main/java/expo/modules/notifications/notifications/triggers/WeeklyTrigger.java

@@ -0,0 +1,85 @@
+package expo.modules.notifications.notifications.triggers;
+
+import android.os.Parcel;
+
+import java.util.Calendar;
+import java.util.Date;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.interfaces.SchedulableNotificationTrigger;
+
+/**
+ * A schedulable trigger representing a notification to be scheduled once per week.
+ */
+public class WeeklyTrigger extends ChannelAwareTrigger implements SchedulableNotificationTrigger {
+  private int mWeekday;
+  private int mHour;
+  private int mMinute;
+
+  public WeeklyTrigger(int weekday, int hour, int minute, @Nullable String channelId) {
+    super(channelId);
+    mWeekday = weekday;
+    mHour = hour;
+    mMinute = minute;
+  }
+
+  private WeeklyTrigger(Parcel in) {
+    super(in);
+    mWeekday = in.readInt();
+    mHour = in.readInt();
+    mMinute = in.readInt();
+  }
+
+  public int getWeekday() {
+    return mWeekday;
+  }
+
+  public int getHour() {
+    return mHour;
+  }
+
+  public int getMinute() {
+    return mMinute;
+  }
+
+  @Nullable
+  @Override
+  public Date nextTriggerDate() {
+    Calendar nextTriggerDate = Calendar.getInstance();
+    nextTriggerDate.set(Calendar.DAY_OF_WEEK, mWeekday);
+    nextTriggerDate.set(Calendar.HOUR_OF_DAY, mHour);
+    nextTriggerDate.set(Calendar.MINUTE, mMinute);
+    nextTriggerDate.set(Calendar.SECOND, 0);
+    nextTriggerDate.set(Calendar.MILLISECOND, 0);
+    Calendar rightNow = Calendar.getInstance();
+    if (nextTriggerDate.before(rightNow)) {
+      nextTriggerDate.add(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
+    }
+    return nextTriggerDate.getTime();
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeInt(mWeekday);
+    dest.writeInt(mHour);
+    dest.writeInt(mMinute);
+  }
+
+  public static final Creator<WeeklyTrigger> CREATOR = new Creator<WeeklyTrigger>() {
+    @Override
+    public WeeklyTrigger createFromParcel(Parcel in) {
+      return new WeeklyTrigger(in);
+    }
+
+    @Override
+    public WeeklyTrigger[] newArray(int size) {
+      return new WeeklyTrigger[size];
+    }
+  };
+}

package/android/src/main/java/expo/modules/notifications/notifications/triggers/YearlyTrigger.java

@@ -0,0 +1,94 @@
+package expo.modules.notifications.notifications.triggers;
+
+import android.os.Parcel;
+
+import java.util.Calendar;
+import java.util.Date;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.interfaces.SchedulableNotificationTrigger;
+
+/**
+ * A schedulable trigger representing a notification to be scheduled once per year.
+ */
+public class YearlyTrigger extends ChannelAwareTrigger implements SchedulableNotificationTrigger {
+  private int mDay;
+  private int mMonth;
+  private int mHour;
+  private int mMinute;
+
+  public YearlyTrigger(int day, int month, int hour, int minute, @Nullable String channelId) {
+    super(channelId);
+    mDay = day;
+    mMonth = month;
+    mHour = hour;
+    mMinute = minute;
+  }
+
+  private YearlyTrigger(Parcel in) {
+    super(in);
+    mDay = in.readInt();
+    mMonth = in.readInt();
+    mHour = in.readInt();
+    mMinute = in.readInt();
+  }
+
+  public int getDay() {
+    return mDay;
+  }
+
+  public int getMonth() {
+    return mMonth;
+  }
+
+  public int getHour() {
+    return mHour;
+  }
+
+  public int getMinute() {
+    return mMinute;
+  }
+
+  @Nullable
+  @Override
+  public Date nextTriggerDate() {
+    Calendar nextTriggerDate = Calendar.getInstance();
+    nextTriggerDate.set(Calendar.DATE, mDay);
+    nextTriggerDate.set(Calendar.MONTH, mMonth);
+    nextTriggerDate.set(Calendar.HOUR_OF_DAY, mHour);
+    nextTriggerDate.set(Calendar.MINUTE, mMinute);
+    nextTriggerDate.set(Calendar.SECOND, 0);
+    nextTriggerDate.set(Calendar.MILLISECOND, 0);
+    Calendar rightNow = Calendar.getInstance();
+    if (nextTriggerDate.before(rightNow)) {
+      nextTriggerDate.add(Calendar.YEAR, 1);
+    }
+    return nextTriggerDate.getTime();
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeInt(mDay);
+    dest.writeInt(mMonth);
+    dest.writeInt(mHour);
+    dest.writeInt(mMinute);
+  }
+
+  public static final Creator<YearlyTrigger> CREATOR = new Creator<YearlyTrigger>() {
+    @Override
+    public YearlyTrigger createFromParcel(Parcel in) {
+      return new YearlyTrigger(in);
+    }
+
+    @Override
+    public YearlyTrigger[] newArray(int size) {
+      return new YearlyTrigger[size];
+    }
+  };
+}

package/android/src/main/java/expo/modules/notifications/permissions/NotificationPermissionsModule.kt

@@ -0,0 +1,124 @@
+package expo.modules.notifications.permissions
+
+import android.Manifest
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.os.bundleOf
+import expo.modules.core.arguments.ReadableArguments
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.interfaces.permissions.PermissionsResponse
+import expo.modules.interfaces.permissions.PermissionsStatus
+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.ModuleNotFoundException
+
+private const val ANDROID_RESPONSE_KEY = "android"
+private const val IMPORTANCE_KEY = "importance"
+private const val INTERRUPTION_FILTER_KEY = "interruptionFilter"
+private val PERMISSIONS: Array<String> = arrayOf(Manifest.permission.POST_NOTIFICATIONS)
+
+class NotificationPermissionsModule : Module() {
+  private val permissions: Permissions
+    get() = appContext.permissions ?: throw ModuleNotFoundException(Permissions::class)
+
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationPermissionsModule")
+
+    AsyncFunction("getPermissionsAsync") { promise: Promise ->
+      if (context.applicationContext.applicationInfo.targetSdkVersion >= 33 && Build.VERSION.SDK_INT >= 33) {
+        getPermissionsWithPromiseImplApi33(promise)
+      } else {
+        getPermissionsWithPromiseImplClassic(promise)
+      }
+    }
+
+    AsyncFunction("requestPermissionsAsync") { _: ReadableArguments?, promise: Promise ->
+      if (context.applicationContext.applicationInfo.targetSdkVersion >= 33 && Build.VERSION.SDK_INT >= 33) {
+        requestPermissionsWithPromiseImplApi33(promise)
+      } else {
+        getPermissionsWithPromiseImplClassic(promise)
+      }
+    }
+  }
+
+  @RequiresApi(33)
+  private fun getPermissionsWithPromiseImplApi33(promise: Promise) {
+    permissions.getPermissions(
+      { permissionsMap: Map<String, PermissionsResponse> ->
+        val managerCompat = NotificationManagerCompat.from(context)
+        val areEnabled = managerCompat.areNotificationsEnabled()
+        val platformBundle = bundleOf(
+          IMPORTANCE_KEY to managerCompat.importance,
+        ).apply {
+          val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
+          if (notificationManager != null) {
+            putInt(INTERRUPTION_FILTER_KEY, notificationManager.currentInterruptionFilter)
+          }
+        }
+
+        val areAllGranted = permissionsMap.all { (_, response) -> response.status == PermissionsStatus.GRANTED }
+        val areAllDenied = permissionsMap.all { (_, response) -> response.status == PermissionsStatus.DENIED }
+        val canAskAgain = permissionsMap.all { (_, response) -> response.canAskAgain }
+        val status = when {
+          areAllDenied -> PermissionsStatus.DENIED.status
+          !areEnabled -> PermissionsStatus.DENIED.status
+          areAllGranted -> PermissionsStatus.GRANTED.status
+          else -> PermissionsStatus.UNDETERMINED.status
+        }
+
+        promise.resolve(
+          bundleOf(
+            PermissionsResponse.EXPIRES_KEY to PermissionsResponse.PERMISSION_EXPIRES_NEVER,
+            PermissionsResponse.STATUS_KEY to status,
+            PermissionsResponse.CAN_ASK_AGAIN_KEY to canAskAgain,
+            PermissionsResponse.GRANTED_KEY to areAllGranted,
+            ANDROID_RESPONSE_KEY to platformBundle,
+          )
+        )
+      },
+      *PERMISSIONS
+    )
+  }
+
+  private fun getPermissionsWithPromiseImplClassic(promise: Promise) {
+    val managerCompat = NotificationManagerCompat.from(context)
+    val areEnabled = managerCompat.areNotificationsEnabled()
+    val status = if (areEnabled) PermissionsStatus.GRANTED else PermissionsStatus.DENIED
+    val platformBundle = bundleOf(
+      IMPORTANCE_KEY to managerCompat.importance,
+    ).apply {
+      val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
+      if (notificationManager != null) {
+        putInt(INTERRUPTION_FILTER_KEY, notificationManager.currentInterruptionFilter)
+      }
+    }
+
+    promise.resolve(
+      bundleOf(
+        PermissionsResponse.EXPIRES_KEY to PermissionsResponse.PERMISSION_EXPIRES_NEVER,
+        PermissionsResponse.STATUS_KEY to status.status,
+        PermissionsResponse.CAN_ASK_AGAIN_KEY to areEnabled,
+        PermissionsResponse.GRANTED_KEY to (status == PermissionsStatus.GRANTED),
+        ANDROID_RESPONSE_KEY to platformBundle,
+      )
+    )
+  }
+
+  @RequiresApi(33)
+  private fun requestPermissionsWithPromiseImplApi33(promise: Promise) {
+    permissions.askForPermissions(
+      {
+        getPermissionsWithPromiseImplApi33(promise)
+      },
+      *PERMISSIONS
+    )
+  }
+}

package/android/src/main/java/expo/modules/notifications/serverregistration/InstallationId.java

@@ -0,0 +1,134 @@
+package expo.modules.notifications.serverregistration;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.UUID;
+
+/**
+ * An installation ID provider - it solves two purposes:
+ * - in installations that have a legacy UUID persisted
+ * in shared-across-expo-modules SharedPreferences or
+ * shared-across-expo-modules non-backed-up file,
+ * migrates the UUID from there to its own non-backed-up file,
+ * - provides/creates a UUID unique per an installation.
+ * <p>
+ * Similar class exists in expoview and expo-constants.
+ */
+public class InstallationId {
+  private static final String TAG = InstallationId.class.getSimpleName();
+
+  // Legacy storage
+  public static final String LEGACY_PREFERENCES_FILE_NAME = "host.exp.exponent.SharedPreferences";
+  public static final String LEGACY_PREFERENCES_UUID_KEY = "uuid";
+
+  public static final String LEGACY_UUID_FILE_NAME = "expo_installation_uuid.txt";
+
+  // Primary storage
+  public static final String UUID_FILE_NAME = "expo_notifications_installation_uuid.txt";
+
+  private String mUuid;
+  private Context mContext;
+  private SharedPreferences mLegacySharedPreferences;
+
+  public InstallationId(Context context) {
+    mContext = context;
+    mLegacySharedPreferences = context.getSharedPreferences(LEGACY_PREFERENCES_FILE_NAME, Context.MODE_PRIVATE);
+  }
+
+  public String getUUID() {
+    // If it has already been cached, return the value.
+    if (mUuid != null) {
+      return mUuid;
+    }
+
+    // 1. Read from primary storage
+    //    If there already is a value it must have been migrated previously.
+    mUuid = readUUIDFromFile(new File(mContext.getNoBackupFilesDir(), UUID_FILE_NAME));
+    if (mUuid != null) {
+      return mUuid;
+    }
+
+    // 2. Read from legacy shared preferences
+    //    If there is a value we should use it - it's been used by previous versions
+    //    of expo-notifications, so in order not to rotate the ID we should migrate it
+    //    to new storage.
+    mUuid = mLegacySharedPreferences.getString(LEGACY_PREFERENCES_UUID_KEY, null);
+    if (mUuid != null) {
+      try {
+        saveUUID(mUuid);
+        // We only remove the value from old storage once it's set and saved in the new storage.
+        mLegacySharedPreferences.edit().remove(LEGACY_PREFERENCES_UUID_KEY).apply();
+      } catch (IOException e) {
+        Log.e(TAG, "Error while migrating UUID from legacy storage. " + e);
+      }
+
+      return mUuid;
+    }
+
+    // 3. Migrate from legacy file
+    //    If there is a value and we've made it up to here it means
+    //    expo-notifications hasn't used *its own* ID in the past -
+    //    - it used expo-constants' ID. Since it's now deprecated,
+    //    let's copy the value to our own storage.
+    mUuid = readUUIDFromFile(new File(mContext.getNoBackupFilesDir(), LEGACY_UUID_FILE_NAME));
+    if (mUuid != null) {
+      try {
+        saveUUID(mUuid);
+      } catch (IOException e) {
+        Log.e(TAG, "Error while migrating UUID from legacy storage. " + e);
+      }
+
+      return mUuid;
+    }
+
+    //noinspection ConstantConditions
+    return mUuid;
+  }
+
+  public String getOrCreateUUID() {
+    String uuid = getUUID();
+    if (uuid != null) {
+      return uuid;
+    }
+
+    // We persist the new UUID in "session storage"
+    // so that if writing to persistent storage
+    // fails subsequent calls to get(orCreate)UUID
+    // return the same value.
+    mUuid = UUID.randomUUID().toString();
+    try {
+      saveUUID(mUuid);
+    } catch (IOException e) {
+      Log.e(TAG, "Error while writing new UUID. " + e);
+    }
+    return mUuid;
+  }
+
+  protected String readUUIDFromFile(File file) {
+    try (FileReader fileReader = new FileReader(file);
+         BufferedReader bufferedReader = new BufferedReader(fileReader)) {
+      String line = bufferedReader.readLine();
+      // If line is not a UUID, it throws an IllegalArgumentException
+      return UUID.fromString(line).toString();
+    } catch (IOException | IllegalArgumentException e) {
+      return null;
+    }
+  }
+
+  protected void saveUUID(String uuid) throws IOException {
+    try (FileWriter writer = new FileWriter(getNonBackedUpUuidFile())) {
+      writer.write(uuid);
+    }
+  }
+
+  protected File getNonBackedUpUuidFile() {
+    return new File(mContext.getNoBackupFilesDir(), UUID_FILE_NAME);
+  }
+}

package/android/src/main/java/expo/modules/notifications/serverregistration/RegistrationInfo.kt

@@ -0,0 +1,24 @@
+package expo.modules.notifications.serverregistration
+
+import android.content.Context
+import java.io.File
+
+open class RegistrationInfo(private val context: Context) {
+  companion object {
+    const val REGISTRATION_INFO_FILE_NAME = "expo_notifications_registration_info.txt"
+  }
+
+  protected val nonBackedUpRegistrationInfoFile: File
+    get() = File(context.noBackupFilesDir, REGISTRATION_INFO_FILE_NAME)
+
+  fun get(): String? = if (nonBackedUpRegistrationInfoFile.exists()) {
+    nonBackedUpRegistrationInfoFile.readText()
+  } else null
+
+  fun set(registrationInfo: String?) {
+    nonBackedUpRegistrationInfoFile.delete()
+    registrationInfo?.let {
+      nonBackedUpRegistrationInfoFile.writeText(it)
+    }
+  }
+}