react-native-notify-kit 9.1.22 → 9.2.0

package/android/src/main/java/app/notifee/core/model/TimestampTriggerModel.java

@@ -0,0 +1,206 @@
+package app.notifee.core.model;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import app.notifee.core.utility.ObjectUtils;
+import java.util.Calendar;
+import java.util.concurrent.TimeUnit;
+
+public class TimestampTriggerModel {
+  private Bundle mTimeTriggerBundle;
+  private int mInterval = -1;
+  private TimeUnit mTimeUnit = null;
+  private Boolean mWithAlarmManager = false;
+  private AlarmType mAlarmType = AlarmType.SET_EXACT;
+  private String mRepeatFrequency = null;
+  private Long mTimestamp = null;
+
+  public static final String HOURLY = "HOURLY";
+  public static final String DAILY = "DAILY";
+  public static final String WEEKLY = "WEEKLY";
+
+  private static final long HOUR_IN_MS = 60L * 60 * 1000;
+
+  private static final String TAG = "TimeTriggerModel";
+
+  private TimestampTriggerModel(Bundle bundle) {
+    mTimeTriggerBundle = bundle;
+
+    // set initial values
+    TimeUnit timeUnit = null;
+    if (mTimeTriggerBundle.containsKey("repeatFrequency")) {
+      int repeatFrequency = ObjectUtils.getInt(mTimeTriggerBundle.get("repeatFrequency"));
+      mTimestamp = ObjectUtils.getLong(mTimeTriggerBundle.get("timestamp"));
+
+      switch (repeatFrequency) {
+        case -1:
+          // default value for one-time trigger
+          break;
+        case 0:
+          mInterval = 1;
+          mTimeUnit = TimeUnit.HOURS;
+          mRepeatFrequency = HOURLY;
+          break;
+        case 1:
+          mInterval = 1;
+          mTimeUnit = TimeUnit.DAYS;
+          mRepeatFrequency = DAILY;
+          break;
+        case 2:
+          // weekly, 7 days
+          mInterval = 7;
+          mTimeUnit = TimeUnit.DAYS;
+          mRepeatFrequency = WEEKLY;
+          break;
+      }
+    }
+
+    if (mTimeTriggerBundle.containsKey("alarmManager")) {
+      mWithAlarmManager = true;
+
+      Bundle alarmManagerBundle = mTimeTriggerBundle.getBundle("alarmManager");
+
+      Object typeObj = alarmManagerBundle.get("type");
+
+      int type;
+      if (typeObj != null) {
+        type = ObjectUtils.getInt(typeObj);
+      } else {
+        type = 3;
+      }
+
+      // this is for the deprecated `alarmManager.allowWhileIdle` option
+      if (alarmManagerBundle.containsKey("allowWhileIdle")
+          && alarmManagerBundle.getBoolean("allowWhileIdle")) {
+        type = 3;
+      }
+
+      switch (type) {
+        case 0:
+          mAlarmType = AlarmType.SET;
+          break;
+        case 1:
+          mAlarmType = AlarmType.SET_AND_ALLOW_WHILE_IDLE;
+          break;
+        // default behavior when alarmManager is true:
+        default:
+        case 2:
+          mAlarmType = AlarmType.SET_EXACT;
+          break;
+        case 3:
+          mAlarmType = AlarmType.SET_EXACT_AND_ALLOW_WHILE_IDLE;
+          break;
+        case 4:
+          mAlarmType = AlarmType.SET_ALARM_CLOCK;
+          break;
+      }
+    } else if (mTimeTriggerBundle.containsKey("allowWhileIdle")) {
+      // for dart
+      mWithAlarmManager = true;
+      mAlarmType = AlarmType.SET_EXACT_AND_ALLOW_WHILE_IDLE;
+    }
+  }
+
+  public static TimestampTriggerModel fromBundle(@NonNull Bundle bundle) {
+    return new TimestampTriggerModel(bundle);
+  }
+
+  public long getTimestamp() {
+    return mTimestamp;
+  }
+
+  public long getDelay() {
+    if (mTimestamp != null && mTimestamp > 0) {
+      return Math.round((mTimestamp - System.currentTimeMillis()) / 1000.0);
+    }
+    return 0;
+  }
+
+  public void setNextTimestamp() {
+    // Skip for non-repeating triggers
+    if (mRepeatFrequency == null) {
+      return;
+    }
+
+    long timestamp = getTimestamp();
+
+    if (HOURLY.equals(mRepeatFrequency)) {
+      // Hourly: fixed ms is correct — no wall-clock preservation needed
+      while (timestamp < System.currentTimeMillis()) {
+        timestamp += HOUR_IN_MS;
+      }
+      this.mTimestamp = timestamp;
+    } else {
+      // Daily/Weekly: use Calendar.add() to preserve local wall-clock time across DST boundaries.
+      // Adding fixed ms (86,400,000) breaks when a calendar day is 23 or 25 hours during DST.
+      Calendar cal = Calendar.getInstance();
+      cal.setTimeInMillis(timestamp);
+
+      int field;
+      if (WEEKLY.equals(mRepeatFrequency)) {
+        field = Calendar.WEEK_OF_YEAR;
+      } else {
+        field = Calendar.DAY_OF_MONTH;
+      }
+
+      while (cal.getTimeInMillis() < System.currentTimeMillis()) {
+        cal.add(field, 1);
+      }
+
+      this.mTimestamp = cal.getTimeInMillis();
+    }
+  }
+
+  public enum AlarmType {
+    SET,
+    SET_AND_ALLOW_WHILE_IDLE,
+    SET_EXACT,
+    SET_EXACT_AND_ALLOW_WHILE_IDLE,
+    SET_ALARM_CLOCK,
+  }
+
+  public int getInterval() {
+    return mInterval;
+  }
+
+  public TimeUnit getTimeUnit() {
+    return mTimeUnit;
+  }
+
+  public Boolean getWithAlarmManager() {
+    return mWithAlarmManager;
+  }
+
+  public AlarmType getAlarmType() {
+    return mAlarmType;
+  }
+
+  public String getRepeatFrequency() {
+    return mRepeatFrequency;
+  }
+
+  public Bundle toBundle() {
+    Bundle bundle = (Bundle) mTimeTriggerBundle.clone();
+    if (mTimestamp != null) {
+      bundle.putLong("timestamp", mTimestamp);
+    }
+    return bundle;
+  }
+}

package/android/src/main/java/app/notifee/core/model/package-info.java

@@ -0,0 +1,4 @@
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
+package app.notifee.core.model;
+
+import androidx.annotation.RestrictTo;

package/android/src/main/java/app/notifee/core/utility/AlarmUtils.java

@@ -0,0 +1,52 @@
+package app.notifee.core.utility;
+
+import static app.notifee.core.ContextHolder.getApplicationContext;
+
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+import app.notifee.core.ContextHolder;
+import app.notifee.core.Logger;
+
+public class AlarmUtils {
+  private static final String TAG = "AlarmUtils";
+
+  public static AlarmManager getAlarmManager() {
+    return (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
+  }
+
+  /**
+   * Attempts to open the device's alarm special access settings
+   *
+   * @param activity
+   */
+  public static void openAlarmPermissionSettings(Activity activity) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+      return;
+    }
+
+    try {
+      Intent intent = new Intent();
+      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+      intent.setAction(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM);
+      Context context = ContextHolder.getApplicationContext();
+      String packageName = context.getPackageName();
+      intent.setData(Uri.parse("package:" + packageName));
+
+      IntentUtils.startActivityOnUiThread(activity, intent);
+    } catch (Exception e) {
+      Logger.e(TAG, "An error occurred whilst trying to open alarm permission settings", e);
+    }
+  }
+
+  public static boolean canScheduleExactAlarms() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      return getAlarmManager().canScheduleExactAlarms();
+    }
+    return true;
+  }
+}

package/android/src/main/java/app/notifee/core/utility/Callbackable.java

@@ -0,0 +1,12 @@
+package app.notifee.core.utility;
+
+import androidx.annotation.Nullable;
+
+/**
+ * Since lambda functions are not supported prior to SDK 24, and this project's SDK min. is 20, This
+ * interface was created to pass a function to another object.
+ */
+public interface Callbackable<T> {
+
+  void call(@Nullable Exception e, @Nullable T result);
+}

package/android/src/main/java/app/notifee/core/utility/ColorUtils.java

@@ -0,0 +1,62 @@
+package app.notifee.core.utility;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.graphics.Color;
+import androidx.annotation.Nullable;
+import java.util.HashMap;
+
+public class ColorUtils {
+  public static @Nullable String getColorString(int color) {
+    String colorString = iColorNameMap.get(color);
+    if (colorString != null) {
+      return colorString;
+    } else {
+      return "#" + Integer.toHexString(color).substring(2);
+    }
+  }
+
+  private static final HashMap<Integer, String> iColorNameMap;
+
+  static {
+    iColorNameMap = new HashMap<>();
+    iColorNameMap.put(Color.BLACK, "black");
+    iColorNameMap.put(Color.DKGRAY, "darkgray");
+    iColorNameMap.put(Color.GRAY, "gray");
+    iColorNameMap.put(Color.LTGRAY, "lightgray");
+    iColorNameMap.put(Color.WHITE, "white");
+    iColorNameMap.put(Color.RED, "red");
+    iColorNameMap.put(Color.GREEN, "green");
+    iColorNameMap.put(Color.BLUE, "blue");
+    iColorNameMap.put(Color.YELLOW, "yellow");
+    iColorNameMap.put(Color.CYAN, "cyan");
+    iColorNameMap.put(Color.MAGENTA, "magenta");
+    iColorNameMap.put(0xFF00FFFF, "aqua");
+    iColorNameMap.put(0xFFFF00FF, "fuchsia");
+    iColorNameMap.put(Color.DKGRAY, "darkgrey");
+    iColorNameMap.put(Color.GRAY, "grey");
+    iColorNameMap.put(Color.LTGRAY, "lightgrey");
+    iColorNameMap.put(0xFF00FF00, "lime");
+    iColorNameMap.put(0xFF800000, "maroon");
+    iColorNameMap.put(0xFF000080, "navy");
+    iColorNameMap.put(0xFF808000, "olive");
+    iColorNameMap.put(0xFF800080, "purple");
+    iColorNameMap.put(0xFFC0C0C0, "silver");
+    iColorNameMap.put(0xFF008080, "teal");
+  }
+}

package/android/src/main/java/app/notifee/core/utility/ExtendedListenableFuture.java

@@ -0,0 +1,84 @@
+package app.notifee.core.utility;
+
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * A simple wrapper around {@link ListenableFuture} that provides additional methods that makes
+ * chaining {@link ListenableFuture}s easier and more readable.
+ */
+public class ExtendedListenableFuture<T> implements ListenableFuture<T> {
+
+  private final ListenableFuture<T> future;
+
+  public ExtendedListenableFuture(ListenableFuture<T> future) {
+    this.future = future;
+  }
+
+  /**
+   * A wrapper around {@link Futures#transformAsync} that uses the Future It's called on as first
+   * parameter by default. This allows easier chaining.
+   */
+  public <O extends @Nullable Object> ExtendedListenableFuture<O> continueWith(
+      AsyncFunction<T, O> asyncFunction, Executor lExecutor) {
+    ListenableFuture<O> future = Futures.transformAsync(this, asyncFunction, lExecutor);
+    return new ExtendedListenableFuture<>(future);
+  }
+
+  public ExtendedListenableFuture<T> addOnCompleteListener(
+      Callbackable<T> callbackable, Executor executor) {
+    Futures.addCallback(
+        this,
+        new FutureCallback<T>() {
+          @Override
+          public void onSuccess(T result) {
+            callbackable.call(null, result);
+          }
+
+          @Override
+          public void onFailure(Throwable t) {
+            callbackable.call(new Exception(t), null);
+          }
+        },
+        executor);
+    return this;
+  }
+
+  @Override
+  public void addListener(Runnable listener, Executor executor) {
+    future.addListener(listener, executor);
+  }
+
+  @Override
+  public boolean cancel(boolean mayInterruptIfRunning) {
+    return future.cancel(mayInterruptIfRunning);
+  }
+
+  @Override
+  public boolean isCancelled() {
+    return future.isCancelled();
+  }
+
+  @Override
+  public boolean isDone() {
+    return future.isDone();
+  }
+
+  @Override
+  public T get() throws ExecutionException, InterruptedException {
+    return future.get();
+  }
+
+  @Override
+  public T get(long timeout, TimeUnit unit)
+      throws ExecutionException, InterruptedException, TimeoutException {
+    return future.get(timeout, unit);
+  }
+}

package/android/src/main/java/app/notifee/core/utility/IntentUtils.java

@@ -0,0 +1,146 @@
+package app.notifee.core.utility;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static app.notifee.core.ContextHolder.getApplicationContext;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.os.Build;
+import androidx.annotation.Nullable;
+import app.notifee.core.Logger;
+import java.util.List;
+
+public class IntentUtils {
+  private static final String TAG = "IntentUtils";
+
+  @SuppressWarnings("deprecation")
+  public static boolean isAvailableOnDevice(Context ctx, Intent intent) {
+    try {
+      if (ctx == null || intent == null) {
+        return false;
+      }
+
+      final PackageManager mgr = ctx.getPackageManager();
+      List<ResolveInfo> list;
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        list =
+            mgr.queryIntentActivities(
+                intent, PackageManager.ResolveInfoFlags.of(PackageManager.MATCH_DEFAULT_ONLY));
+      } else {
+        list = mgr.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
+      }
+      return !list.isEmpty();
+    } catch (Exception e) {
+      Logger.e(TAG, "An error occurred whilst trying to check if intent is available on device", e);
+
+      return false;
+    }
+  }
+
+  public static String getActivityName(Intent intent) {
+    if (intent == null) {
+      return null;
+    }
+
+    try {
+      String className = intent.getComponent().getClassName();
+      int index = className.lastIndexOf(".");
+
+      if (index != -1) {
+        return className.substring(index + 1);
+      }
+
+    } catch (Exception e) {
+      // noop
+    }
+
+    return null;
+  }
+
+  public static void startActivityOnUiThread(Activity activity, Intent intent) {
+    if (activity == null || intent == null) {
+      Logger.w(TAG, "Activity or intent is null when calling startActivityOnUiThread()");
+      return;
+    }
+
+    Context ctx = getApplicationContext();
+    if (ctx == null) {
+      Logger.w(TAG, "Unable to get application context when calling startActivityOnUiThread()");
+      return;
+    }
+
+    activity.runOnUiThread(
+        () -> {
+          try {
+            ctx.startActivity(intent);
+          } catch (Exception e) {
+            Logger.e(TAG, "An error occurred whilst trying to start activity on Ui Thread", e);
+          }
+        });
+  }
+
+  public static Class<?> getLaunchActivity(@Nullable String launchActivity) {
+    String activity;
+
+    if (launchActivity != null && !launchActivity.equals("default")) {
+      activity = launchActivity;
+    } else {
+      activity = getMainActivityClassName();
+    }
+
+    if (activity == null) {
+      Logger.e("ReceiverService", "Launch Activity for notification could not be found.");
+      return null;
+    }
+
+    Class<?> launchActivityClass = getClassForName(activity);
+
+    if (launchActivityClass == null) {
+      Logger.e(
+          "ReceiverService",
+          String.format("Launch Activity for notification does not exist ('%s').", launchActivity));
+      return null;
+    }
+
+    return launchActivityClass;
+  }
+
+  private @Nullable static Class<?> getClassForName(String className) {
+    try {
+      return Class.forName(className);
+    } catch (ClassNotFoundException e) {
+      return null;
+    }
+  }
+
+  private @Nullable static String getMainActivityClassName() {
+    String packageName = getApplicationContext().getPackageName();
+    Intent launchIntent =
+        getApplicationContext().getPackageManager().getLaunchIntentForPackage(packageName);
+
+    if (launchIntent == null || launchIntent.getComponent() == null) {
+      return null;
+    }
+
+    return launchIntent.getComponent().getClassName();
+  }
+}