react-native-notify-kit 9.1.21 → 9.2.0

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

@@ -0,0 +1,191 @@
+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(@Nullable Object value) {
+    if (value == null) {
+      return 0;
+    }
+
+    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<Object> arrayToMap(Object array) throws IllegalArgumentException {
+    ArrayList<Object> 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<Object> listToMap(List<?> list) throws IllegalArgumentException {
+    ArrayList<Object> 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);
+  }
+}

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

@@ -0,0 +1,338 @@
+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.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.provider.Settings;
+import app.notifee.core.ContextHolder;
+import app.notifee.core.Logger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+
+public class PowerManagerUtils {
+  private static final String TAG = "PowerManagerUtils";
+  private static volatile Intent sPowerManagerIntentCache;
+
+  public static void setPowerManagerIntentCache(Intent intent) {
+    synchronized (PowerManagerUtils.class) {
+      sPowerManagerIntentCache = intent;
+    }
+  }
+
+  public static Intent getPowerManagerIntent() {
+    synchronized (PowerManagerUtils.class) {
+      return sPowerManagerIntentCache;
+    }
+  }
+
+  /**
+   * Attempts to open the device's battery optimization settings
+   *
+   * @param activity
+   */
+  public static void openBatteryOptimizationSettings(Activity activity) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      return;
+    }
+
+    try {
+      Intent intent = new Intent();
+      intent.setAction(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS);
+      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+      if (activity != null) {
+        Boolean isAvailableOnDevice =
+            IntentUtils.isAvailableOnDevice(ContextHolder.getApplicationContext(), intent);
+
+        if (!isAvailableOnDevice) {
+          Logger.d(TAG, "battery optimization settings is not available on device");
+          return;
+        }
+
+        IntentUtils.startActivityOnUiThread(activity, intent);
+      }
+    } catch (Exception e) {
+      Logger.e(TAG, "An error occurred whilst trying to open battery optimization settings", e);
+    }
+  }
+
+  /**
+   * Returns true if the app has battery optimization enabled
+   *
+   * @param context
+   */
+  public static Boolean isBatteryOptimizationEnabled(Context context) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      return false;
+    }
+    PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+    return !pm.isIgnoringBatteryOptimizations(context.getPackageName());
+  }
+
+  /**
+   * Lights up the screen if it is not already lit
+   *
+   * @param context
+   */
+  // FULL_WAKE_LOCK and ON_AFTER_RELEASE are deprecated since API 17, but there is no
+  // non-deprecated wake lock flag that can light up the screen from a Service/BroadcastReceiver
+  // context. WindowManager.FLAG_KEEP_SCREEN_ON requires an Activity.
+  @SuppressWarnings("deprecation")
+  public static void lightUpScreenIfNeeded(Context context) {
+    PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+    Boolean isInteractive = pm.isInteractive();
+
+    if (isInteractive == false) {
+      PowerManager.WakeLock wl =
+          pm.newWakeLock(
+              PowerManager.FULL_WAKE_LOCK
+                  | PowerManager.ACQUIRE_CAUSES_WAKEUP
+                  | PowerManager.ON_AFTER_RELEASE,
+              "Notifee:lock");
+      wl.acquire(3000L);
+
+      PowerManager.WakeLock wl_cpu =
+          pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Notifee:cpuLock");
+      wl_cpu.acquire(3000L);
+    }
+  }
+
+  /**
+   * Retrieves information about the device and its Power Manager Settings
+   *
+   * @return PowerManagerInfo
+   */
+  public static PowerManagerInfo getPowerManagerInfo() {
+    String activityName;
+
+    Intent intent = findPowerManagerIntent(ContextHolder.getApplicationContext());
+    activityName = IntentUtils.getActivityName(intent);
+
+    PowerManagerInfo result =
+        new PowerManagerInfo(Build.MANUFACTURER, Build.MODEL, Build.VERSION.RELEASE, activityName);
+    return result;
+  }
+
+  /**
+   * Attempts to open the device's Power Manager settings
+   *
+   * @param activity
+   */
+  public static void openPowerManagerSettings(Activity activity) {
+    Intent intent = getPowerManagerIntent();
+    if (intent == null) {
+      intent = findPowerManagerIntent(ContextHolder.getApplicationContext());
+    }
+
+    if (intent != null) {
+      try {
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        IntentUtils.startActivityOnUiThread(activity, intent);
+      } catch (Exception exception) {
+        Logger.e(
+            TAG, "Unable to start activity: " + IntentUtils.getActivityName(intent), exception);
+      }
+    } else {
+      Logger.w(TAG, "Unable to find an activity to open the device's power manager");
+    }
+  }
+
+  private static Intent findPowerManagerIntent(Context context) {
+    String manufacturerName = Build.BRAND.toLowerCase(Locale.US);
+    List<Intent> possibleIntents = getManufacturerPowerManagerIntents(manufacturerName);
+
+    for (int i = 0; i < possibleIntents.size(); i++) {
+      Intent possibleIntent = possibleIntents.get(i);
+      Boolean isAvailableOnDevice = IntentUtils.isAvailableOnDevice(context, possibleIntent);
+      if (isAvailableOnDevice) {
+        setPowerManagerIntentCache(possibleIntent);
+        return possibleIntent;
+      }
+    }
+    return null;
+  }
+
+  private static List<Intent> getManufacturerPowerManagerIntents(String manufacturerName) {
+    List<Intent> possibleIntents = new ArrayList<>();
+    switch (manufacturerName) {
+      case "asus":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.asus.mobilemanager",
+                    "com.asus.mobilemanager.powersaver.PowerSaverSettings"),
+                createIntent(
+                    "com.asus.mobilemanager", "com.asus.mobilemanager.autostart.AutoStartActivity"),
+                createIntent(
+                        "com.asus.mobilemanager", "com.asus.mobilemanager.entry.FunctionActivity")
+                    .setData(Uri.parse("mobilemanager://function/entry/AutoStart")));
+        break;
+      case "samsung":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.samsung.android.lool",
+                    "com.samsung.android.sm.ui.battery.BatteryActivity"),
+                createIntent(
+                    "com.samsung.android.sm", "com.samsung.android.sm.ui.battery.BatteryActivity"),
+                createIntent(
+                    "com.samsung.android.lool",
+                    "com.samsung.android.sm.battery.ui.BatteryActivity"));
+        break;
+      case "huawei":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.huawei.systemmanager",
+                    "com.huawei.systemmanager.optimize.process.ProtectActivity"),
+                createIntent(
+                    "com.huawei.systemmanager",
+                    "com.huawei.systemmanager.startupmgr.ui.StartupNormalAppListActivity"),
+                createIntent(
+                    "com.huawei.systemmanager",
+                    "com.huawei.systemmanager.appcontrol.activity.StartupAppControlActivity"));
+        break;
+      case "redmi":
+      case "xiaomi":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.miui.securitycenter",
+                    "com.miui.permcenter.autostart.AutoStartManagementActivity"));
+        break;
+      case "letv":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                        "com.letv.android.letvsafe",
+                        "com.letv.android.letvsafe.AutobootManageActivity")
+                    .setData(Uri.parse("mobilemanager://function/entry/AutoStart")));
+        break;
+      case "honor":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.huawei.systemmanager",
+                    "com.huawei.systemmanager.optimize.process.ProtectActivity"));
+        break;
+      case "coloros":
+      case "oppo":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.coloros.safecenter",
+                    "com.coloros.safecenter.permission.startup.StartupAppListActivity"),
+                createIntent(
+                    "com.oppo.safe", "com.oppo.safe.permission.startup.StartupAppListActivity"),
+                createIntent(
+                        "com.coloros.safecenter",
+                        "com.coloros.safecenter.startupapp.StartupAppListActivity")
+                    .setAction(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS),
+                createIntent(
+                    "com.coloros.oppoguardelf",
+                    "com.coloros.powermanager.fuelgaue.PowerUsageModelActivity"),
+                createIntent(
+                    "com.coloros.oppoguardelf",
+                    "com.coloros.powermanager.fuelgaue.PowerSaverModeActivity"),
+                createIntent(
+                    "com.coloros.oppoguardelf",
+                    "com.coloros.powermanager.fuelgaue.PowerConsumptionActivity"));
+        break;
+      case "vivo":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.iqoo.secure", "com.iqoo.secure.ui.phoneoptimize.AddWhiteListActivity"),
+                createIntent(
+                    "com.vivo.permissionmanager",
+                    "com.vivo.permissionmanager.activity.BgStartUpManagerActivity"),
+                createIntent(
+                    "com.iqoo.secure", "com.iqoo.secure.ui.phoneoptimize.BgStartUpManager"));
+        break;
+      case "nokia":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.evenwell.powersaving.g3",
+                    "com.evenwell.powersaving.g3.exception.PowerSaverExceptionActivity"));
+        break;
+      case "oneplus":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.oneplus.security",
+                    "com.oneplus.security.chainlaunch.view.ChainLaunchAppListActivity"));
+        break;
+      case "meizu":
+        possibleIntents =
+            Arrays.asList(
+                createIntent("com.meizu.safe", "com.meizu.safe.security.SHOW_APPSEC")
+                    .addCategory(Intent.CATEGORY_DEFAULT));
+        break;
+      case "htc":
+        possibleIntents =
+            Arrays.asList(
+                createIntent(
+                    "com.htc.pitroad", "com.htc.pitroad.landingpage.activity.LandingPageActivity"));
+        break;
+      default:
+        break;
+    }
+
+    return possibleIntents;
+  }
+
+  private static Intent createIntent(String pkg, String cls) {
+    Intent intent = new Intent();
+    intent.setComponent(new ComponentName(pkg, cls));
+    return intent;
+  }
+
+  public static class PowerManagerInfo {
+    String manufacturer;
+    String model;
+    String version;
+    String activity;
+
+    public PowerManagerInfo(String manufacturer, String model, String version, String activity) {
+      this.manufacturer = manufacturer;
+      this.model = model;
+      this.version = version;
+      this.activity = activity;
+    }
+
+    public Bundle toBundle() {
+      Bundle bundle = new Bundle();
+      bundle.putString("manufacturer", this.manufacturer);
+      bundle.putString("model", this.model);
+      bundle.putString("version", this.version);
+      bundle.putString("activity", this.activity);
+
+      return bundle;
+    }
+  }
+}