@ammarahmed/notifee-react-native 7.3.0 → 7.4.1

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

@@ -0,0 +1,334 @@
+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
+   */
+  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();
+
+      PowerManager.WakeLock wl_cpu =
+          pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Notifee:cpuLock");
+      wl_cpu.acquire();
+    }
+  }
+
+  /**
+   * 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;
+    }
+  }
+}

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

@@ -0,0 +1,309 @@
+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.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.util.TypedValue;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import app.notifee.core.ContextHolder;
+import app.notifee.core.Logger;
+import com.facebook.common.executors.CallerThreadExecutor;
+import com.facebook.common.references.CloseableReference;
+import com.facebook.datasource.DataSource;
+import com.facebook.drawee.backends.pipeline.Fresco;
+import com.facebook.imagepipeline.datasource.BaseBitmapDataSubscriber;
+import com.facebook.imagepipeline.image.CloseableImage;
+import com.facebook.imagepipeline.request.ImageRequest;
+import com.facebook.imagepipeline.request.ImageRequestBuilder;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ResourceUtils {
+  private static final String TAG = "ResourceUtils";
+  private static final String LOCAL_RESOURCE_SCHEME = "res";
+  private static volatile Map<String, Integer> sResourceIdCache;
+
+  public static Map<String, Integer> getResourceIdCache() {
+    if (sResourceIdCache == null) {
+      synchronized (ResourceUtils.class) {
+        if (sResourceIdCache == null) {
+          sResourceIdCache = new HashMap<>();
+        }
+      }
+    }
+    return sResourceIdCache;
+  }
+
+  public static Uri getImageSourceUri(String source) {
+    try {
+      Uri uri = Uri.parse(source);
+      // verify a scheme is set,
+      // so that relative uri (used by static resources) are not handled
+      if (uri.getScheme() == null) {
+        return getResourceDrawableUri(source);
+      }
+
+      return uri;
+    } catch (Exception e) {
+      return getResourceDrawableUri(source);
+    }
+  }
+
+  public static Uri getResourceDrawableUri(@Nullable String name) {
+    int resId = getResourceIdByName(name, "drawable");
+    return resId > 0
+        ? new Uri.Builder().scheme(LOCAL_RESOURCE_SCHEME).path(String.valueOf(resId)).build()
+        : Uri.EMPTY;
+  }
+
+  /**
+   * Returns a circular Bitmap from another bitmap. The original bitmap can be any shape.
+   *
+   * @param bitmap
+   * @return Bitmap
+   */
+  public static Bitmap getCircularBitmap(Bitmap bitmap) {
+    Bitmap output;
+    Rect srcRect, dstRect;
+    float r;
+    final int width = bitmap.getWidth();
+    final int height = bitmap.getHeight();
+
+    if (width > height) {
+      output = Bitmap.createBitmap(height, height, Bitmap.Config.ARGB_8888);
+      int left = (width - height) / 2;
+      int right = left + height;
+      srcRect = new Rect(left, 0, right, height);
+      dstRect = new Rect(0, 0, height, height);
+      r = height / 2;
+    } else {
+      output = Bitmap.createBitmap(width, width, Bitmap.Config.ARGB_8888);
+      int top = (height - width) / 2;
+      int bottom = top + width;
+      srcRect = new Rect(0, top, width, bottom);
+      dstRect = new Rect(0, 0, width, width);
+      r = width / 2;
+    }
+
+    final Canvas canvas = new Canvas(output);
+
+    final int color = Color.RED;
+    final Paint paint = new Paint();
+
+    paint.setAntiAlias(true);
+    canvas.drawARGB(0, 0, 0, 0);
+    paint.setColor(color);
+    canvas.drawCircle(r, r, r, paint);
+    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
+    canvas.drawBitmap(bitmap, srcRect, dstRect, paint);
+
+    return output;
+  }
+
+  /**
+   * Returns a Bitmap from any given HTTP image URL, or local resource.
+   *
+   * @param imageUrl
+   * @return Bitmap or null if the image failed to load
+   */
+  public static ListenableFuture<Bitmap> getImageBitmapFromUrl(
+    String imageUrl) {
+    Uri imageUri;
+    final SettableFuture<Bitmap> bitmapTCS = SettableFuture.create();
+
+    if (!imageUrl.contains("/")) {
+      String imageResourceUrl = getImageResourceUrl(imageUrl);
+      if (imageResourceUrl == null) {
+        bitmapTCS.set(null);
+        return bitmapTCS;
+      }
+      imageUri = getImageSourceUri(imageResourceUrl);
+    } else {
+      imageUri = getImageSourceUri(imageUrl);
+    }
+
+    ImageRequest imageRequest = ImageRequestBuilder.newBuilderWithSource(imageUri).build();
+
+    // TODO(helenaford): handle destroying of fresco after use in background state
+    // Needed when the app is killed, and the Fresco hasn't yet been initialized by React Native
+    if (!Fresco.hasBeenInitialized()) {
+      Logger.w(TAG, "Fresco initializing natively by Notifee");
+
+      // TODO(helenaford): expand on this to initialize with a custom imagePipelineConfig
+      Fresco.initialize(ContextHolder.getApplicationContext());
+    }
+
+    DataSource<CloseableReference<CloseableImage>> dataSource =
+        Fresco.getImagePipeline()
+            .fetchDecodedImage(imageRequest, ContextHolder.getApplicationContext());
+
+    dataSource.subscribe(
+        new BaseBitmapDataSubscriber() {
+          @Override
+          protected void onNewResultImpl(@Nullable Bitmap bitmap) {
+            bitmapTCS.set(bitmap);
+          }
+
+          @Override
+          protected void onFailureImpl(
+              @NonNull DataSource<CloseableReference<CloseableImage>> dataSource) {
+            Logger.e(TAG, "Failed to load an image: " + imageUrl, dataSource.getFailureCause());
+            bitmapTCS.set(null);
+          }
+        },
+        CallerThreadExecutor.getInstance());
+
+    return bitmapTCS;
+  }
+
+  /**
+   * Returns a resource path for a local resource
+   *
+   * @param icon
+   * @return
+   */
+  private static String getImageResourceUrl(String icon) {
+    int resourceId = getResourceIdByName(icon, "mipmap");
+
+    if (resourceId == 0) {
+      resourceId = getResourceIdByName(icon, "drawable");
+    }
+
+    if (resourceId == 0) {
+      return null;
+    }
+
+    return resourceId > 0
+        ? new Uri.Builder()
+            .scheme(LOCAL_RESOURCE_SCHEME)
+            .path(String.valueOf(resourceId))
+            .build()
+            .toString()
+        : Uri.EMPTY.toString();
+  }
+
+  /**
+   * Gets a resource ID by name.
+   *
+   * @param resourceName
+   * @return integer or 0 if not found
+   */
+  public static int getImageResourceId(String resourceName) {
+    int resourceId = getResourceIdByName(resourceName, "mipmap");
+    if (resourceId == 0) {
+      resourceId = getResourceIdByName(resourceName, "drawable");
+    }
+
+    return resourceId;
+  }
+
+  /** Attempts to find a resource id by name and type */
+  private static int getResourceIdByName(String name, String type) {
+    if (name == null || name.isEmpty()) {
+      return 0;
+    }
+
+    name = name.toLowerCase().replace("-", "_");
+
+    String key = name + "_" + type;
+
+    synchronized (ResourceUtils.class) {
+      if (getResourceIdCache().containsKey(key)) {
+        // noinspection ConstantConditions
+        return getResourceIdCache().get(key);
+      }
+
+      Context context = ContextHolder.getApplicationContext();
+      String packageName = context.getPackageName();
+
+      int id = context.getResources().getIdentifier(name, type, packageName);
+      getResourceIdCache().put(key, id);
+      return id;
+    }
+  }
+
+  public static @Nullable String getSoundName(Uri sound) {
+    if (sound == null) return null;
+    if (sound.toString().contains("android.resource")) {
+      String soundFile = sound.getLastPathSegment();
+      try {
+        int resourceId = Integer.valueOf(soundFile);
+        Logger.e(
+            TAG,
+            "Loaded sound by resource id. New app builds will fail to play sound. Create a new"
+                + " channel to resolve. Issue #341");
+        if (resourceId != 0) {
+          TypedValue value = new TypedValue();
+          Context context = ContextHolder.getApplicationContext();
+          context.getResources().getValue(resourceId, value, true);
+
+          CharSequence soundString = value.string;
+          if (soundString != null || soundString.length() > 0) {
+            return soundString.toString().replace("res/raw/", "");
+          }
+        }
+      } catch (NumberFormatException nfe) {
+        // This implies the sound URI last path segment was by file name, not resourceId
+        // They were by resourceId prior to issue #341 where we learned that leads to unstable URIs
+        // Now we verify the file exists but use the file name from the raw directory
+        // We still attempt to resolve by resourceId above to gracefully handle URIs created via our
+        // previous behavior
+        return soundFile;
+      }
+    }
+
+    // TODO parse system sounds
+    return null;
+  }
+
+  public static @Nullable Uri getSoundUri(String sound) {
+    Context context = ContextHolder.getApplicationContext();
+    if (sound == null) {
+      return null;
+    } else if (sound.contains("://")) {
+      return Uri.parse(sound);
+    } else if (sound.equalsIgnoreCase("default")) {
+      return RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+    } else {
+      // The API user is attempting to set a sound by file name, verify it exists
+      int soundResourceId = getResourceIdByName(sound, "raw");
+      if (soundResourceId == 0 && sound.contains(".")) {
+        soundResourceId = getResourceIdByName(sound.substring(0, sound.lastIndexOf('.')), "raw");
+      }
+
+      if (soundResourceId == 0) {
+        return null;
+      }
+
+      // Use the actual sound name vs the resource ID, to obtain a stable URI, Issue #341
+      return Uri.parse("android.resource://" + context.getPackageName() + "/raw/" + sound);
+    }
+  }
+}

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

@@ -0,0 +1,28 @@
+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.text.Spanned;
+import androidx.core.text.HtmlCompat;
+
+public class TextUtils {
+
+  public static Spanned fromHtml(String text) {
+    return HtmlCompat.fromHtml(text, HtmlCompat.FROM_HTML_MODE_LEGACY);
+  }
+}

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

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

package/dist/types/Notification.d.ts

@@ -325,7 +325,13 @@ export declare enum EventType {
     /**
      * Event type is sent when a notification trigger is created.
      */
-    TRIGGER_NOTIFICATION_CREATED = 7
+    TRIGGER_NOTIFICATION_CREATED = 7,
+    /**
+     * **ANDROID ONLY**
+     *
+     * Event type is sent when a notification wants to start a foreground service but a foreground service is already started.
+     */
+    FG_ALREADY_EXIST = 8
 }
 /**
  * An interface representing the different detail values which can be provided with a notification event.
@@ -343,6 +349,7 @@ export interface EventDetail {
      *  - [`EventType.ACTION_PRESS`](/react-native/reference/eventtype#action_press)
      *  - [`EventType.DELIVERED`](/react-native/reference/eventtype#delivered)
      *  - [`EventType.TRIGGER_NOTIFICATION_CREATED`](/react-native/reference/eventtype#trigger_notification_created)
+     *  - [`EventType.FG_ALREADY_EXIST`](/react-native/reference/eventtype#fg_already_exist)
      */
     notification?: Notification;
     /**