@ammarahmed/notifee-react-native 7.3.1 → 7.4.1

package/android/src/main/java/app/notifee/core/ChannelManager.java

@@ -0,0 +1,351 @@
+package app.notifee.core;
+
+/*
+ * 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 static androidx.core.app.NotificationManagerCompat.IMPORTANCE_NONE;
+
+import android.app.NotificationChannel;
+import android.app.NotificationChannelGroup;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.core.app.NotificationManagerCompat;
+import app.notifee.core.model.ChannelGroupModel;
+import app.notifee.core.model.ChannelModel;
+import app.notifee.core.utility.ColorUtils;
+import app.notifee.core.utility.ResourceUtils;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class ChannelManager {
+
+  private static String TAG = "ChannelManager";
+  private static ExecutorService executorService = Executors.newCachedThreadPool();
+  private static ListeningExecutorService lExecutorService = MoreExecutors.listeningDecorator(
+    executorService);
+
+  static ListenableFuture<Void> createChannel(ChannelModel channelModel) {
+    return lExecutorService.submit(
+      () -> {
+        if (Build.VERSION.SDK_INT < 26) {
+          return null;
+        }
+
+          NotificationChannel channel =
+              new NotificationChannel(
+                  channelModel.getId(), channelModel.getName(), channelModel.getImportance());
+
+          channel.setShowBadge(channelModel.getBadge());
+          channel.setBypassDnd(channelModel.getBypassDnd());
+          channel.setDescription(channelModel.getDescription());
+          channel.setGroup(channelModel.getGroupId());
+          channel.enableLights(channelModel.getLights());
+
+          if (channelModel.getLightColor() != null) {
+            channel.setLightColor(channelModel.getLightColor());
+          }
+
+          channel.setLockscreenVisibility(channelModel.getVisibility());
+          channel.enableVibration(channelModel.getVibration());
+
+          long[] vibrationPattern = channelModel.getVibrationPattern();
+          if (vibrationPattern.length > 0) {
+            channel.setVibrationPattern(vibrationPattern);
+          }
+
+          if (channelModel.getSound() != null) {
+            Uri soundUri = ResourceUtils.getSoundUri(channelModel.getSound());
+            if (soundUri != null) {
+              AudioAttributes audioAttributes =
+                  new AudioAttributes.Builder()
+                      .setUsage(AudioAttributes.USAGE_NOTIFICATION)
+                      .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                      .build();
+              channel.setSound(soundUri, audioAttributes);
+            } else {
+              Logger.w(
+                  TAG,
+                  "Unable to retrieve sound for channel, sound was specified as: "
+                      + channel.getSound());
+            }
+          } else {
+            channel.setSound(null, null);
+          }
+
+          NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+              .createNotificationChannel(channel);
+
+          return null;
+        });
+  }
+
+  static ListenableFuture<Void> createChannels(List<ChannelModel> channelModels) {
+    return lExecutorService.submit(
+        () -> {
+          for (ChannelModel channelModel : channelModels) {
+            createChannel(channelModel).get();
+          }
+
+          return null;
+        });
+  }
+
+  static ListenableFuture<Void> createChannelGroup(ChannelGroupModel channelGroupModel) {
+    return lExecutorService.submit(
+        () -> {
+          if (Build.VERSION.SDK_INT < 26) {
+            return null;
+          }
+
+          NotificationChannelGroup notificationChannelGroup =
+              new NotificationChannelGroup(channelGroupModel.getId(), channelGroupModel.getName());
+
+          if (Build.VERSION.SDK_INT >= 28 && channelGroupModel.getDescription() != null) {
+            notificationChannelGroup.setDescription(channelGroupModel.getDescription());
+          }
+
+          NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+              .createNotificationChannelGroup(notificationChannelGroup);
+
+          return null;
+        });
+  }
+
+  static ListenableFuture<Void> createChannelGroups(
+      List<ChannelGroupModel> channelGroupModels) {
+      return lExecutorService.submit(
+        () -> {
+          if (Build.VERSION.SDK_INT < 26) {
+            return null;
+          }
+
+          for (ChannelGroupModel channelGroupModel : channelGroupModels) {
+            createChannelGroup(channelGroupModel).get();
+          }
+
+          return null;
+        });
+  }
+
+  static void deleteChannel(@NonNull String channelId) {
+    NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+        .deleteNotificationChannel(channelId);
+  }
+
+  static void deleteChannelGroup(@NonNull String channelGroupId) {
+    NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+        .deleteNotificationChannelGroup(channelGroupId);
+  }
+
+  static ListenableFuture<List<Bundle>> getChannels() {
+    return lExecutorService.submit(
+        () -> {
+          List<NotificationChannel> channels =
+              NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                  .getNotificationChannels();
+
+          if (channels.size() == 0 || Build.VERSION.SDK_INT < 26) {
+            return Collections.emptyList();
+          }
+
+          ArrayList<Bundle> channelBundles = new ArrayList<>(channels.size());
+          for (NotificationChannel channel : channels) {
+            channelBundles.add(convertChannelToBundle(channel));
+          }
+
+          return channelBundles;
+        });
+  }
+
+  static ListenableFuture<Bundle> getChannel(String channelId) {
+    return lExecutorService.submit(
+        () -> {
+          NotificationChannel channel =
+              NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                  .getNotificationChannel(channelId);
+
+          return convertChannelToBundle(channel);
+        });
+  }
+
+  static ListenableFuture<Boolean> isChannelBlocked(String channelId) {
+    return lExecutorService.submit(
+        () -> {
+          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false;
+
+          NotificationChannel channel =
+              NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                  .getNotificationChannel(channelId);
+
+          if (channel == null) {
+            return false;
+          }
+
+          return IMPORTANCE_NONE == channel.getImportance();
+        });
+  }
+
+  static ListenableFuture<Boolean> isChannelCreated(String channelId) {
+    return lExecutorService.submit(
+        () -> {
+          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false;
+
+          NotificationChannel channel =
+              NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                  .getNotificationChannel(channelId);
+
+          return channel != null;
+        });
+  }
+
+  static ListenableFuture<List<Bundle>> getChannelGroups() {
+      return lExecutorService.submit(
+        () -> {
+          List<NotificationChannelGroup> channelGroups =
+              NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                  .getNotificationChannelGroups();
+
+          if (channelGroups.size() == 0 || Build.VERSION.SDK_INT < 26) {
+            return Collections.emptyList();
+          }
+
+          ArrayList<Bundle> channelGroupBundles = new ArrayList<>(channelGroups.size());
+          for (NotificationChannelGroup channelGroup : channelGroups) {
+            channelGroupBundles.add(convertChannelGroupToBundle(channelGroup));
+          }
+
+          return channelGroupBundles;
+        });
+  }
+
+  static ListenableFuture<Bundle> getChannelGroup(String channelGroupId) {
+    return lExecutorService.submit(
+        () -> {
+          NotificationChannelGroup channelGroup =
+            NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+              .getNotificationChannelGroup(channelGroupId);
+
+          return convertChannelGroupToBundle(channelGroup);
+        });
+  }
+
+  private static Bundle convertChannelToBundle(NotificationChannel channel) {
+    if (channel == null || Build.VERSION.SDK_INT < 26) {
+      return null;
+    }
+
+    Bundle channelBundle = new Bundle();
+    channelBundle.putString("id", channel.getId());
+    channelBundle.putString("name", channel.getName().toString());
+    channelBundle.putBoolean("badge", channel.canShowBadge());
+    channelBundle.putBoolean("bypassDnd", channel.canBypassDnd());
+
+    // can be null, don't include if null
+    if (channel.getDescription() != null) {
+      channelBundle.putString("description", channel.getDescription());
+    }
+
+    // can be null, don't include if null
+    if (channel.getGroup() != null) {
+      channelBundle.putString("groupId", channel.getGroup());
+    }
+
+    channelBundle.putInt("importance", channel.getImportance());
+    channelBundle.putBoolean("lights", channel.shouldShowLights());
+    channelBundle.putBoolean("vibration", channel.shouldVibrate());
+    channelBundle.putBoolean("blocked", channel.getImportance() == IMPORTANCE_NONE);
+
+    // can be null, don't include if null
+    if (channel.getSound() != null) {
+      channelBundle.putString("soundURI", channel.getSound().toString());
+      // try to parse uri
+      String soundValue = ResourceUtils.getSoundName(channel.getSound());
+      if (soundValue != null) channelBundle.putString("sound", soundValue);
+    }
+
+    // optional, can be 0
+    if (channel.getLightColor() != 0) {
+      channelBundle.putString("lightColor", ColorUtils.getColorString(channel.getLightColor()));
+    }
+
+    // getVibrationPattern can be null
+    long[] vibrationPattern = channel.getVibrationPattern();
+
+    if (vibrationPattern != null && vibrationPattern.length > 0) {
+      try {
+        int[] convertedVibrationPattern = new int[vibrationPattern.length];
+        // cast to int array
+        for (int i = 0; i < vibrationPattern.length; i++) {
+          convertedVibrationPattern[i] = (int) vibrationPattern[i];
+        }
+
+        channelBundle.putIntArray("vibrationPattern", convertedVibrationPattern);
+      } catch (Exception e) {
+        Logger.e(TAG, "Unable to convert Vibration Pattern to Channel Bundle", e);
+      }
+    }
+
+    // Unless the user manually changes this in app settings, it is always -1000.
+    int visibility = channel.getLockscreenVisibility();
+    if (visibility != -1000) { // -1000 = not set
+      channelBundle.putInt("visibility", visibility);
+    }
+
+    return channelBundle;
+  }
+
+  private static Bundle convertChannelGroupToBundle(NotificationChannelGroup channelGroup) {
+    if (channelGroup == null || Build.VERSION.SDK_INT < 26) {
+      return null;
+    }
+
+    Bundle channelGroupBundle = new Bundle();
+    channelGroupBundle.putString("id", channelGroup.getId());
+    channelGroupBundle.putString("name", channelGroup.getName().toString());
+
+    List<NotificationChannel> notificationChannels = channelGroup.getChannels();
+    ArrayList<Bundle> channels = new ArrayList<>(notificationChannels.size());
+
+    for (NotificationChannel notificationChannel : notificationChannels) {
+      channels.add(convertChannelToBundle(notificationChannel));
+    }
+
+    channelGroupBundle.putParcelableArrayList("channels", channels);
+
+    if (Build.VERSION.SDK_INT >= 28) {
+      channelGroupBundle.putBoolean("blocked", channelGroup.isBlocked());
+      channelGroupBundle.putString("description", channelGroup.getDescription());
+    } else {
+      channelGroupBundle.putBoolean("blocked", false);
+    }
+
+    return channelGroupBundle;
+  }
+
+  public static ListeningExecutorService getListeningExecutorService() {
+    return lExecutorService;
+  }
+}

package/android/src/main/java/app/notifee/core/ContextHolder.java

@@ -0,0 +1,33 @@
+package app.notifee.core;
+
+/*
+ * 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;
+
+public class ContextHolder {
+  private static Context applicationContext;
+
+  public static Context getApplicationContext() {
+    return applicationContext;
+  }
+
+  public static void setApplicationContext(Context applicationContext) {
+    Logger.d("context", "received application context");
+    ContextHolder.applicationContext = applicationContext;
+  }
+}

package/android/src/main/java/app/notifee/core/EventBus.java

@@ -0,0 +1,63 @@
+package app.notifee.core;
+
+/*
+ * 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.
+ *
+ */
+
+public class EventBus {
+  private static final EventBus instance = new EventBus();
+  private org.greenrobot.eventbus.EventBus eventBus;
+
+  private EventBus() {
+    eventBus = org.greenrobot.eventbus.EventBus.builder().build();
+  }
+
+  public static EventBus getInstance() {
+    return instance;
+  }
+
+  public static void register(Object subscriber) {
+    getInstance().getDefault().register(subscriber);
+  }
+
+  public static void unregister(Object subscriber) {
+    getInstance().getDefault().unregister(subscriber);
+  }
+
+  public static <T> T getStickyEvent(Class<T> eventType) {
+    return getInstance().getDefault().getStickyEvent(eventType);
+  }
+
+  public static <T> T removeStickEvent(Class<T> eventType) {
+    return getInstance().getDefault().removeStickyEvent(eventType);
+  }
+
+  public static void post(Object event) {
+    getInstance().getDefault().post(event);
+  }
+
+  static void postSticky(Object event) {
+    getInstance().getDefault().postSticky(event);
+  }
+
+  static <T> T removeStickyEvent(Class<T> eventType) {
+    return getInstance().getDefault().removeStickyEvent(eventType);
+  }
+
+  private org.greenrobot.eventbus.EventBus getDefault() {
+    return eventBus;
+  }
+}

package/android/src/main/java/app/notifee/core/EventSubscriber.java

@@ -0,0 +1,82 @@
+package app.notifee.core;
+
+/*
+ * 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 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 java.util.HashSet;
+import java.util.Set;
+import org.greenrobot.eventbus.Subscribe;
+import org.greenrobot.eventbus.ThreadMode;
+
+@KeepForSdk
+public class EventSubscriber {
+  private static final EventSubscriber mInstance = new EventSubscriber();
+  private final Set<EventListener> mListeners = new HashSet<>();
+
+  private EventSubscriber() {
+    EventBus.register(this);
+  }
+
+  @KeepForSdk
+  public static void register(EventListener listener) {
+    mInstance.mListeners.add(listener);
+  }
+
+  @KeepForSdk
+  public static void unregister(EventListener listener) {
+    mInstance.mListeners.remove(listener);
+  }
+
+  @KeepForSdk
+  public static Context getContext() {
+    return ContextHolder.getApplicationContext();
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onNotificationEvent(NotificationEvent notificationEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onNotificationEvent(notificationEvent);
+    }
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onLogEvent(LogEvent logEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onLogEvent(logEvent);
+    }
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onBlockStateEvent(BlockStateEvent blockStateEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onBlockStateEvent(blockStateEvent);
+    }
+  }
+
+  @Subscribe(threadMode = ThreadMode.MAIN)
+  public void onForegroundServiceEvent(ForegroundServiceEvent foregroundServiceEvent) {
+    for (EventListener eventListener : mListeners) {
+      eventListener.onForegroundServiceEvent(foregroundServiceEvent);
+    }
+  }
+}

package/android/src/main/java/app/notifee/core/ForegroundService.java

@@ -0,0 +1,125 @@
+package app.notifee.core;
+
+/*
+ * 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.Notification;
+import android.app.Service;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.IBinder;
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationManagerCompat;
+import app.notifee.core.event.ForegroundServiceEvent;
+import app.notifee.core.event.NotificationEvent;
+import app.notifee.core.interfaces.MethodCallResult;
+import app.notifee.core.model.NotificationModel;
+
+public class ForegroundService extends Service {
+  private static final String TAG = "ForegroundService";
+  public static final String START_FOREGROUND_SERVICE_ACTION =
+      "app.notifee.core.ForegroundService.START";
+  public static final String STOP_FOREGROUND_SERVICE_ACTION =
+      "app.notifee.core.ForegroundService.STOP";
+
+  public static String mCurrentNotificationId = null;
+
+  static void start(int hashCode, Notification notification, Bundle notificationBundle) {
+    Intent intent = new Intent(ContextHolder.getApplicationContext(), ForegroundService.class);
+    intent.setAction(START_FOREGROUND_SERVICE_ACTION);
+    intent.putExtra("hashCode", hashCode);
+    intent.putExtra("notification", notification);
+    intent.putExtra("notificationBundle", notificationBundle);
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      ContextHolder.getApplicationContext().startForegroundService(intent);
+    } else {
+      // TODO test this on older device
+      ContextHolder.getApplicationContext().startService(intent);
+    }
+  }
+
+  static void stop() {
+    Intent intent = new Intent(ContextHolder.getApplicationContext(), ForegroundService.class);
+    intent.setAction(STOP_FOREGROUND_SERVICE_ACTION);
+
+    try {
+      // Call start service first with stop action
+      ContextHolder.getApplicationContext().startService(intent);
+    } catch (IllegalStateException illegalStateException) {
+      // try to stop with stopService command
+      ContextHolder.getApplicationContext().stopService(intent);
+    } catch (Exception exception) {
+      Logger.e(TAG, "Unable to stop foreground service", exception);
+    }
+  }
+
+  @Override
+  public int onStartCommand(Intent intent, int flags, int startId) {
+    // Check if action is to stop the foreground service
+    if (intent == null || STOP_FOREGROUND_SERVICE_ACTION.equals(intent.getAction())) {
+      stopSelf();
+      mCurrentNotificationId = null;
+      return 0;
+    }
+
+    Bundle extras = intent.getExtras();
+
+    if (extras != null) {
+      // Hash code is sent to service to ensure it is kept the same
+      int hashCode = extras.getInt("hashCode");
+      Notification notification = extras.getParcelable("notification");
+      Bundle bundle = extras.getBundle("notificationBundle");
+
+      if (notification != null & bundle != null) {
+        NotificationModel notificationModel = NotificationModel.fromBundle(bundle);
+
+        if (mCurrentNotificationId == null) {
+          mCurrentNotificationId = notificationModel.getId();
+          startForeground(hashCode, notification);
+
+          // On headless task complete
+          final MethodCallResult<Void> methodCallResult =
+              (e, aVoid) -> {
+                stopForeground(true);
+                mCurrentNotificationId = null;
+              };
+
+          ForegroundServiceEvent foregroundServiceEvent =
+              new ForegroundServiceEvent(notificationModel, methodCallResult);
+
+          EventBus.post(foregroundServiceEvent);
+        } else if (mCurrentNotificationId.equals(notificationModel.getId())) {
+          NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+              .notify(hashCode, notification);
+        } else {
+          EventBus.post(
+            new NotificationEvent(NotificationEvent.TYPE_FG_ALREADY_EXIST, notificationModel));
+        }
+      }
+    }
+
+    return START_NOT_STICKY;
+  }
+
+  @Nullable
+  @Override
+  public IBinder onBind(Intent intent) {
+    return null;
+  }
+}