@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/android/src/main/java/expo/modules/notifications/notifications/NotificationManager.java

@@ -0,0 +1,119 @@
+package expo.modules.notifications.notifications;
+
+import expo.modules.core.interfaces.SingletonModule;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.WeakHashMap;
+
+import expo.modules.notifications.notifications.interfaces.NotificationListener;
+import expo.modules.notifications.notifications.model.Notification;
+import expo.modules.notifications.notifications.model.NotificationResponse;
+import expo.modules.notifications.service.delegates.ExpoHandlingDelegate;
+
+public class NotificationManager implements SingletonModule, expo.modules.notifications.notifications.interfaces.NotificationManager {
+  private static final String SINGLETON_NAME = "NotificationManager";
+
+  /**
+   * A weak map of listeners -> reference. Used to check quickly whether given listener
+   * is already registered and to iterate over on new token.
+   */
+  private WeakHashMap<NotificationListener, WeakReference<NotificationListener>> mListenerReferenceMap;
+  private Collection<NotificationResponse> mPendingNotificationResponses = new ArrayList<>();
+
+  public NotificationManager() {
+    mListenerReferenceMap = new WeakHashMap<>();
+
+    // Registers this singleton instance in static ExpoHandlingDelegate listeners collection.
+    // Since it doesn't hold strong reference to the object this should be safe.
+    ExpoHandlingDelegate.Companion.addListener(this);
+  }
+
+  @Override
+  public String getName() {
+    return SINGLETON_NAME;
+  }
+
+  /**
+   * Registers a {@link NotificationListener} by adding a {@link WeakReference} to
+   * the {@link NotificationManager#mListenerReferenceMap} map.
+   *
+   * @param listener Listener to be notified of new messages.
+   */
+  @Override
+  public void addListener(NotificationListener listener) {
+    // Check if the listener is already registered
+    if (!mListenerReferenceMap.containsKey(listener)) {
+      WeakReference<NotificationListener> listenerReference = new WeakReference<>(listener);
+      mListenerReferenceMap.put(listener, listenerReference);
+      if (!mPendingNotificationResponses.isEmpty()) {
+        for (NotificationResponse pendingResponse : mPendingNotificationResponses) {
+          listener.onNotificationResponseReceived(pendingResponse);
+        }
+      }
+    }
+  }
+
+  /**
+   * Unregisters a {@link NotificationListener} by removing the {@link WeakReference} to the listener
+   * from the {@link NotificationManager#mListenerReferenceMap} map.
+   *
+   * @param listener Listener previously registered with {@link NotificationManager#addListener(NotificationListener)}.
+   */
+  @Override
+  public void removeListener(NotificationListener listener) {
+    mListenerReferenceMap.remove(listener);
+  }
+
+  /**
+   * Used by {@link expo.modules.notifications.service.delegates.ExpoSchedulingDelegate} to notify of new messages.
+   * Calls {@link NotificationListener#onNotificationReceived(Notification)} on all values
+   * of {@link NotificationManager#mListenerReferenceMap}.
+   *
+   * @param notification Notification received
+   */
+  public void onNotificationReceived(Notification notification) {
+    for (WeakReference<NotificationListener> listenerReference : mListenerReferenceMap.values()) {
+      NotificationListener listener = listenerReference.get();
+      if (listener != null) {
+        listener.onNotificationReceived(notification);
+      }
+    }
+  }
+
+  /**
+   * Used by {@link expo.modules.notifications.service.delegates.ExpoSchedulingDelegate} to notify of new notification responses.
+   * Calls {@link NotificationListener#onNotificationResponseReceived(NotificationResponse)} on all values
+   * of {@link NotificationManager#mListenerReferenceMap}.
+   *
+   * @param response Notification response received
+   */
+  public void onNotificationResponseReceived(NotificationResponse response) {
+    if (mListenerReferenceMap.isEmpty()) {
+      mPendingNotificationResponses.add(response);
+    } else {
+      for (WeakReference<NotificationListener> listenerReference : mListenerReferenceMap.values()) {
+        NotificationListener listener = listenerReference.get();
+        if (listener != null) {
+          listener.onNotificationResponseReceived(response);
+        }
+      }
+    }
+  }
+
+  /**
+   * Used by {@link expo.modules.notifications.service.delegates.ExpoSchedulingDelegate} to notify of message deletion event.
+   * Calls {@link NotificationListener#onNotificationsDropped()} on all values
+   * of {@link NotificationManager#mListenerReferenceMap}.
+   */
+  public void onNotificationsDropped() {
+    for (WeakReference<NotificationListener> listenerReference : mListenerReferenceMap.values()) {
+      NotificationListener listener = listenerReference.get();
+      if (listener != null) {
+        listener.onNotificationsDropped();
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/NotificationSerializer.java

@@ -0,0 +1,202 @@
+package expo.modules.notifications.notifications;
+
+import android.os.Build;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import expo.modules.core.arguments.MapArguments;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import expo.modules.notifications.notifications.interfaces.NotificationTrigger;
+import expo.modules.notifications.notifications.model.Notification;
+import expo.modules.notifications.notifications.model.NotificationAction;
+import expo.modules.notifications.notifications.model.NotificationCategory;
+import expo.modules.notifications.notifications.model.NotificationContent;
+import expo.modules.notifications.notifications.model.NotificationRequest;
+import expo.modules.notifications.notifications.model.NotificationResponse;
+import expo.modules.notifications.notifications.model.TextInputNotificationAction;
+import expo.modules.notifications.notifications.model.TextInputNotificationResponse;
+import expo.modules.notifications.notifications.model.triggers.FirebaseNotificationTrigger;
+
+import expo.modules.notifications.notifications.triggers.ChannelAwareTrigger;
+import expo.modules.notifications.notifications.triggers.DailyTrigger;
+import expo.modules.notifications.notifications.triggers.DateTrigger;
+import expo.modules.notifications.notifications.triggers.TimeIntervalTrigger;
+import expo.modules.notifications.notifications.triggers.WeeklyTrigger;
+import expo.modules.notifications.notifications.triggers.YearlyTrigger;
+
+public class NotificationSerializer {
+  public static Bundle toBundle(NotificationResponse response) {
+    Bundle serializedResponse = new Bundle();
+    serializedResponse.putString("actionIdentifier", response.getActionIdentifier());
+    serializedResponse.putBundle("notification", toBundle(response.getNotification()));
+    if (response instanceof TextInputNotificationResponse) {
+      serializedResponse.putString("userText", ((TextInputNotificationResponse) response).getUserText());
+    }
+    return serializedResponse;
+  }
+
+  public static Bundle toBundle(Notification notification) {
+    Bundle serializedNotification = new Bundle();
+    serializedNotification.putBundle("request", toBundle(notification.getNotificationRequest()));
+    serializedNotification.putLong("date", notification.getDate().getTime());
+    return serializedNotification;
+  }
+
+  public static Bundle toBundle(NotificationRequest request) {
+    Bundle serializedRequest = new Bundle();
+    serializedRequest.putString("identifier", request.getIdentifier());
+    serializedRequest.putBundle("content", toBundle(request.getContent()));
+    serializedRequest.putBundle("trigger", toBundle(request.getTrigger()));
+    return serializedRequest;
+  }
+
+  public static Bundle toBundle(NotificationContent content) {
+    Bundle serializedContent = new Bundle();
+    serializedContent.putString("title", content.getTitle());
+    serializedContent.putString("subtitle", content.getSubtitle());
+    serializedContent.putString("body", content.getText());
+    if (content.getColor() != null) {
+      serializedContent.putString("color", String.format("#%08X", content.getColor().intValue()));
+    }
+    serializedContent.putBundle("data", toBundle(content.getBody()));
+    if (content.getBadgeCount() != null) {
+      serializedContent.putInt("badge", content.getBadgeCount().intValue());
+    } else {
+      serializedContent.putString("badge", null);
+    }
+    if (content.shouldPlayDefaultSound()) {
+      serializedContent.putString("sound", "default");
+    } else if (content.getSound() != null) {
+      serializedContent.putString("sound", "custom");
+    } else {
+      serializedContent.putString("sound", null);
+    }
+    if (content.getPriority() != null) {
+      serializedContent.putString("priority", content.getPriority().getEnumValue());
+    }
+    if (content.getVibrationPattern() != null) {
+      double[] serializedVibrationPattern = new double[content.getVibrationPattern().length];
+      for (int i = 0; i < serializedVibrationPattern.length; i++) {
+        serializedVibrationPattern[i] = content.getVibrationPattern()[i];
+      }
+      serializedContent.putDoubleArray("vibrationPattern", serializedVibrationPattern);
+    }
+    serializedContent.putBoolean("autoDismiss", content.isAutoDismiss());
+    if (content.getCategoryId() != null) {
+      serializedContent.putString("categoryIdentifier", content.getCategoryId());
+    }
+    serializedContent.putBoolean("sticky", content.isSticky());
+    return serializedContent;
+  }
+
+  public static Bundle toBundle(@Nullable JSONObject notification) {
+    if (notification == null) {
+      return null;
+    }
+    Map<String, Object> notificationMap = new HashMap<>(notification.length());
+    Iterator<String> keyIterator = notification.keys();
+    while (keyIterator.hasNext()) {
+      String key = keyIterator.next();
+      Object value = notification.opt(key);
+      if (value instanceof JSONObject) {
+        notificationMap.put(key, toBundle((JSONObject) value));
+      } else if (value instanceof JSONArray) {
+        notificationMap.put(key, toList((JSONArray) value));
+      } else if (JSONObject.NULL.equals(value)) {
+        notificationMap.put(key, null);
+      } else {
+        notificationMap.put(key, value);
+      }
+    }
+    try {
+      return new MapArguments(notificationMap).toBundle();
+    } catch (NullPointerException e) {
+      // If a NullPointerException was thrown it most probably means
+      // that @unimodules/core is at < 5.1.1 where we introduced
+      // support for null values in MapArguments' map). Let's go through
+      // the map and remove the null values to be backwards compatible.
+
+      Set<String> keySet = notificationMap.keySet();
+      for (String key : keySet) {
+        if (notificationMap.get(key) == null) {
+          notificationMap.remove(key);
+        }
+      }
+      return new MapArguments(notificationMap).toBundle();
+    }
+  }
+
+  private static List<Object> toList(JSONArray array) {
+    List<Object> result = new ArrayList<>(array.length());
+    for (int i = 0; i < array.length(); i++) {
+      if (array.isNull(i)) {
+        result.add(null);
+      } else if (array.optJSONObject(i) != null) {
+        result.add(toBundle(array.optJSONObject(i)));
+      } else if (array.optJSONArray(i) != null) {
+        result.add(toList(array.optJSONArray(i)));
+      } else {
+        result.add(array.opt(i));
+      }
+    }
+    return result;
+  }
+
+  private static Bundle toBundle(@Nullable NotificationTrigger trigger) {
+    if (trigger == null) {
+      return null;
+    }
+    Bundle bundle = new Bundle();
+    if (trigger instanceof FirebaseNotificationTrigger) {
+      bundle.putString("type", "push");
+      bundle.putBundle("remoteMessage", RemoteMessageSerializer.toBundle(((FirebaseNotificationTrigger) trigger).getRemoteMessage()));
+    } else if (trigger instanceof TimeIntervalTrigger) {
+      bundle.putString("type", "timeInterval");
+      bundle.putBoolean("repeats", ((TimeIntervalTrigger) trigger).isRepeating());
+      bundle.putLong("seconds", ((TimeIntervalTrigger) trigger).getTimeInterval());
+    } else if (trigger instanceof DateTrigger) {
+      bundle.putString("type", "date");
+      bundle.putBoolean("repeats", false);
+      bundle.putLong("value", ((DateTrigger) trigger).getTriggerDate().getTime());
+    } else if (trigger instanceof DailyTrigger) {
+      bundle.putString("type", "daily");
+      bundle.putInt("hour", ((DailyTrigger) trigger).getHour());
+      bundle.putInt("minute", ((DailyTrigger) trigger).getMinute());
+    } else if (trigger instanceof WeeklyTrigger) {
+      bundle.putString("type", "weekly");
+      bundle.putInt("weekday", ((WeeklyTrigger) trigger).getWeekday());
+      bundle.putInt("hour", ((WeeklyTrigger) trigger).getHour());
+      bundle.putInt("minute", ((WeeklyTrigger) trigger).getMinute());
+    } else if (trigger instanceof YearlyTrigger) {
+      bundle.putString("type", "yearly");
+      bundle.putInt("day", ((YearlyTrigger) trigger).getDay());
+      bundle.putInt("month", ((YearlyTrigger) trigger).getMonth());
+      bundle.putInt("hour", ((YearlyTrigger) trigger).getHour());
+      bundle.putInt("minute", ((YearlyTrigger) trigger).getMinute());
+    } else {
+      bundle.putString("type", "unknown");
+    }
+    bundle.putString("channelId", getChannelId(trigger));
+
+    return bundle;
+  }
+
+  @Nullable
+  private static String getChannelId(NotificationTrigger trigger) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      return trigger.getNotificationChannel();
+    }
+    return null;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/RemoteMessageSerializer.java

@@ -0,0 +1,104 @@
+package expo.modules.notifications.notifications;
+
+import android.os.Bundle;
+
+import com.google.firebase.messaging.RemoteMessage;
+
+import java.util.Map;
+
+import androidx.annotation.Nullable;
+
+/**
+ * Serializes all the information available in {@link RemoteMessage}
+ * to {@link Bundle}.
+ */
+public class RemoteMessageSerializer {
+  /**
+   * Serializes all the information available in {@link RemoteMessage}
+   *
+   * @param message {@link RemoteMessage} to serialize
+   * @return Serialized message
+   */
+  public static Bundle toBundle(RemoteMessage message) {
+    Bundle serializedMessage = new Bundle();
+    serializedMessage.putString("collapseKey", message.getCollapseKey());
+    serializedMessage.putBundle("data", toBundle(message.getData()));
+    serializedMessage.putString("from", message.getFrom());
+    serializedMessage.putString("messageId", message.getMessageId());
+    serializedMessage.putString("messageType", message.getMessageType());
+    serializedMessage.putBundle("notification", toBundle(message.getNotification()));
+    serializedMessage.putInt("originalPriority", message.getOriginalPriority());
+    serializedMessage.putInt("priority", message.getPriority());
+    serializedMessage.putLong("sentTime", message.getSentTime());
+    serializedMessage.putString("to", message.getTo());
+    serializedMessage.putInt("ttl", message.getTtl());
+    return serializedMessage;
+  }
+
+  private static Bundle toBundle(Map<String, String> data) {
+    Bundle serializedData = new Bundle();
+    for (Map.Entry<String, String> dataEntry : data.entrySet()) {
+      serializedData.putString(dataEntry.getKey(), dataEntry.getValue());
+    }
+    return serializedData;
+  }
+
+  private static Bundle toBundle(@Nullable RemoteMessage.Notification notification) {
+    if (notification == null) {
+      return null;
+    }
+
+    Bundle serializedNotification = new Bundle();
+    serializedNotification.putString("body", notification.getBody());
+    serializedNotification.putStringArray("bodyLocalizationArgs", notification.getBodyLocalizationArgs());
+    serializedNotification.putString("bodyLocalizationKey", notification.getBodyLocalizationKey());
+    serializedNotification.putString("channelId", notification.getChannelId());
+    serializedNotification.putString("clickAction", notification.getClickAction());
+    serializedNotification.putString("color", notification.getColor());
+    serializedNotification.putBoolean("usesDefaultLightSettings", notification.getDefaultLightSettings());
+    serializedNotification.putBoolean("usesDefaultSound", notification.getDefaultSound());
+    serializedNotification.putBoolean("usesDefaultVibrateSettings", notification.getDefaultVibrateSettings());
+    if (notification.getEventTime() != null) {
+      serializedNotification.putLong("eventTime", notification.getEventTime());
+    } else {
+      serializedNotification.putString("eventTime", null);
+    }
+    serializedNotification.putString("icon", notification.getIcon());
+    if (notification.getImageUrl() != null) {
+      serializedNotification.putString("imageUrl", notification.getImageUrl().toString());
+    } else {
+      serializedNotification.putString("imageUrl", null);
+    }
+    serializedNotification.putIntArray("lightSettings", notification.getLightSettings());
+    if (notification.getLink() != null) {
+      serializedNotification.putString("link", notification.getLink().toString());
+    } else {
+      serializedNotification.putString("link", null);
+    }
+    serializedNotification.putBoolean("localOnly", notification.getLocalOnly());
+    if (notification.getNotificationCount() != null) {
+      serializedNotification.putInt("notificationCount", notification.getNotificationCount());
+    } else {
+      serializedNotification.putString("notificationCount", null);
+    }
+    if (notification.getNotificationPriority() != null) {
+      serializedNotification.putInt("notificationPriority", notification.getNotificationPriority());
+    } else {
+      serializedNotification.putString("notificationPriority", null);
+    }
+    serializedNotification.putString("sound", notification.getSound());
+    serializedNotification.putBoolean("sticky", notification.getSticky());
+    serializedNotification.putString("tag", notification.getTag());
+    serializedNotification.putString("ticker", notification.getTicker());
+    serializedNotification.putString("title", notification.getTitle());
+    serializedNotification.putStringArray("titleLocalizationArgs", notification.getTitleLocalizationArgs());
+    serializedNotification.putString("titleLocalizationKey", notification.getTitleLocalizationKey());
+    serializedNotification.putLongArray("vibrateTimings", notification.getVibrateTimings());
+    if (notification.getVisibility() != null) {
+      serializedNotification.putInt("visibility", notification.getVisibility());
+    } else {
+      serializedNotification.putString("visibility", null);
+    }
+    return serializedNotification;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/SoundResolver.java

@@ -0,0 +1,58 @@
+package expo.modules.notifications.notifications;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.net.Uri;
+import android.provider.Settings;
+
+import androidx.annotation.Nullable;
+
+/**
+ * A shared logic between ContentBuilders ({@link ArgumentsNotificationContentBuilder}
+ * and {@link JSONNotificationContentBuilder}) for resolving sounds based on the "sound" property.
+ */
+public class SoundResolver {
+  private Context mContext;
+
+  public SoundResolver(Context context) {
+    mContext = context;
+  }
+
+  /**
+   * For given filename tries to resolve a raw resource by basename.
+   *
+   * @param filename A sound's filename
+   * @return null if there was no sound found for the filename or a {@link Uri} to the raw resource
+   * if one could be found.
+   */
+  @Nullable
+  public Uri resolve(@Nullable String filename) {
+    if (filename == null || filename.length() == 0) {
+      return null;
+    }
+
+    String packageName = mContext.getPackageName();
+    String resourceName = filenameToBasename(filename);
+    int resourceId = mContext.getResources().getIdentifier(resourceName, "raw", packageName);
+    // If resourceId is 0, then the resource does not exist.
+    // Returning null falls back to using a default sound.
+    if (resourceId != 0) {
+      return new Uri.Builder()
+        .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
+        .authority(packageName)
+        .appendPath("raw")
+        .appendPath(resourceName)
+        .build();
+    }
+
+    return Settings.System.DEFAULT_NOTIFICATION_URI;
+  }
+
+  private String filenameToBasename(String filename) {
+    if (!filename.contains(".")) {
+      return filename;
+    }
+
+    return filename.substring(0, filename.lastIndexOf('.'));
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/background/BackgroundRemoteNotificationTaskConsumer.java

@@ -0,0 +1,123 @@
+package expo.modules.notifications.notifications.background;
+
+import android.app.job.JobParameters;
+import android.app.job.JobService;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.PersistableBundle;
+import android.util.Log;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import expo.modules.notifications.notifications.NotificationSerializer;
+import expo.modules.notifications.service.delegates.FirebaseMessagingDelegate;
+import expo.modules.interfaces.taskManager.TaskConsumer;
+import expo.modules.interfaces.taskManager.TaskConsumerInterface;
+import expo.modules.interfaces.taskManager.TaskExecutionCallback;
+import expo.modules.interfaces.taskManager.TaskInterface;
+import expo.modules.interfaces.taskManager.TaskManagerUtilsInterface;
+
+/**
+ * Represents a task to be run when the app is receives a remote push
+ * notification. Map of current tasks is maintained in {@link FirebaseMessagingDelegate}.
+ */
+public class BackgroundRemoteNotificationTaskConsumer extends TaskConsumer implements TaskConsumerInterface {
+  private static final String TAG = BackgroundRemoteNotificationTaskConsumer.class.getSimpleName();
+  private static final String NOTIFICATION_KEY = "notification";
+
+  private TaskInterface mTask;
+
+  public BackgroundRemoteNotificationTaskConsumer(Context context, TaskManagerUtilsInterface taskManagerUtils) {
+    super(context, taskManagerUtils);
+    FirebaseMessagingDelegate.Companion.addBackgroundTaskConsumer(this);
+  }
+
+  //region TaskConsumerInterface
+
+  @Override
+  public String taskType() {
+    return "remote-notification";
+  }
+
+  @Override
+  public void didRegister(TaskInterface task) {
+    mTask = task;
+  }
+
+  @Override
+  public void didUnregister() {
+    mTask = null;
+  }
+
+  public void scheduleJob(Bundle bundle) {
+    Context context = getContext();
+
+    if (context != null && mTask != null) {
+      PersistableBundle data = new PersistableBundle();
+      // Bundles are not persistable, so let's convert to a JSON string
+      data.putString(NOTIFICATION_KEY, bundleToJson(bundle).toString());
+      getTaskManagerUtils().scheduleJob(context, mTask, Collections.singletonList(data));
+    }
+  }
+
+  @Override
+  public boolean didExecuteJob(final JobService jobService, final JobParameters params) {
+    if (mTask == null) {
+      return false;
+    }
+
+    List<PersistableBundle> data = getTaskManagerUtils().extractDataFromJobParams(params);
+
+    for (PersistableBundle item : data) {
+      Bundle bundle = new Bundle();
+      bundle.putBundle(NOTIFICATION_KEY, jsonStringToBundle(item.getString(NOTIFICATION_KEY)));
+      mTask.execute(bundle, null, new TaskExecutionCallback() {
+        @Override
+        public void onFinished(Map<String, Object> response) {
+          jobService.jobFinished(params, false);
+        }
+      });
+    }
+
+    // Returning `true` indicates that the job is still running, but in async mode.
+    // In that case we're obligated to call `jobService.jobFinished` as soon as the async block finishes.
+    return true;
+  }
+
+  //endregion
+  //region private methods
+
+  private static JSONObject bundleToJson(Bundle bundle) {
+    JSONObject json = new JSONObject();
+    for (String key : bundle.keySet()) {
+      try {
+        if (bundle.get(key) instanceof Bundle) {
+          json.put(key, bundleToJson((Bundle) bundle.get(key)));
+        } else {
+          json.put(key, JSONObject.wrap(bundle.get(key)));
+        }
+      } catch(JSONException e) {
+        Log.e("expo-notifications", "Could not create JSON object from notification bundle. " + e.getMessage());
+      }
+    }
+    return json;
+  }
+
+  private static Bundle jsonStringToBundle(String jsonString) {
+    Bundle bundle = new Bundle();
+    try {
+      JSONObject jsonObject = new JSONObject(jsonString);
+      bundle = NotificationSerializer.toBundle(jsonObject);
+    } catch (JSONException e) {
+      Log.e("expo-notifications", "Could not parse notification from JSON string. " + e.getMessage());
+    }
+    return bundle;
+  }
+
+  //endregion
+}

package/android/src/main/java/expo/modules/notifications/notifications/background/ExpoBackgroundNotificationTasksModule.kt

@@ -0,0 +1,33 @@
+package expo.modules.notifications.notifications.background
+
+import expo.modules.interfaces.taskManager.TaskManagerInterface
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ModuleNotFoundException
+
+class ExpoBackgroundNotificationTasksModule : Module() {
+  private lateinit var taskManager: TaskManagerInterface
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoBackgroundNotificationTasksModule")
+    OnCreate {
+      taskManager = appContext.legacyModule()
+        ?: throw ModuleNotFoundException(TaskManagerInterface::class)
+    }
+
+    AsyncFunction("registerTaskAsync") { taskName: String ->
+      taskManager.registerTask(
+        taskName,
+        BackgroundRemoteNotificationTaskConsumer::class.java,
+        emptyMap()
+      )
+    }
+
+    AsyncFunction("unregisterTaskAsync") { taskName: String ->
+      taskManager.unregisterTask(
+        taskName,
+        BackgroundRemoteNotificationTaskConsumer::class.java
+      )
+    }
+  }
+}