@ammarahmed/notifee-react-native 7.3.1 → 7.4.2

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

@@ -0,0 +1,163 @@
+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.concurrent.TimeUnit;
+
+public class TimestampTriggerModel {
+  private Bundle mTimeTriggerBundle;
+  private int mInterval = -1;
+  private TimeUnit mTimeUnit = null;
+  private Boolean mWithAlarmManager = false;
+  private Boolean mAllowWhileIdle = false;
+  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 int MINUTES_IN_MS = 60 * 1000;
+  private static final long HOUR_IN_MS = 60 * MINUTES_IN_MS;
+  private static final long DAY_IN_MS = 24 * HOUR_IN_MS;
+
+  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");
+
+      if (alarmManagerBundle.containsKey("allowWhileIdle")) {
+        mAllowWhileIdle = alarmManagerBundle.getBoolean("allowWhileIdle");
+      }
+    } else if (mTimeTriggerBundle.containsKey("allowWhileIdle")) {
+      mWithAlarmManager = true;
+      mAllowWhileIdle = mTimeTriggerBundle.getBoolean("allowWhileIdle");
+    }
+  }
+
+  public static TimestampTriggerModel fromBundle(@NonNull Bundle bundle) {
+    return new TimestampTriggerModel(bundle);
+  }
+
+  public long getTimestamp() {
+    return mTimestamp;
+  }
+
+  public long getDelay() {
+    long delay = 0;
+
+    if (mTimeTriggerBundle.containsKey("timestamp")) {
+      long timestamp = ObjectUtils.getLong(mTimeTriggerBundle.get("timestamp"));
+      if (timestamp > 0) {
+        delay = Math.round((timestamp - System.currentTimeMillis()) / 1000);
+      }
+    }
+
+    return delay;
+  }
+
+  public void setNextTimestamp() {
+    // Skip for non-repeating triggers
+    if (mRepeatFrequency == null) {
+      return;
+    }
+
+    long timestamp = getTimestamp();
+    long interval = 0;
+
+    switch (mRepeatFrequency) {
+      case TimestampTriggerModel.WEEKLY:
+        interval = 7 * DAY_IN_MS;
+        break;
+      case TimestampTriggerModel.DAILY:
+        interval = DAY_IN_MS;
+        break;
+      case TimestampTriggerModel.HOURLY:
+        interval = HOUR_IN_MS;
+        break;
+    }
+
+    // prevent alarm manager notification firing straight away
+    while (timestamp < System.currentTimeMillis()) {
+      timestamp += interval;
+    }
+
+    this.mTimestamp = timestamp;
+  }
+
+  public int getInterval() {
+    return mInterval;
+  }
+
+  public TimeUnit getTimeUnit() {
+    return mTimeUnit;
+  }
+
+  public Boolean getWithAlarmManager() {
+    return mWithAlarmManager;
+  }
+
+  public Boolean getAllowWhileIdle() {
+    return mAllowWhileIdle;
+  }
+
+  public String getRepeatFrequency() {
+    return mRepeatFrequency;
+  }
+
+  public Bundle toBundle() {
+    return (Bundle) mTimeTriggerBundle.clone();
+  }
+}

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,136 @@
+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 androidx.annotation.Nullable;
+import app.notifee.core.Logger;
+import java.util.List;
+
+public class IntentUtils {
+  private static final String TAG = "IntentUtils";
+
+  public static boolean isAvailableOnDevice(Context ctx, Intent intent) {
+    try {
+      if (ctx == null || intent == null) {
+        return false;
+      }
+
+      final PackageManager mgr = ctx.getPackageManager();
+      List<ResolveInfo> list = mgr.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
+      return list.size() > 0;
+    } 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()");
+    }
+
+    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();
+  }
+}

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

@@ -0,0 +1,187 @@
+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.os.Bundle;
+import android.os.Parcel;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class ObjectUtils {
+
+  public static @Nullable Class getClassForName(String className) {
+    try {
+      return Class.forName(className);
+    } catch (ClassNotFoundException e) {
+      return null;
+    }
+  }
+
+  public static @Nullable Object getClassInstanceFromDefaultConstructor(@Nullable Class clazz) {
+    Object classInstance = null;
+    if (clazz == null) return null;
+    try {
+      classInstance = clazz.getConstructors()[0].newInstance();
+    } catch (IllegalAccessException e) {
+      // noop
+    } catch (InstantiationException e) {
+      // noop
+    } catch (InvocationTargetException e) {
+      // noop
+    }
+    return classInstance;
+  }
+
+  public static Map<String, Object> getClassProperties(Class clazz) {
+    Map<String, Object> properties = new HashMap<>();
+    try {
+      for (Field field : clazz.getDeclaredFields()) {
+        field.setAccessible(true);
+        Object value = field.get(clazz);
+        if (value != null) {
+          properties.put(field.getName(), value);
+        }
+      }
+    } catch (IllegalAccessException exception) {
+      return null;
+    }
+    return properties;
+  }
+
+  public static int getInt(Object value) {
+    if (value instanceof Double) {
+      return (int) ((Double) value).doubleValue();
+    }
+
+    return (int) value;
+  }
+
+  public static long getLong(Object value) {
+    if (value instanceof Double) {
+      return (long) ((Double) value).doubleValue();
+    }
+
+    return (long) value;
+  }
+
+  public static byte[] bundleToBytes(@NonNull Bundle bundle) {
+    Parcel parcel = Parcel.obtain();
+    parcel.writeBundle(bundle);
+    byte[] bytes = parcel.marshall();
+    parcel.recycle();
+    return bytes;
+  }
+
+  @NonNull
+  public static Bundle bytesToBundle(byte[] bytes) {
+    Parcel parcel = Parcel.obtain();
+    parcel.unmarshall(bytes, 0, bytes.length);
+    parcel.setDataPosition(0);
+    Bundle bundle = parcel.readBundle(ObjectUtils.class.getClassLoader());
+    parcel.recycle();
+    return Objects.requireNonNull(bundle);
+  }
+
+  public static Map<String, Object> bundleToMap(Bundle bundle) throws IllegalArgumentException {
+    Map<String, Object> map = new HashMap<>();
+    for (String key : bundle.keySet()) {
+      Object value = bundle.get(key);
+      if (value == null) {
+        map.put(key, null);
+      } else if (value.getClass().isArray()) {
+        map.put(key, arrayToMap(value));
+      } else if (value instanceof Bundle) {
+        map.put(key, bundleToMap((Bundle) value));
+      } else if (value instanceof List) {
+        map.put(key, listToMap((List) value));
+      } else {
+        map.put(key, value);
+      }
+    }
+    return map;
+  }
+
+  public static ArrayList arrayToMap(Object array) throws IllegalArgumentException {
+    ArrayList catalystArray = new ArrayList();
+    if (array instanceof String[]) {
+      for (String v : (String[]) array) {
+        catalystArray.add(v);
+      }
+    } else if (array instanceof Bundle[]) {
+      for (Bundle v : (Bundle[]) array) {
+        catalystArray.add(ObjectUtils.bundleToMap(v));
+      }
+    } else if (array instanceof int[]) {
+      for (int v : (int[]) array) {
+        catalystArray.add(v);
+      }
+    } else if (array instanceof float[]) {
+      for (float v : (float[]) array) {
+        catalystArray.add(v);
+      }
+    } else if (array instanceof double[]) {
+      for (double v : (double[]) array) {
+        catalystArray.add(v);
+      }
+    } else if (array instanceof boolean[]) {
+      for (boolean v : (boolean[]) array) {
+        catalystArray.add(v);
+      }
+    } else {
+      throw new IllegalArgumentException("Unknown array type " + array.getClass());
+    }
+    return catalystArray;
+  }
+
+  public static ArrayList listToMap(List list) throws IllegalArgumentException {
+    ArrayList catalystArray = new ArrayList();
+    for (Object obj : list) {
+      if (obj == null) {
+        catalystArray.add(null);
+      } else if (obj.getClass().isArray()) {
+        catalystArray.add(arrayToMap(obj));
+      } else if (obj instanceof Bundle) {
+        catalystArray.add(ObjectUtils.bundleToMap((Bundle) obj));
+      } else if (obj instanceof List) {
+        catalystArray.add(listToMap((List) obj));
+      } else if (obj instanceof String) {
+        catalystArray.add((String) obj);
+      } else if (obj instanceof Integer) {
+        catalystArray.add((Integer) obj);
+      } else if (obj instanceof Number) {
+        catalystArray.add(((Number) obj).doubleValue());
+      } else if (obj instanceof Boolean) {
+        catalystArray.add((Boolean) obj);
+      } else {
+        throw new IllegalArgumentException("Unknown value type " + obj.getClass());
+      }
+    }
+    return catalystArray;
+  }
+
+  public interface TypedCallback<T> {
+    void call(T t);
+  }
+}