@psync/notifee 9.2.0

package/android/src/main/java/io/invertase/notifee/NotifeeApiModule.java

@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee;
+
+import android.Manifest;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import app.notifee.core.Logger;
+import app.notifee.core.Notifee;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+public class NotifeeApiModule extends ReactContextBaseJavaModule implements PermissionListener {
+  private static final int NOTIFICATION_TYPE_DISPLAYED = 1;
+  private static final int NOTIFICATION_TYPE_TRIGGER = 2;
+  private static final int NOTIFICATION_TYPE_ALL = 0;
+
+  public NotifeeApiModule(@NonNull ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  public static String getMainComponent(@NonNull String defaultComponent) {
+    return Notifee.getInstance().getMainComponent(defaultComponent);
+  }
+
+  // This method was removed upstream in react-native 0.74+, replaced with invalidate
+  // We will leave this stub here for older react-native versions compatibility
+  // ...but it will just delegate to the new invalidate method
+  public void onCatalystInstanceDestroy() {
+    invalidate();
+  }
+
+  // This method was added in react-native 0.74 as a replacement for onCatalystInstanceDestroy
+  // It should be marked @Override but that would cause problems in apps using older react-native
+  // When minimum supported version is 0.74+ add @Override & remove onCatalystInstanceDestroy
+  public void invalidate() {
+    NotifeeReactUtils.headlessTaskManager.stopAllTasks();
+  }
+
+  @ReactMethod
+  public void cancelAllNotifications(Promise promise) {
+    Notifee.getInstance()
+        .cancelAllNotifications(
+            NOTIFICATION_TYPE_ALL, (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void cancelDisplayedNotifications(Promise promise) {
+    Notifee.getInstance()
+        .cancelAllNotifications(
+            NOTIFICATION_TYPE_DISPLAYED,
+            (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void cancelTriggerNotifications(Promise promise) {
+    Notifee.getInstance()
+        .cancelAllNotifications(
+            NOTIFICATION_TYPE_TRIGGER, (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void cancelAllNotificationsWithIds(
+      ReadableArray idsArray, int notificationType, String tag, Promise promise) {
+    ArrayList<String> ids = new ArrayList<>(idsArray.size());
+    for (int i = 0; i < idsArray.size(); i++) {
+      ids.add(idsArray.getString(i));
+    }
+
+    Notifee.getInstance()
+        .cancelAllNotificationsWithIds(
+            notificationType,
+            ids,
+            tag,
+            (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void getDisplayedNotifications(Promise promise) {
+    Notifee.getInstance()
+        .getDisplayedNotifications(
+            (e, aBundleList) -> NotifeeReactUtils.promiseResolver(promise, e, aBundleList));
+  }
+
+  @ReactMethod
+  public void getTriggerNotifications(Promise promise) {
+    Notifee.getInstance()
+        .getTriggerNotifications(
+            (e, aBundleList) -> NotifeeReactUtils.promiseResolver(promise, e, aBundleList));
+  }
+
+  @ReactMethod
+  public void getTriggerNotificationIds(Promise promise) {
+    Notifee.getInstance()
+        .getTriggerNotificationIds(
+            (e, aStringList) ->
+                NotifeeReactUtils.promiseStringListResolver(promise, e, aStringList));
+  }
+
+  @ReactMethod
+  public void createChannel(ReadableMap channelMap, Promise promise) {
+    Notifee.getInstance()
+        .createChannel(
+            Arguments.toBundle(channelMap),
+            (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void createChannels(ReadableArray channelsArray, Promise promise) {
+    ArrayList<Bundle> channels = new ArrayList<>(channelsArray.size());
+    for (int i = 0; i < channelsArray.size(); i++) {
+      channels.add(Arguments.toBundle(channelsArray.getMap(i)));
+    }
+
+    Notifee.getInstance()
+        .createChannels(channels, (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void createChannelGroup(ReadableMap channelGroupMap, Promise promise) {
+    Notifee.getInstance()
+        .createChannelGroup(
+            Arguments.toBundle(channelGroupMap),
+            (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void createChannelGroups(ReadableArray channelGroupsArray, Promise promise) {
+    ArrayList<Bundle> channelGroups = new ArrayList<>(channelGroupsArray.size());
+
+    for (int i = 0; i < channelGroupsArray.size(); i++) {
+      channelGroups.add(Arguments.toBundle(channelGroupsArray.getMap(i)));
+    }
+
+    Notifee.getInstance()
+        .createChannelGroups(
+            channelGroups, (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void deleteChannel(String channelId, Promise promise) {
+    Notifee.getInstance()
+        .deleteChannel(channelId, (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void deleteChannelGroup(String channelId, Promise promise) {
+    Notifee.getInstance()
+        .deleteChannelGroup(channelId, (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void displayNotification(ReadableMap notificationMap, Promise promise) {
+    Notifee.getInstance()
+        .displayNotification(
+            Arguments.toBundle(notificationMap),
+            (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void openAlarmPermissionSettings(Promise promise) {
+    Notifee.getInstance()
+        .openAlarmPermissionSettings(
+            getCurrentActivity(), (e, avoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void createTriggerNotification(
+      ReadableMap notificationMap, ReadableMap triggerMap, Promise promise) {
+    Notifee.getInstance()
+        .createTriggerNotification(
+            Arguments.toBundle(notificationMap),
+            Arguments.toBundle(triggerMap),
+            (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void getChannels(Promise promise) {
+    Notifee.getInstance()
+        .getChannels(
+            (e, aBundleList) -> NotifeeReactUtils.promiseResolver(promise, e, aBundleList));
+  }
+
+  @ReactMethod
+  public void getChannel(String channelId, Promise promise) {
+    Notifee.getInstance()
+        .getChannel(
+            channelId, (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+  }
+
+  @ReactMethod
+  public void getChannelGroups(Promise promise) {
+    Notifee.getInstance()
+        .getChannelGroups(
+            (e, aBundleList) -> NotifeeReactUtils.promiseResolver(promise, e, aBundleList));
+  }
+
+  @ReactMethod
+  public void getChannelGroup(String channelGroupId, Promise promise) {
+    Notifee.getInstance()
+        .getChannel(
+            channelGroupId, (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+  }
+
+  @ReactMethod
+  public void isChannelCreated(String channelId, Promise promise) {
+    Notifee.getInstance()
+        .isChannelCreated(
+            channelId, (e, aBool) -> NotifeeReactUtils.promiseBooleanResolver(promise, e, aBool));
+  }
+
+  @ReactMethod
+  public void isChannelBlocked(String channelId, Promise promise) {
+    Notifee.getInstance()
+        .isChannelBlocked(
+            channelId, (e, aBool) -> NotifeeReactUtils.promiseBooleanResolver(promise, e, aBool));
+  }
+
+  @ReactMethod
+  public void getInitialNotification(Promise promise) {
+    Notifee.getInstance()
+        .getInitialNotification(
+            getCurrentActivity(),
+            (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+  }
+
+  @ReactMethod
+  public void getNotificationSettings(Promise promise) {
+    Notifee.getInstance()
+        .getNotificationSettings(
+            (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+  }
+
+  @ReactMethod
+  public void requestPermission(Promise promise) {
+    // For Android 12 and below, we return the notification settings
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+      Notifee.getInstance()
+          .getNotificationSettings(
+              (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+      return;
+    }
+
+    // We have to handle this logic outside of our core module due to a react-native limitation
+    // with obtaining the correct activity
+    PermissionAwareActivity activity = (PermissionAwareActivity) getCurrentActivity();
+    if (activity == null) {
+      Logger.d(
+          "requestPermission",
+          "Unable to get permissionAwareActivity for " + Build.VERSION.SDK_INT);
+
+      Notifee.getInstance()
+          .getNotificationSettings(
+              (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+      return;
+    }
+
+    // Setting the request permission callback before attempting to call requestPermissions
+    Notifee.getInstance()
+        .setRequestPermissionCallback(
+            (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+
+    try {
+      activity.requestPermissions(
+          new String[] {Manifest.permission.POST_NOTIFICATIONS},
+          Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION,
+          this);
+    } catch (Exception e) {
+      Logger.d(
+          "requestPermission",
+          "Failed to request POST_NOTIFICATIONS permission: " + e.getMessage());
+      NotifeeReactUtils.promiseResolver(promise, e);
+    }
+  }
+
+  @ReactMethod
+  public void openNotificationSettings(String channelId, Promise promise) {
+    Notifee.getInstance()
+        .openNotificationSettings(
+            channelId,
+            getCurrentActivity(),
+            (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void openBatteryOptimizationSettings(Promise promise) {
+    Notifee.getInstance()
+        .openBatteryOptimizationSettings(
+            getCurrentActivity(), (e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void isBatteryOptimizationEnabled(Promise promise) {
+    Notifee.getInstance()
+        .isBatteryOptimizationEnabled(
+            (e, aBool) -> NotifeeReactUtils.promiseBooleanResolver(promise, e, aBool));
+  }
+
+  @ReactMethod
+  public void getPowerManagerInfo(Promise promise) {
+    Notifee.getInstance()
+        .getPowerManagerInfo(
+            (e, aBundle) -> NotifeeReactUtils.promiseResolver(promise, e, aBundle));
+  }
+
+  @ReactMethod
+  public void openPowerManagerSettings(Promise promise) {
+    Notifee.getInstance()
+        .openPowerManagerSettings(
+            getCurrentActivity(), (e, avoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void stopForegroundService(Promise promise) {
+    Notifee.getInstance()
+        .stopForegroundService((e, aVoid) -> NotifeeReactUtils.promiseResolver(promise, e));
+  }
+
+  @ReactMethod
+  public void hideNotificationDrawer() {
+    NotifeeReactUtils.hideNotificationDrawer();
+  }
+
+  @ReactMethod
+  public void addListener(String eventName) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return "NotifeeApiModule";
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    Map<String, Object> constants = new HashMap<>();
+    constants.put("ANDROID_API_LEVEL", android.os.Build.VERSION.SDK_INT);
+    return constants;
+  }
+
+  @Override
+  public boolean onRequestPermissionsResult(
+      int requestCode, String[] permissions, int[] grantResults) {
+    return Notifee.getInstance().onRequestPermissionsResult(requestCode, permissions, grantResults);
+  }
+}

package/android/src/main/java/io/invertase/notifee/NotifeeEventSubscriber.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee;
+
+import static io.invertase.notifee.NotifeeReactUtils.isAppInForeground;
+
+import android.os.Bundle;
+import androidx.annotation.Keep;
+import app.notifee.core.event.BlockStateEvent;
+import app.notifee.core.event.ForegroundServiceEvent;
+import app.notifee.core.event.LogEvent;
+import app.notifee.core.event.NotificationEvent;
+import app.notifee.core.interfaces.EventListener;
+import app.notifee.core.model.NotificationModel;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+@Keep
+public class NotifeeEventSubscriber implements EventListener {
+  static final String NOTIFICATION_EVENT_KEY = "app.notifee.notification-event";
+  static final String FOREGROUND_NOTIFICATION_TASK_KEY =
+      "app.notifee.foreground-service-headless-task";
+
+  private static final String KEY_TYPE = "type";
+  private static final String KEY_DETAIL = "detail";
+  private static final String KEY_BLOCKED = "blocked";
+  private static final String KEY_HEADLESS = "headless";
+  private static final String KEY_NOTIFICATION = "notification";
+
+  private static final String KEY_DETAIL_PRESS_ACTION = "pressAction";
+  private static final String KEY_DETAIL_INPUT = "input";
+
+  @Override
+  public void onNotificationEvent(NotificationEvent notificationEvent) {
+    WritableMap eventMap = Arguments.createMap();
+    WritableMap eventDetailMap = Arguments.createMap();
+    eventMap.putInt(KEY_TYPE, notificationEvent.getType());
+
+    eventDetailMap.putMap(
+        KEY_NOTIFICATION, Arguments.fromBundle(notificationEvent.getNotification().toBundle()));
+
+    Bundle extras = notificationEvent.getExtras();
+    if (extras != null) {
+      Bundle pressAction = extras.getBundle(KEY_DETAIL_PRESS_ACTION);
+      if (pressAction != null) {
+        eventDetailMap.putMap(KEY_DETAIL_PRESS_ACTION, Arguments.fromBundle(pressAction));
+      }
+
+      String input = extras.getString(KEY_DETAIL_INPUT);
+      if (input != null) {
+        eventDetailMap.putString(KEY_DETAIL_INPUT, input);
+      }
+    }
+
+    eventMap.putMap(KEY_DETAIL, eventDetailMap);
+
+    if (isAppInForeground()) {
+      eventMap.putBoolean(KEY_HEADLESS, false);
+      NotifeeReactUtils.sendEvent(NOTIFICATION_EVENT_KEY, eventMap);
+    } else {
+      eventMap.putBoolean(KEY_HEADLESS, true);
+      NotifeeReactUtils.startHeadlessTask(NOTIFICATION_EVENT_KEY, eventMap, 60000, null);
+    }
+  }
+
+  @Override
+  public void onLogEvent(LogEvent logEvent) {
+    // TODO
+  }
+
+  @Override
+  public void onBlockStateEvent(BlockStateEvent blockStateEvent) {
+    WritableMap eventMap = Arguments.createMap();
+    WritableMap eventDetailMap = Arguments.createMap();
+
+    eventMap.putInt(KEY_TYPE, blockStateEvent.getType());
+
+    int type = blockStateEvent.getType();
+
+    if (type == BlockStateEvent.TYPE_CHANNEL_BLOCKED
+        || type == BlockStateEvent.TYPE_CHANNEL_GROUP_BLOCKED) {
+      String mapKey = type == BlockStateEvent.TYPE_CHANNEL_BLOCKED ? "channel" : "channelGroup";
+      Bundle channelOrGroupBundle = blockStateEvent.getChannelOrGroupBundle();
+      if (channelOrGroupBundle != null) {
+        eventDetailMap.putMap(
+            mapKey, Arguments.fromBundle(blockStateEvent.getChannelOrGroupBundle()));
+      }
+    }
+
+    if (type == BlockStateEvent.TYPE_APP_BLOCKED) {
+      eventDetailMap.putBoolean(KEY_BLOCKED, blockStateEvent.isBlocked());
+    }
+
+    eventMap.putMap(KEY_DETAIL, eventDetailMap);
+
+    if (isAppInForeground()) {
+      eventMap.putBoolean(KEY_HEADLESS, false);
+      NotifeeReactUtils.sendEvent(NOTIFICATION_EVENT_KEY, eventMap);
+    } else {
+      eventMap.putBoolean(KEY_HEADLESS, true);
+      NotifeeReactUtils.startHeadlessTask(
+          NOTIFICATION_EVENT_KEY, eventMap, 0, blockStateEvent::setCompletionResult);
+    }
+  }
+
+  @Override
+  public void onForegroundServiceEvent(ForegroundServiceEvent foregroundServiceEvent) {
+    NotificationModel notificationBundle = foregroundServiceEvent.getNotification();
+
+    WritableMap eventMap = Arguments.createMap();
+    eventMap.putMap(KEY_NOTIFICATION, Arguments.fromBundle(notificationBundle.toBundle()));
+
+    NotifeeReactUtils.startHeadlessTask(
+        FOREGROUND_NOTIFICATION_TASK_KEY, eventMap, 0, foregroundServiceEvent::setCompletionResult);
+  }
+}

package/android/src/main/java/io/invertase/notifee/NotifeeInitProvider.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import app.notifee.core.InitProvider;
+import app.notifee.core.Notifee;
+import com.facebook.react.modules.systeminfo.ReactNativeVersion;
+import java.util.Map;
+
+public class NotifeeInitProvider extends InitProvider {
+  @Override
+  public boolean onCreate() {
+    boolean onCreate = super.onCreate();
+
+    Notifee.initialize(new NotifeeEventSubscriber());
+    return onCreate;
+  }
+
+  private String getApplicationVersionString() {
+    String version = "unknown";
+    Context context = this.getContext();
+    if (context != null) {
+      PackageManager pm = context.getPackageManager();
+      try {
+        PackageInfo pInfo = pm.getPackageInfo(context.getPackageName(), 0);
+        version = pInfo.versionName;
+      } catch (Exception e) {
+        // is there anything useful to log the unbelievably unexpected inability to get package
+        // info?
+      }
+    }
+
+    return version;
+  }
+
+  private String getReactNativeVersionString() {
+    Map<String, Object> versionMap = ReactNativeVersion.VERSION;
+    int major = (int) versionMap.get("major");
+    int minor = (int) versionMap.get("minor");
+    int patch = (int) versionMap.get("patch");
+    String prerelease = (String) versionMap.get("prerelease");
+
+    String versionName = major + "." + minor + "." + patch;
+    if (prerelease != null) {
+      versionName += "." + prerelease;
+    }
+
+    return versionName;
+  }
+}

package/android/src/main/java/io/invertase/notifee/NotifeePackage.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Nonnull;
+
+public class NotifeePackage implements ReactPackage {
+  @Nonnull
+  @Override
+  public List<NativeModule> createNativeModules(@Nonnull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new NotifeeApiModule(reactContext));
+    return modules;
+  }
+
+  @Nonnull
+  @Override
+  public List<ViewManager> createViewManagers(@Nonnull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/android/src/main/java/io/invertase/notifee/NotifeeReactUtils.java

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+package io.invertase.notifee;
+
+import static io.invertase.notifee.HeadlessTask.getReactContext;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.ProcessLifecycleOwner;
+import app.notifee.core.EventSubscriber;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import java.lang.reflect.Method;
+import java.util.List;
+
+class NotifeeReactUtils {
+  public static final HeadlessTask headlessTaskManager = new HeadlessTask();
+
+  static void promiseResolver(Promise promise, Exception e, Bundle bundle) {
+    if (e != null) {
+      // TODO custom error class with message/code
+      promise.reject(e);
+    } else if (bundle != null) {
+      promise.resolve(Arguments.fromBundle(bundle));
+    } else {
+      promise.resolve(null);
+    }
+  }
+
+  static void promiseResolver(Promise promise, Exception e, List<Bundle> bundleList) {
+    if (e != null) {
+      // TODO custom error class with message/code
+      promise.reject(e);
+    } else {
+      WritableArray writableArray = Arguments.createArray();
+      for (Bundle bundle : bundleList) {
+        writableArray.pushMap(Arguments.fromBundle(bundle));
+      }
+      promise.resolve(writableArray);
+    }
+  }
+
+  static void promiseBooleanResolver(Promise promise, Exception e, Boolean bool) {
+    if (e != null) {
+      // TODO custom error class with message/code
+      promise.reject(e);
+    } else {
+      promise.resolve(bool);
+    }
+  }
+
+  static void promiseStringListResolver(Promise promise, Exception e, List<String> stringList) {
+    if (e != null) {
+      // TODO custom error class with message/code
+      promise.reject(e);
+    } else {
+      WritableArray writableArray = Arguments.createArray();
+      for (String string : stringList) {
+        writableArray.pushString(string);
+      }
+      promise.resolve(writableArray);
+    }
+  }
+
+  static void promiseResolver(Promise promise, Exception e) {
+    if (e != null) {
+      // TODO custom error class with message/code
+      promise.reject(e);
+    } else {
+      promise.resolve(null);
+    }
+  }
+
+  static void startHeadlessTask(
+      String taskName,
+      WritableMap taskData,
+      long taskTimeout,
+      @Nullable HeadlessTask.GenericCallback taskCompletionCallback) {
+
+    HeadlessTask.TaskConfig config =
+        new HeadlessTask.TaskConfig(taskName, taskTimeout, taskData, taskCompletionCallback);
+    headlessTaskManager.startTask(EventSubscriber.getContext(), config);
+  }
+
+  static void sendEvent(String eventName, WritableMap eventMap) {
+    try {
+      ReactContext reactContext = getReactContext(EventSubscriber.getContext());
+
+      if (reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+        return;
+      }
+
+      reactContext
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+          .emit(eventName, eventMap);
+
+    } catch (Exception e) {
+      Log.e("SEND_EVENT", "", e);
+    }
+  }
+
+  static boolean isAppInForeground() {
+    return ProcessLifecycleOwner.get()
+        .getLifecycle()
+        .getCurrentState()
+        .isAtLeast(Lifecycle.State.RESUMED);
+  }
+
+  static void hideNotificationDrawer() {
+    Context context = EventSubscriber.getContext();
+
+    try {
+      @SuppressLint("WrongConstant")
+      Object service = context.getSystemService("statusbar");
+      Class<?> statusbarManager = Class.forName("android.app.StatusBarManager");
+      Method collapse =
+          statusbarManager.getMethod((Build.VERSION.SDK_INT >= 17) ? "collapsePanels" : "collapse");
+      collapse.setAccessible(true);
+      collapse.invoke(service);
+    } catch (Exception e) {
+      Log.e("HIDE_NOTIF_DRAWER", "", e);
+    }
+  }
+}