@ammarahmed/notifee-react-native 7.3.0

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

@@ -0,0 +1,349 @@
+/*
+ * 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);
+  }
+
+  @Override
+  public void onCatalystInstanceDestroy() {
+    NotifeeReactUtils.clearRunningHeadlessTasks();
+  }
+
+  @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 actvity
+    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));
+
+    activity.requestPermissions(
+        new String[] {Manifest.permission.POST_NOTIFICATIONS},
+        Notifee.REQUEST_CODE_NOTIFICATION_PERMISSION,
+        this);
+  }
+
+  @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();
+  }
+}