@ammarahmed/notifee-react-native 7.4.8 → 7.4.10

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

@@ -184,7 +184,7 @@ public class NotificationAndroidStyleModel {
 
             // largeIcon has been specified to be null for BigPicture
             if (largeIcon == null) {
-              bigPictureStyle.bigLargeIcon(null);
+               bigPictureStyle.bigLargeIcon((Bitmap) null);
             }
           }
 

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

@@ -13,9 +13,15 @@ import android.os.Handler;
 import android.os.Looper;
 import android.util.Log;
 import android.util.SparseArray;
+
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+
 import app.notifee.core.EventSubscriber;
+
 import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactHost;
+import com.facebook.react.ReactInstanceEventListener;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactNativeHost;
 import com.facebook.react.bridge.Arguments;
@@ -28,217 +34,216 @@ import com.facebook.react.jstasks.HeadlessJsTaskConfig;
 import com.facebook.react.jstasks.HeadlessJsTaskContext;
 import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+
 import java.lang.reflect.Method;
 import java.util.List;
 
 class NotifeeReactUtils {
-  private static final SparseArray<GenericCallback> headlessTasks = new SparseArray<>();
-  private static final HeadlessJsTaskEventListener headlessTasksListener =
-      new HeadlessJsTaskEventListener() {
-        @Override
-        public void onHeadlessJsTaskStart(int taskId) {}
-
-        @Override
-        public void onHeadlessJsTaskFinish(int taskId) {
-          synchronized (headlessTasks) {
-            GenericCallback callback = headlessTasks.get(taskId);
-            if (callback != null) {
-              headlessTasks.remove(taskId);
-              callback.call();
+    private static final SparseArray<GenericCallback> headlessTasks = new SparseArray<>();
+    private static final HeadlessJsTaskEventListener headlessTasksListener =
+            new HeadlessJsTaskEventListener() {
+                @Override
+                public void onHeadlessJsTaskStart(int taskId) {
+                }
+
+                @Override
+                public void onHeadlessJsTaskFinish(int taskId) {
+                    synchronized (headlessTasks) {
+                        GenericCallback callback = headlessTasks.get(taskId);
+                        if (callback != null) {
+                            headlessTasks.remove(taskId);
+                            callback.call();
+                        }
+                    }
+                }
+            };
+
+    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 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 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 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);
+
+    private static @Nullable ReactContext getReactContext() {
+        ReactHost reactNativeHost =
+                ((ReactApplication) EventSubscriber.getContext()).getReactHost();
+        if (reactNativeHost == null) return null;
+        return reactNativeHost.getCurrentReactContext();
     }
-  }
-
-  static void promiseResolver(Promise promise, Exception e) {
-    if (e != null) {
-      // TODO custom error class with message/code
-      promise.reject(e);
-    } else {
-      promise.resolve(null);
+
+    private static void initializeReactContext(GenericCallback callback) {
+        ReactHost reactNativeHost =
+                ((ReactApplication) EventSubscriber.getContext()).getReactHost();
+
+        if (reactNativeHost != null) {
+            reactNativeHost.addReactInstanceEventListener(
+                    new ReactInstanceEventListener() {
+                        @Override
+                        public void onReactContextInitialized(@NonNull final ReactContext reactContext) {
+                            reactNativeHost.removeReactInstanceEventListener(this);
+                            new Handler(Looper.getMainLooper()).postDelayed(callback::call, 100);
+                        }
+                    });
+            reactNativeHost.start();
+        }
     }
-  }
-
-  private static @Nullable ReactContext getReactContext() {
-    ReactNativeHost reactNativeHost =
-        ((ReactApplication) EventSubscriber.getContext()).getReactNativeHost();
-    ReactInstanceManager reactInstanceManager = reactNativeHost.getReactInstanceManager();
-    return reactInstanceManager.getCurrentReactContext();
-  }
-
-  private static void initializeReactContext(GenericCallback callback) {
-    ReactNativeHost reactNativeHost =
-        ((ReactApplication) EventSubscriber.getContext()).getReactNativeHost();
-
-    ReactInstanceManager reactInstanceManager = reactNativeHost.getReactInstanceManager();
-
-    reactInstanceManager.addReactInstanceEventListener(
-        new ReactInstanceManager.ReactInstanceEventListener() {
-          @Override
-          public void onReactContextInitialized(final ReactContext reactContext) {
-            reactInstanceManager.removeReactInstanceEventListener(this);
-            new Handler(Looper.getMainLooper()).postDelayed(callback::call, 100);
-          }
-        });
-
-    if (!reactInstanceManager.hasStartedCreatingInitialContext()) {
-      reactInstanceManager.createReactContextInBackground();
+
+    static void clearRunningHeadlessTasks() {
+        for (int i = 0; i < headlessTasks.size(); i++) {
+            GenericCallback callback = headlessTasks.valueAt(i);
+            callback.call();
+            headlessTasks.remove(i);
+        }
     }
-  }
 
-  static void clearRunningHeadlessTasks() {
-    for (int i = 0; i < headlessTasks.size(); i++) {
-      GenericCallback callback = headlessTasks.valueAt(i);
-      callback.call();
-      headlessTasks.remove(i);
+    static void startHeadlessTask(
+            String taskName,
+            WritableMap taskData,
+            long taskTimeout,
+            @Nullable GenericCallback taskCompletionCallback) {
+        GenericCallback callback =
+                () -> {
+                    HeadlessJsTaskContext taskContext = HeadlessJsTaskContext.getInstance(getReactContext());
+                    HeadlessJsTaskConfig taskConfig =
+                            new HeadlessJsTaskConfig(taskName, taskData, taskTimeout, true);
+
+                    synchronized (headlessTasks) {
+                        if (headlessTasks.size() == 0) {
+                            taskContext.addTaskEventListener(headlessTasksListener);
+                        }
+                    }
+
+                    headlessTasks.put(
+                            taskContext.startTask(taskConfig),
+                            () -> {
+                                synchronized (headlessTasks) {
+                                    if (headlessTasks.size() == 0) {
+                                        taskContext.removeTaskEventListener(headlessTasksListener);
+                                    }
+                                }
+                                if (taskCompletionCallback != null) {
+                                    taskCompletionCallback.call();
+                                }
+                            });
+                };
+
+        if (getReactContext() == null) {
+            initializeReactContext(callback);
+        } else {
+            callback.call();
+        }
     }
-  }
-
-  static void startHeadlessTask(
-      String taskName,
-      WritableMap taskData,
-      long taskTimeout,
-      @Nullable GenericCallback taskCompletionCallback) {
-    GenericCallback callback =
-        () -> {
-          HeadlessJsTaskContext taskContext = HeadlessJsTaskContext.getInstance(getReactContext());
-          HeadlessJsTaskConfig taskConfig =
-              new HeadlessJsTaskConfig(taskName, taskData, taskTimeout, true);
-
-          synchronized (headlessTasks) {
-            if (headlessTasks.size() == 0) {
-              taskContext.addTaskEventListener(headlessTasksListener);
+
+    static void sendEvent(String eventName, WritableMap eventMap) {
+        try {
+            ReactContext reactContext = getReactContext();
+
+            if (reactContext == null || !reactContext.hasActiveReactInstance()) {
+                return;
             }
-          }
-
-          headlessTasks.put(
-              taskContext.startTask(taskConfig),
-              () -> {
-                synchronized (headlessTasks) {
-                  if (headlessTasks.size() == 0) {
-                    taskContext.removeTaskEventListener(headlessTasksListener);
-                  }
-                }
-                if (taskCompletionCallback != null) {
-                  taskCompletionCallback.call();
-                }
-              });
-        };
 
-    if (getReactContext() == null) {
-      initializeReactContext(callback);
-    } else {
-      callback.call();
+            reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(eventName, eventMap);
+
+        } catch (Exception e) {
+            Log.e("SEND_EVENT", "", e);
+        }
     }
-  }
 
-  static void sendEvent(String eventName, WritableMap eventMap) {
-    try {
-      ReactContext reactContext = getReactContext();
+    static boolean isAppInForeground() {
+        Context context = EventSubscriber.getContext();
 
-      if (reactContext == null || !reactContext.hasActiveCatalystInstance()) {
-        return;
-      }
+        ActivityManager activityManager =
+                (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+        if (activityManager == null) return false;
 
-      reactContext
-          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-          .emit(eventName, eventMap);
+        List<ActivityManager.RunningAppProcessInfo> appProcesses =
+                activityManager.getRunningAppProcesses();
+        if (appProcesses == null) return false;
 
-    } catch (Exception e) {
-      Log.e("SEND_EVENT", "", e);
-    }
-  }
-
-  static boolean isAppInForeground() {
-    Context context = EventSubscriber.getContext();
-
-    ActivityManager activityManager =
-        (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
-    if (activityManager == null) return false;
-
-    List<ActivityManager.RunningAppProcessInfo> appProcesses =
-        activityManager.getRunningAppProcesses();
-    if (appProcesses == null) return false;
-
-    final String packageName = context.getPackageName();
-    for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
-      if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
-          && appProcess.processName.equals(packageName)) {
-        ReactContext reactContext = getReactContext();
-        if (reactContext == null) {
-          return false;
+        final String packageName = context.getPackageName();
+        for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
+            if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+                    && appProcess.processName.equals(packageName)) {
+                ReactContext reactContext = getReactContext();
+                if (reactContext == null) {
+                    return false;
+                }
+
+                return reactContext.getLifecycleState() == LifecycleState.RESUMED;
+            }
         }
 
-        return reactContext.getLifecycleState() == LifecycleState.RESUMED;
-      }
+        return false;
     }
 
-    return false;
-  }
-
-  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);
+    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);
+        }
     }
-  }
 
-  interface GenericCallback {
-    void call();
-  }
+    interface GenericCallback {
+        void call();
+    }
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "7.4.6";
+export declare const version = "7.4.10";

package/dist/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":";;;AAAA,2BAA2B;AACd,QAAA,OAAO,GAAG,OAAO,CAAC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":";;;AAAA,2BAA2B;AACd,QAAA,OAAO,GAAG,QAAQ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ammarahmed/notifee-react-native",
-  "version": "7.4.8",
+  "version": "7.4.10",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "Notifee - a feature rich notifications library for React Native.",
   "main": "dist/index.js",

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '7.4.6';
+export const version = '7.4.10';