@ammarahmed/notifee-react-native 7.3.1 → 7.4.2

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

@@ -0,0 +1,903 @@
+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 app.notifee.core.ContextHolder.getApplicationContext;
+import static app.notifee.core.ReceiverService.ACTION_PRESS_INTENT;
+import static app.notifee.core.event.NotificationEvent.TYPE_ACTION_PRESS;
+import static app.notifee.core.event.NotificationEvent.TYPE_PRESS;
+import static java.lang.Integer.parseInt;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.service.notification.StatusBarNotification;
+import androidx.annotation.NonNull;
+import androidx.concurrent.futures.CallbackToFutureAdapter;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.app.RemoteInput;
+import androidx.core.graphics.drawable.IconCompat;
+import androidx.work.Data;
+import androidx.work.ExistingPeriodicWorkPolicy;
+import androidx.work.ExistingWorkPolicy;
+import androidx.work.ListenableWorker;
+import androidx.work.ListenableWorker.Result;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.PeriodicWorkRequest;
+import androidx.work.WorkManager;
+import app.notifee.core.database.WorkDataEntity;
+import app.notifee.core.database.WorkDataRepository;
+import app.notifee.core.event.MainComponentEvent;
+import app.notifee.core.event.NotificationEvent;
+import app.notifee.core.interfaces.MethodCallResult;
+import app.notifee.core.model.IntervalTriggerModel;
+import app.notifee.core.model.NotificationAndroidActionModel;
+import app.notifee.core.model.NotificationAndroidModel;
+import app.notifee.core.model.NotificationAndroidPressActionModel;
+import app.notifee.core.model.NotificationAndroidStyleModel;
+import app.notifee.core.model.NotificationModel;
+import app.notifee.core.model.TimestampTriggerModel;
+import app.notifee.core.utility.Callbackable;
+import app.notifee.core.utility.ExtendedListenableFuture;
+import app.notifee.core.utility.IntentUtils;
+import app.notifee.core.utility.ObjectUtils;
+import app.notifee.core.utility.PowerManagerUtils;
+import app.notifee.core.utility.ResourceUtils;
+import app.notifee.core.utility.TextUtils;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+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.List;
+import java.util.Objects;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+class NotificationManager {
+  private static final String TAG = "NotificationManager";
+  private static final String EXTRA_NOTIFEE_NOTIFICATION = "notifee.notification";
+  private static final String EXTRA_NOTIFEE_TRIGGER = "notifee.trigger";
+  private static final ExecutorService CACHED_THREAD_POOL = Executors.newCachedThreadPool();
+  private static final ListeningExecutorService LISTENING_CACHED_THREAD_POOL = MoreExecutors.listeningDecorator(
+    CACHED_THREAD_POOL);
+  private static final int NOTIFICATION_TYPE_ALL = 0;
+  private static final int NOTIFICATION_TYPE_DISPLAYED = 1;
+  private static final int NOTIFICATION_TYPE_TRIGGER = 2;
+
+  private static ListenableFuture<NotificationCompat.Builder> notificationBundleToBuilder(
+    NotificationModel notificationModel) {
+    final NotificationAndroidModel androidModel = notificationModel.getAndroid();
+
+    /*
+     * Construct the initial NotificationCompat.Builder instance
+     */
+    Callable<NotificationCompat.Builder> builderCallable =
+        () -> {
+          Boolean hasCustomSound = false;
+          NotificationCompat.Builder builder =
+              new NotificationCompat.Builder(getApplicationContext(), androidModel.getChannelId());
+
+          // must always keep at top
+          builder.setExtras(notificationModel.getData());
+
+          builder.setDeleteIntent(
+              ReceiverService.createIntent(
+                  ReceiverService.DELETE_INTENT,
+                  new String[] {"notification"},
+                  notificationModel.toBundle()));
+          int targetSdkVersion =
+              ContextHolder.getApplicationContext().getApplicationInfo().targetSdkVersion;
+          if (targetSdkVersion >= Build.VERSION_CODES.S
+              && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            builder.setContentIntent(
+                NotificationPendingIntent.createIntent(
+                    notificationModel.getHashCode(),
+                    androidModel.getPressAction(),
+                    TYPE_PRESS,
+                    new String[] {"notification", "pressAction"},
+                    notificationModel.toBundle(),
+                    androidModel.getPressAction()));
+          } else {
+            builder.setContentIntent(
+                ReceiverService.createIntent(
+                    ReceiverService.PRESS_INTENT,
+                    new String[] {"notification", "pressAction"},
+                    notificationModel.toBundle(),
+                    androidModel.getPressAction()));
+          }
+
+          if (notificationModel.getTitle() != null) {
+            builder.setContentTitle(TextUtils.fromHtml(notificationModel.getTitle()));
+          }
+
+          if (notificationModel.getSubTitle() != null) {
+            builder.setSubText(TextUtils.fromHtml(notificationModel.getSubTitle()));
+          }
+
+          if (notificationModel.getBody() != null) {
+            builder.setContentText(TextUtils.fromHtml(notificationModel.getBody()));
+          }
+
+          if (androidModel.getBadgeIconType() != null) {
+            builder.setBadgeIconType(androidModel.getBadgeIconType());
+          }
+
+          if (androidModel.getCategory() != null) {
+            builder.setCategory(androidModel.getCategory());
+          }
+
+          if (androidModel.getColor() != null) {
+            builder.setColor(androidModel.getColor());
+          }
+
+          builder.setColorized(androidModel.getColorized());
+
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            builder.setChronometerCountDown(androidModel.getChronometerCountDown());
+          }
+
+          if (androidModel.getGroup() != null) {
+            builder.setGroup(androidModel.getGroup());
+          }
+
+          builder.setGroupAlertBehavior(androidModel.getGroupAlertBehaviour());
+          builder.setGroupSummary(androidModel.getGroupSummary());
+
+          if (androidModel.getInputHistory() != null) {
+            builder.setRemoteInputHistory(androidModel.getInputHistory());
+          }
+
+          if (androidModel.getLights() != null) {
+            ArrayList<Integer> lights = androidModel.getLights();
+            builder.setLights(lights.get(0), lights.get(1), lights.get(2));
+          }
+
+          builder.setLocalOnly(androidModel.getLocalOnly());
+
+          if (androidModel.getNumber() != null) {
+            builder.setNumber(androidModel.getNumber());
+          }
+
+          if (androidModel.getSound() != null) {
+            Uri soundUri = ResourceUtils.getSoundUri(androidModel.getSound());
+            if (soundUri != null) {
+              hasCustomSound = true;
+              builder.setSound(soundUri);
+            } else {
+              Logger.w(
+                  TAG,
+                  "Unable to retrieve sound for notification, sound was specified as: "
+                      + androidModel.getSound());
+            }
+          }
+
+          builder.setDefaults(androidModel.getDefaults(hasCustomSound));
+          builder.setOngoing(androidModel.getOngoing());
+          builder.setOnlyAlertOnce(androidModel.getOnlyAlertOnce());
+          builder.setPriority(androidModel.getPriority());
+
+          NotificationAndroidModel.AndroidProgress progress = androidModel.getProgress();
+          if (progress != null) {
+            builder.setProgress(
+                progress.getMax(), progress.getCurrent(), progress.getIndeterminate());
+          }
+
+          if (androidModel.getShortcutId() != null) {
+            builder.setShortcutId(androidModel.getShortcutId());
+          }
+
+          builder.setShowWhen(androidModel.getShowTimestamp());
+
+          Integer smallIconId = androidModel.getSmallIcon();
+          if (smallIconId != null) {
+            Integer smallIconLevel = androidModel.getSmallIconLevel();
+            if (smallIconLevel != null) {
+              builder.setSmallIcon(smallIconId, smallIconLevel);
+            } else {
+              builder.setSmallIcon(smallIconId);
+            }
+          }
+
+          if (androidModel.getSortKey() != null) {
+            builder.setSortKey(androidModel.getSortKey());
+          }
+
+          if (androidModel.getTicker() != null) {
+            builder.setTicker(androidModel.getTicker());
+          }
+
+          if (androidModel.getTimeoutAfter() != null) {
+            builder.setTimeoutAfter(androidModel.getTimeoutAfter());
+          }
+
+          builder.setUsesChronometer(androidModel.getShowChronometer());
+
+          long[] vibrationPattern = androidModel.getVibrationPattern();
+          if (vibrationPattern.length > 0) builder.setVibrate(vibrationPattern);
+
+          builder.setVisibility(androidModel.getVisibility());
+
+          long timestamp = androidModel.getTimestamp();
+          if (timestamp > -1) builder.setWhen(timestamp);
+
+          builder.setAutoCancel(androidModel.getAutoCancel());
+
+          return builder;
+        };
+
+    /*
+     * A task continuation that fetches the largeIcon through Fresco, if specified.
+     */
+    AsyncFunction<NotificationCompat.Builder, NotificationCompat.Builder> largeIconContinuation =
+        taskResult -> LISTENING_CACHED_THREAD_POOL.submit(() -> {
+          NotificationCompat.Builder builder = taskResult;
+
+          if (androidModel.hasLargeIcon()) {
+            String largeIcon = androidModel.getLargeIcon();
+            Bitmap largeIconBitmap = null;
+
+            try {
+              largeIconBitmap = ResourceUtils.getImageBitmapFromUrl(largeIcon)
+                      .get(10, TimeUnit.SECONDS);
+            } catch (TimeoutException e) {
+              Logger.e(
+                  TAG,
+                  "Timeout occurred whilst trying to retrieve a largeIcon image: " + largeIcon,
+                  e);
+            } catch (Exception e) {
+              Logger.e(
+                  TAG,
+                  "An error occurred whilst trying to retrieve a largeIcon image: " + largeIcon,
+                  e);
+            }
+
+            if (largeIconBitmap != null) {
+              if (androidModel.getCircularLargeIcon()) {
+                largeIconBitmap = ResourceUtils.getCircularBitmap(largeIconBitmap);
+              }
+
+              builder.setLargeIcon(largeIconBitmap);
+            }
+          }
+
+          return builder;
+        });
+
+    /*
+     * A task continuation for full-screen action, if specified.
+     */
+    AsyncFunction<NotificationCompat.Builder, NotificationCompat.Builder>
+        fullScreenActionContinuation =
+            taskResult -> LISTENING_CACHED_THREAD_POOL.submit(() -> {
+              NotificationCompat.Builder builder = taskResult;
+              if (androidModel.hasFullScreenAction()) {
+                NotificationAndroidPressActionModel fullScreenActionBundle =
+                    androidModel.getFullScreenAction();
+
+                String launchActivity = fullScreenActionBundle.getLaunchActivity();
+                Class launchActivityClass = IntentUtils.getLaunchActivity(launchActivity);
+                if (launchActivityClass == null) {
+                  Logger.e(
+                      TAG,
+                      String.format(
+                          "Launch Activity for full-screen action does not exist ('%s').",
+                          launchActivity));
+                  return builder;
+                }
+
+                Intent launchIntent = new Intent(getApplicationContext(), launchActivityClass);
+                if (fullScreenActionBundle.getLaunchActivityFlags() != -1) {
+                  launchIntent.addFlags(fullScreenActionBundle.getLaunchActivityFlags());
+                }
+
+                if (fullScreenActionBundle.getMainComponent() != null) {
+                  launchIntent.putExtra("mainComponent", fullScreenActionBundle.getMainComponent());
+                  launchIntent.putExtra("notification", notificationModel.toBundle());
+                  EventBus.postSticky(
+                      new MainComponentEvent(fullScreenActionBundle.getMainComponent()));
+                }
+
+                PendingIntent fullScreenPendingIntent =
+                    PendingIntent.getActivity(
+                        getApplicationContext(),
+                        notificationModel.getHashCode(),
+                        launchIntent,
+                        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+                builder.setFullScreenIntent(fullScreenPendingIntent, true);
+              }
+
+              return builder;
+            });
+
+    /*
+     * A task continuation that builds all actions, if any. Additionally fetches
+     * icon bitmaps through Fresco.
+     */
+    AsyncFunction<NotificationCompat.Builder, NotificationCompat.Builder> actionsContinuation =
+        taskResult -> LISTENING_CACHED_THREAD_POOL.submit(() -> {
+          NotificationCompat.Builder builder = taskResult;
+          ArrayList<NotificationAndroidActionModel> actionBundles = androidModel.getActions();
+
+          if (actionBundles == null) {
+            return builder;
+          }
+
+          for (NotificationAndroidActionModel actionBundle : actionBundles) {
+            PendingIntent pendingIntent = null;
+            int targetSdkVersion =
+                ContextHolder.getApplicationContext().getApplicationInfo().targetSdkVersion;
+            if (targetSdkVersion >= Build.VERSION_CODES.S
+                && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+              pendingIntent =
+                  NotificationPendingIntent.createIntent(
+                      notificationModel.getHashCode(),
+                      actionBundle.getPressAction().toBundle(),
+                      TYPE_ACTION_PRESS,
+                      new String[] {"notification", "pressAction"},
+                      notificationModel.toBundle(),
+                      actionBundle.getPressAction().toBundle());
+            } else {
+              pendingIntent =
+                  ReceiverService.createIntent(
+                      ACTION_PRESS_INTENT,
+                      new String[] {"notification", "pressAction"},
+                      notificationModel.toBundle(),
+                      actionBundle.getPressAction().toBundle());
+            }
+
+            String icon = actionBundle.getIcon();
+            Bitmap iconBitmap = null;
+
+            if (icon != null) {
+              try {
+                iconBitmap =
+                    ResourceUtils.getImageBitmapFromUrl(actionBundle.getIcon())
+                      .get(10, TimeUnit.SECONDS);
+              } catch (TimeoutException e) {
+                Logger.e(
+                    TAG, "Timeout occurred whilst trying to retrieve an action icon: " + icon, e);
+              } catch (Exception e) {
+                Logger.e(
+                    TAG, "An error occurred whilst trying to retrieve an action icon: " + icon, e);
+              }
+            }
+
+            IconCompat iconCompat = null;
+            if (iconBitmap != null) {
+              iconCompat = IconCompat.createWithAdaptiveBitmap(iconBitmap);
+            }
+
+            NotificationCompat.Action.Builder actionBuilder =
+                new NotificationCompat.Action.Builder(
+                    iconCompat, TextUtils.fromHtml(actionBundle.getTitle()), pendingIntent);
+
+            RemoteInput remoteInput = actionBundle.getRemoteInput(actionBuilder);
+            if (remoteInput != null) {
+              actionBuilder.addRemoteInput(remoteInput);
+            }
+
+            builder.addAction(actionBuilder.build());
+          }
+
+          return builder;
+        });
+
+    /*
+     * A task continuation that builds the notification style, if any. Additionally
+     * fetches any image bitmaps (e.g. Person image, or BigPicture image) through
+     * Fresco.
+     */
+    AsyncFunction<NotificationCompat.Builder, NotificationCompat.Builder> styleContinuation =
+        builder -> LISTENING_CACHED_THREAD_POOL.submit(() -> {
+          NotificationAndroidStyleModel androidStyleBundle = androidModel.getStyle();
+          if (androidStyleBundle == null) {
+            return builder;
+          }
+
+          ListenableFuture<NotificationCompat.Style> styleTask =
+            androidStyleBundle.getStyleTask(LISTENING_CACHED_THREAD_POOL);
+          if (styleTask == null) {
+            return builder;
+          }
+
+          NotificationCompat.Style style = styleTask.get();
+          if (style != null) {
+            builder.setStyle(style);
+          }
+
+          return builder;
+        });
+
+    return new ExtendedListenableFuture<>(
+        LISTENING_CACHED_THREAD_POOL.submit(builderCallable))
+        // get a large image bitmap if largeIcon is set
+        .continueWith(largeIconContinuation, LISTENING_CACHED_THREAD_POOL)
+        // build notification actions, tasks based to allow image fetching
+        .continueWith(actionsContinuation, LISTENING_CACHED_THREAD_POOL)
+        // build notification style, tasks based to allow image fetching
+        .continueWith(styleContinuation, LISTENING_CACHED_THREAD_POOL)
+        // set full screen action, if fullScreenAction is set
+        .continueWith(fullScreenActionContinuation, LISTENING_CACHED_THREAD_POOL);
+  }
+
+  static ListenableFuture<Void> cancelAllNotifications(@NonNull int notificationType) {
+    return new ExtendedListenableFuture<>(LISTENING_CACHED_THREAD_POOL.submit(
+            () -> {
+              NotificationManagerCompat notificationManagerCompat =
+                  NotificationManagerCompat.from(getApplicationContext());
+
+              if (notificationType == NOTIFICATION_TYPE_DISPLAYED
+                  || notificationType == NOTIFICATION_TYPE_ALL) {
+                notificationManagerCompat.cancelAll();
+              }
+
+              if (notificationType == NOTIFICATION_TYPE_TRIGGER
+                  || notificationType == NOTIFICATION_TYPE_ALL) {
+                WorkManager workManager = WorkManager.getInstance(getApplicationContext());
+                workManager.cancelAllWorkByTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
+
+                // Remove all cancelled and finished work from its internal database
+                // states include SUCCEEDED, FAILED and CANCELLED
+                workManager.pruneWork();
+              }
+              return null;
+            }))
+        .continueWith(task -> {
+              if (notificationType == NOTIFICATION_TYPE_TRIGGER
+                  || notificationType == NOTIFICATION_TYPE_ALL) {
+                return new ExtendedListenableFuture<Void>(NotifeeAlarmManager.cancelAllNotifications())
+                  .addOnCompleteListener((e, result) -> {
+                      if (e == null) {
+                        WorkDataRepository.getInstance(getApplicationContext())
+                          .deleteAll();
+                      }
+                }, LISTENING_CACHED_THREAD_POOL);
+      }
+      return Futures.immediateFuture(null);
+    }, LISTENING_CACHED_THREAD_POOL);
+  }
+
+  static ListenableFuture<Void> cancelAllNotificationsWithIds(
+      @NonNull int notificationType, @NonNull List<String> ids, String tag) {
+    return new ExtendedListenableFuture<>(LISTENING_CACHED_THREAD_POOL.submit(
+            () -> {
+              WorkManager workManager = WorkManager.getInstance(getApplicationContext());
+              NotificationManagerCompat notificationManagerCompat =
+                  NotificationManagerCompat.from(getApplicationContext());
+
+              for (String id : ids) {
+                Logger.i(TAG, "Removing notification with id " + id);
+
+                if (notificationType != NOTIFICATION_TYPE_TRIGGER) {
+                  // Cancel notifications displayed by FCM which will always have
+                  // an id of 0 and a tag, see https://github.com/invertase/notifee/pull/175
+                  if (tag != null && id.equals("0")) {
+                    // Attempt to parse id as integer
+                    Integer integerId = null;
+
+                    try {
+                      integerId = parseInt(id);
+                    } catch (Exception e) {
+                      Logger.e(
+                          TAG,
+                          "cancelAllNotificationsWithIds -> Failed to parse id as integer  " + id);
+                    }
+
+                    if (integerId != null) {
+                      notificationManagerCompat.cancel(tag, integerId);
+                    }
+                  }
+
+                  // Cancel a notification created with notifee
+                  notificationManagerCompat.cancel(tag, id.hashCode());
+                }
+
+                if (notificationType != NOTIFICATION_TYPE_DISPLAYED) {
+                  Logger.i(TAG, "Removing notification with id " + id);
+
+                  workManager.cancelUniqueWork("trigger:" + id);
+                  // Remove all cancelled and finished work from its internal database
+                  // states include SUCCEEDED, FAILED and CANCELLED
+                  workManager.pruneWork();
+
+                  // And with alarm manager
+                  NotifeeAlarmManager.cancelNotification(id);
+                }
+              }
+
+              return null;
+            }))
+        .continueWith(
+            task -> {
+              // delete all from database
+              if (notificationType != NOTIFICATION_TYPE_DISPLAYED) {
+                WorkDataRepository.getInstance(getApplicationContext()).deleteByIds(ids);
+              }
+              return Futures.immediateFuture(null);
+            }, LISTENING_CACHED_THREAD_POOL);
+  }
+
+  static ListenableFuture<Void> displayNotification(NotificationModel notificationModel, Bundle triggerBundle) {
+    return new ExtendedListenableFuture<>(notificationBundleToBuilder(notificationModel))
+        .continueWith(
+                        (taskResult) -> {
+              NotificationCompat.Builder builder = taskResult;
+
+              // Add the following extras for `getDisplayedNotifications()`
+              Bundle extrasBundle = new Bundle();
+              extrasBundle.putBundle(EXTRA_NOTIFEE_NOTIFICATION, notificationModel.toBundle());
+              if (triggerBundle != null) {
+                extrasBundle.putBundle(EXTRA_NOTIFEE_TRIGGER, triggerBundle);
+              }
+              builder.addExtras(extrasBundle);
+
+              // build notification
+              Notification notification = Objects.requireNonNull(builder).build();
+
+              int hashCode = notificationModel.getHashCode();
+
+              NotificationAndroidModel androidBundle = notificationModel.getAndroid();
+              if (androidBundle.getLoopSound()) {
+                notification.flags |= Notification.FLAG_INSISTENT;
+              }
+
+              if (androidBundle.getFlags() != null && androidBundle.getFlags().length > 0) {
+                for (int flag : androidBundle.getFlags()) {
+                  notification.flags |= flag;
+                }
+              }
+
+              if (androidBundle.getLightUpScreen()) {
+                PowerManagerUtils.lightUpScreenIfNeeded(ContextHolder.getApplicationContext());
+              }
+
+              if (androidBundle.getAsForegroundService()) {
+                ForegroundService.start(hashCode, notification, notificationModel.toBundle());
+              } else {
+                NotificationManagerCompat.from(getApplicationContext())
+                    .notify(androidBundle.getTag(), hashCode, notification);
+              }
+
+              EventBus.post(
+                  new NotificationEvent(NotificationEvent.TYPE_DELIVERED, notificationModel));
+
+              return Futures.immediateFuture(null);
+            }, CACHED_THREAD_POOL);
+  }
+
+  static ListenableFuture<Void> createTriggerNotification(
+      NotificationModel notificationModel, Bundle triggerBundle) {
+    return
+        LISTENING_CACHED_THREAD_POOL.submit(
+        () -> {
+          int triggerType = ObjectUtils.getInt(triggerBundle.get("type"));
+          switch (triggerType) {
+            case 0:
+              createTimestampTriggerNotification(notificationModel, triggerBundle);
+              break;
+            case 1:
+              createIntervalTriggerNotification(notificationModel, triggerBundle);
+              break;
+          }
+
+          EventBus.post(
+              new NotificationEvent(
+                  NotificationEvent.TYPE_TRIGGER_NOTIFICATION_CREATED, notificationModel));
+
+          return null;
+        });
+  }
+
+  static void createIntervalTriggerNotification(
+      NotificationModel notificationModel, Bundle triggerBundle) {
+    IntervalTriggerModel trigger = IntervalTriggerModel.fromBundle(triggerBundle);
+    String uniqueWorkName = "trigger:" + notificationModel.getId();
+    WorkManager workManager = WorkManager.getInstance(getApplicationContext());
+
+    Data.Builder workDataBuilder =
+        new Data.Builder()
+            .putString(Worker.KEY_WORK_TYPE, Worker.WORK_TYPE_NOTIFICATION_TRIGGER)
+            .putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_PERIODIC)
+            .putString("id", notificationModel.getId());
+
+    WorkDataRepository.getInstance(getApplicationContext())
+        .insertTriggerNotification(notificationModel, triggerBundle, false);
+
+    long interval = trigger.getInterval();
+
+    PeriodicWorkRequest.Builder workRequestBuilder;
+    workRequestBuilder =
+        new PeriodicWorkRequest.Builder(Worker.class, interval, trigger.getTimeUnit());
+
+    workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
+    workRequestBuilder.addTag(uniqueWorkName);
+    workRequestBuilder.setInputData(workDataBuilder.build());
+    workManager.enqueueUniquePeriodicWork(
+        uniqueWorkName, ExistingPeriodicWorkPolicy.REPLACE, workRequestBuilder.build());
+  }
+
+  static void createTimestampTriggerNotification(
+      NotificationModel notificationModel, Bundle triggerBundle) {
+    TimestampTriggerModel trigger = TimestampTriggerModel.fromBundle(triggerBundle);
+
+    String uniqueWorkName = "trigger:" + notificationModel.getId();
+
+    long delay = trigger.getDelay();
+    int interval = trigger.getInterval();
+
+    // Save in DB
+    Data.Builder workDataBuilder =
+        new Data.Builder()
+            .putString(Worker.KEY_WORK_TYPE, Worker.WORK_TYPE_NOTIFICATION_TRIGGER)
+            .putString("id", notificationModel.getId());
+
+    Boolean withAlarmManager = trigger.getWithAlarmManager();
+
+    WorkDataRepository.getInstance(getApplicationContext())
+        .insertTriggerNotification(notificationModel, triggerBundle, withAlarmManager);
+
+    // Schedule notification with alarm manager
+    if (withAlarmManager) {
+      NotifeeAlarmManager.scheduleTimestampTriggerNotification(notificationModel, trigger);
+      return;
+    }
+
+    // Continue to schedule trigger notification with WorkManager
+    WorkManager workManager = WorkManager.getInstance(getApplicationContext());
+
+    // WorkManager - One time trigger
+    if (interval == -1) {
+      OneTimeWorkRequest.Builder workRequestBuilder = new OneTimeWorkRequest.Builder(Worker.class);
+      workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
+      workRequestBuilder.addTag(uniqueWorkName);
+      workDataBuilder.putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_ONE_TIME);
+      workRequestBuilder.setInputData(workDataBuilder.build());
+      workRequestBuilder.setInitialDelay(delay, TimeUnit.SECONDS);
+      workManager.enqueueUniqueWork(
+          uniqueWorkName, ExistingWorkPolicy.REPLACE, workRequestBuilder.build());
+    } else {
+      // WorkManager - repeat trigger
+      PeriodicWorkRequest.Builder workRequestBuilder;
+
+      workRequestBuilder =
+          new PeriodicWorkRequest.Builder(
+              Worker.class, trigger.getInterval(), trigger.getTimeUnit());
+
+      workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
+      workRequestBuilder.addTag(uniqueWorkName);
+      workRequestBuilder.setInitialDelay(delay, TimeUnit.SECONDS);
+      workDataBuilder.putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_PERIODIC);
+      workRequestBuilder.setInputData(workDataBuilder.build());
+      workManager.enqueueUniquePeriodicWork(
+          uniqueWorkName, ExistingPeriodicWorkPolicy.REPLACE, workRequestBuilder.build());
+    }
+  }
+
+  static ListenableFuture<List<Bundle>> getDisplayedNotifications() {
+    return LISTENING_CACHED_THREAD_POOL.submit(
+        () -> {
+          List<Bundle> notifications = new ArrayList<Bundle>();
+
+          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            return notifications;
+          }
+
+          android.app.NotificationManager notificationManager =
+              (android.app.NotificationManager)
+                  getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE);
+
+          StatusBarNotification delivered[] = notificationManager.getActiveNotifications();
+
+          for (StatusBarNotification sbNotification : delivered) {
+            Notification original = sbNotification.getNotification();
+
+            Bundle extras = original.extras;
+            Bundle displayNotificationBundle = new Bundle();
+
+            Bundle notificationBundle = extras.getBundle(EXTRA_NOTIFEE_NOTIFICATION);
+            Bundle triggerBundle = extras.getBundle(EXTRA_NOTIFEE_TRIGGER);
+
+            if (notificationBundle == null) {
+              notificationBundle = new Bundle();
+              notificationBundle.putString("id", "" + sbNotification.getId());
+
+              Object title = extras.get(Notification.EXTRA_TITLE);
+
+              if (title != null) {
+                notificationBundle.putString("title", title.toString());
+              }
+
+              Object text = extras.get(Notification.EXTRA_TEXT);
+
+              if (text != null) {
+                notificationBundle.putString("body", text.toString());
+              }
+
+              Object subtitle = extras.get(Notification.EXTRA_SUB_TEXT);
+
+              if (subtitle != null) {
+                notificationBundle.putString("subtitle", subtitle.toString());
+              }
+
+              Bundle androidBundle = new Bundle();
+              if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                androidBundle.putString("channelId", original.getChannelId());
+              }
+              androidBundle.putString("tag", sbNotification.getTag());
+              androidBundle.putString("group", original.getGroup());
+
+              notificationBundle.putBundle("android", androidBundle);
+
+              displayNotificationBundle.putString("id", "" + sbNotification.getId());
+            } else {
+              displayNotificationBundle.putString("id", "" + notificationBundle.get("id"));
+            }
+
+            if (triggerBundle != null) {
+              displayNotificationBundle.putBundle("trigger", triggerBundle);
+            }
+
+            displayNotificationBundle.putBundle("notification", notificationBundle);
+            displayNotificationBundle.putString("date", "" + sbNotification.getPostTime());
+
+            notifications.add(displayNotificationBundle);
+          }
+
+          return notifications;
+        });
+  }
+
+  static void getTriggerNotifications(MethodCallResult<List<Bundle>> result) {
+    WorkDataRepository workDataRepository = new WorkDataRepository(getApplicationContext());
+
+    List<Bundle> triggerNotifications = new ArrayList<Bundle>();
+
+    Futures.addCallback(workDataRepository.getAll(),
+      new FutureCallback<List<WorkDataEntity>>() {
+        @Override
+        public void onSuccess(List<WorkDataEntity> workDataEntities) {
+                for (WorkDataEntity workDataEntity : workDataEntities) {
+                  Bundle triggerNotificationBundle = new Bundle();
+
+                  triggerNotificationBundle.putBundle(
+                      "notification", ObjectUtils.bytesToBundle(workDataEntity.getNotification()));
+
+                  triggerNotificationBundle.putBundle(
+                      "trigger", ObjectUtils.bytesToBundle(workDataEntity.getTrigger()));
+                  triggerNotifications.add(triggerNotificationBundle);
+                }
+
+          result.onComplete(null, triggerNotifications);
+        }
+
+          @Override
+          public void onFailure(Throwable t) {
+            result.onComplete(new Exception(t), triggerNotifications);
+          }
+        }, LISTENING_CACHED_THREAD_POOL);
+  }
+
+  static void getTriggerNotificationIds(MethodCallResult<List<String>> result) {
+    WorkDataRepository workDataRepository = new WorkDataRepository(getApplicationContext());
+
+    Futures.addCallback(workDataRepository
+        .getAll(),
+      new FutureCallback<List<WorkDataEntity>>() {
+        @Override
+        public void onSuccess(List<WorkDataEntity> workDataEntities) {
+              List<String> triggerNotificationIds = new ArrayList<String>();
+                for (WorkDataEntity workDataEntity : workDataEntities) {
+                  triggerNotificationIds.add(workDataEntity.getId());
+                }
+
+                result.onComplete(null, triggerNotificationIds);
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+          result.onComplete(new Exception(t), null);
+        }
+      }, LISTENING_CACHED_THREAD_POOL);
+
+  }
+
+  /* Execute work from trigger notifications via WorkManager*/
+  static void doScheduledWork(
+      Data data, CallbackToFutureAdapter.Completer<ListenableWorker.Result> completer) {
+
+    String id = data.getString("id");
+
+    WorkDataRepository workDataRepository = new WorkDataRepository(getApplicationContext());
+
+    AsyncFunction<WorkDataEntity, ListenableFuture<Void>> workContinuation =
+      workDataEntity -> LISTENING_CACHED_THREAD_POOL.submit(() -> {
+        byte[] notificationBytes;
+
+          if (workDataEntity == null || workDataEntity.getNotification() == null) {
+            // check if notification bundle is stored with Work Manager
+            notificationBytes = data.getByteArray("notification");
+            if (notificationBytes != null) {
+              Logger.w(
+                  TAG,
+                  "The trigger notification was created using an older version, please consider"
+                      + " recreating the notification.");
+            } else {
+              Logger.w(
+                  TAG, "Attempted to handle doScheduledWork but no notification data was found.");
+              completer.set(ListenableWorker.Result.success());
+              return Futures.immediateFuture(null);
+            }
+          } else {
+            notificationBytes = workDataEntity.getNotification();
+          }
+
+          NotificationModel notificationModel =
+              NotificationModel.fromBundle(ObjectUtils.bytesToBundle(notificationBytes));
+
+          byte[] triggerBytes = workDataEntity.getTrigger();
+          Bundle triggerBundle = null;
+
+          if (workDataEntity.getTrigger() != null) {
+            triggerBundle = ObjectUtils.bytesToBundle(triggerBytes);
+          }
+
+          return NotificationManager.displayNotification(notificationModel, triggerBundle);
+        });
+
+    new ExtendedListenableFuture<>(workDataRepository
+        .getWorkDataById(id))
+        .continueWith(workContinuation, LISTENING_CACHED_THREAD_POOL)
+        .addOnCompleteListener(
+        (e, result) -> {
+        if (e == null) {
+          new ExtendedListenableFuture<>(result).addOnCompleteListener(
+            (e2, _unused) -> {
+              completer.set(Result.success());
+              if (e2 != null) {
+                Logger.e(TAG, "Failed to display notification", e2);
+              } else {
+                String workerRequestType = data.getString(
+                  Worker.KEY_WORK_REQUEST);
+                if (workerRequestType != null
+                  && workerRequestType.equals(
+                  Worker.WORK_REQUEST_ONE_TIME)) {
+                  // delete database entry if work is a one-time request
+                  WorkDataRepository.getInstance(getApplicationContext())
+                    .deleteById(id);
+                }
+              }
+            }, LISTENING_CACHED_THREAD_POOL);
+        } else {
+          completer.set(Result.success());
+          Logger.e(TAG, "Failed to display notification", e);
+        }
+    }, LISTENING_CACHED_THREAD_POOL);
+  }
+}