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

package/android/src/main/java/expo/modules/notifications/notifications/channels/managers/AndroidXNotificationsChannelManager.java

@@ -0,0 +1,196 @@
+package expo.modules.notifications.notifications.channels.managers;
+
+import android.app.NotificationChannel;
+import android.app.NotificationChannelGroup;
+import android.content.Context;
+import android.graphics.Color;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+
+import expo.modules.core.arguments.MapArguments;
+import expo.modules.core.arguments.ReadableArguments;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationManagerCompat;
+import expo.modules.notifications.notifications.SoundResolver;
+import expo.modules.notifications.notifications.channels.InvalidVibrationPatternException;
+import expo.modules.notifications.notifications.enums.AudioContentType;
+import expo.modules.notifications.notifications.enums.AudioUsage;
+import expo.modules.notifications.notifications.enums.NotificationVisibility;
+
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.AUDIO_ATTRIBUTES_CONTENT_TYPE_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.AUDIO_ATTRIBUTES_FLAGS_ENFORCE_AUDIBILITY_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.AUDIO_ATTRIBUTES_FLAGS_HW_AV_SYNC_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.AUDIO_ATTRIBUTES_FLAGS_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.AUDIO_ATTRIBUTES_USAGE_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.BYPASS_DND_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.DESCRIPTION_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.ENABLE_LIGHTS_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.ENABLE_VIBRATE_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.GROUP_ID_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.LIGHT_COLOR_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.LOCKSCREEN_VISIBILITY_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.SHOW_BADGE_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.SOUND_AUDIO_ATTRIBUTES_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.SOUND_KEY;
+import static expo.modules.notifications.notifications.channels.serializers.NotificationsChannelSerializer.VIBRATION_PATTERN_KEY;
+
+
+public class AndroidXNotificationsChannelManager implements NotificationsChannelManager {
+  private final NotificationManagerCompat mNotificationManager;
+  private NotificationsChannelGroupManager mNotificationsChannelGroupManager;
+  private final SoundResolver mSoundResolver;
+
+  public AndroidXNotificationsChannelManager(Context context, NotificationsChannelGroupManager groupManager) {
+    mNotificationManager = NotificationManagerCompat.from(context);
+    mSoundResolver = new SoundResolver(context);
+    mNotificationsChannelGroupManager = groupManager;
+  }
+
+
+  @Nullable
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public NotificationChannel getNotificationChannel(@NonNull String channelId) {
+    return mNotificationManager.getNotificationChannel(channelId);
+  }
+
+  @NonNull
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public List<NotificationChannel> getNotificationChannels() {
+    return mNotificationManager.getNotificationChannels();
+  }
+
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public void deleteNotificationChannel(@NonNull String channelId) {
+    mNotificationManager.deleteNotificationChannel(channelId);
+  }
+
+  @Override
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public NotificationChannel createNotificationChannel(@NonNull String channelId, CharSequence name, int importance, ReadableArguments channelOptions) {
+    NotificationChannel channel = new NotificationChannel(channelId, name, importance);
+    configureChannelWithOptions(channel, channelOptions);
+    mNotificationManager.createNotificationChannel(channel);
+    return channel;
+  }
+
+  // Processing options
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  protected void configureChannelWithOptions(Object maybeChannel, ReadableArguments args) {
+    // We cannot use NotificationChannel in the signature of the method
+    // since it's a class available only on newer OSes and the adapter iterates
+    // through all the methods and triggers the NoClassDefFoundError.
+    if (!(maybeChannel instanceof NotificationChannel)) {
+      return;
+    }
+    NotificationChannel channel = (NotificationChannel) maybeChannel;
+    if (args.containsKey(BYPASS_DND_KEY)) {
+      channel.setBypassDnd(args.getBoolean(BYPASS_DND_KEY));
+    }
+    if (args.containsKey(DESCRIPTION_KEY)) {
+      channel.setDescription(args.getString(DESCRIPTION_KEY));
+    }
+    if (args.containsKey(LIGHT_COLOR_KEY)) {
+      channel.setLightColor(Color.parseColor(args.getString(LIGHT_COLOR_KEY)));
+    }
+    if (args.containsKey(GROUP_ID_KEY)) {
+      String groupId = args.getString(GROUP_ID_KEY);
+      NotificationChannelGroup group = mNotificationsChannelGroupManager.getNotificationChannelGroup(groupId);
+      if (group == null) {
+        group = mNotificationsChannelGroupManager.createNotificationChannelGroup(groupId, groupId, new MapArguments());
+      }
+      channel.setGroup(group.getId());
+    }
+    if (args.containsKey(LOCKSCREEN_VISIBILITY_KEY)) {
+      NotificationVisibility visibility = NotificationVisibility.fromEnumValue(args.getInt(LOCKSCREEN_VISIBILITY_KEY));
+      if (visibility != null) {
+        channel.setLockscreenVisibility(visibility.getNativeValue());
+      }
+    }
+    if (args.containsKey(SHOW_BADGE_KEY)) {
+      channel.setShowBadge(args.getBoolean(SHOW_BADGE_KEY));
+    }
+    if (args.containsKey(SOUND_KEY) || args.containsKey(SOUND_AUDIO_ATTRIBUTES_KEY)) {
+      Uri soundUri = createSoundUriFromArguments(args);
+      AudioAttributes soundAttributes = createAttributesFromArguments(args.getArguments(SOUND_AUDIO_ATTRIBUTES_KEY));
+      channel.setSound(soundUri, soundAttributes);
+    }
+    if (args.containsKey(VIBRATION_PATTERN_KEY)) {
+      channel.setVibrationPattern(createVibrationPatternFromList(args.getList(VIBRATION_PATTERN_KEY)));
+    }
+    if (args.containsKey(ENABLE_LIGHTS_KEY)) {
+      channel.enableLights(args.getBoolean(ENABLE_LIGHTS_KEY));
+    }
+    if (args.containsKey(ENABLE_VIBRATE_KEY)) {
+      channel.enableVibration(args.getBoolean(ENABLE_VIBRATE_KEY));
+    }
+  }
+
+  @Nullable
+  protected Uri createSoundUriFromArguments(ReadableArguments args) {
+    // The default is... the default sound.
+    if (!args.containsKey(SOUND_KEY)) {
+      return Settings.System.DEFAULT_NOTIFICATION_URI;
+    }
+    // "null" means "no sound"
+    String filename = args.getString(SOUND_KEY);
+    if (filename == null) {
+      return null;
+    }
+    // Otherwise it should be a sound filename
+    return mSoundResolver.resolve(filename);
+  }
+
+  @Nullable
+  protected long[] createVibrationPatternFromList(@Nullable List patternRequest) throws InvalidVibrationPatternException {
+    if (patternRequest == null) {
+      return null;
+    }
+
+    long[] pattern = new long[patternRequest.size()];
+    for (int i = 0; i < patternRequest.size(); i++) {
+      if (patternRequest.get(i) instanceof Number) {
+        pattern[i] = ((Number) patternRequest.get(i)).longValue();
+      } else {
+        throw new InvalidVibrationPatternException(i, patternRequest.get(i));
+      }
+    }
+    return pattern;
+  }
+
+  @Nullable
+  protected AudioAttributes createAttributesFromArguments(@Nullable ReadableArguments args) {
+    if (args == null) {
+      return null;
+    }
+
+    AudioAttributes.Builder attributesBuilder = new AudioAttributes.Builder();
+    if (args.containsKey(AUDIO_ATTRIBUTES_USAGE_KEY)) {
+      attributesBuilder.setUsage(AudioUsage.fromEnumValue(args.getInt(AUDIO_ATTRIBUTES_USAGE_KEY)).getNativeValue());
+    }
+    if (args.containsKey(AUDIO_ATTRIBUTES_CONTENT_TYPE_KEY)) {
+      attributesBuilder.setContentType(AudioContentType.fromEnumValue(args.getInt(AUDIO_ATTRIBUTES_CONTENT_TYPE_KEY)).getNativeValue());
+    }
+    if (args.containsKey(AUDIO_ATTRIBUTES_FLAGS_KEY)) {
+      int flags = 0;
+      ReadableArguments flagsArgs = args.getArguments(AUDIO_ATTRIBUTES_FLAGS_KEY);
+      if (flagsArgs.getBoolean(AUDIO_ATTRIBUTES_FLAGS_ENFORCE_AUDIBILITY_KEY)) {
+        flags |= AudioAttributes.FLAG_AUDIBILITY_ENFORCED;
+      }
+      if (flagsArgs.getBoolean(AUDIO_ATTRIBUTES_FLAGS_HW_AV_SYNC_KEY)) {
+        flags |= AudioAttributes.FLAG_HW_AV_SYNC;
+      }
+      attributesBuilder.setFlags(flags);
+    }
+    return attributesBuilder.build();
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/managers/NotificationsChannelGroupManager.java

@@ -0,0 +1,28 @@
+package expo.modules.notifications.notifications.channels.managers;
+
+import android.app.NotificationChannelGroup;
+import android.os.Build;
+
+import expo.modules.core.arguments.ReadableArguments;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+public interface NotificationsChannelGroupManager {
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  NotificationChannelGroup getNotificationChannelGroup(@NonNull String channelGroupId);
+
+  @NonNull
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  List<NotificationChannelGroup> getNotificationChannelGroups();
+
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  NotificationChannelGroup createNotificationChannelGroup(@NonNull String id, @NonNull CharSequence name, ReadableArguments groupOptions);
+
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  void deleteNotificationChannelGroup(@NonNull String groupId);
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/managers/NotificationsChannelManager.java

@@ -0,0 +1,28 @@
+package expo.modules.notifications.notifications.channels.managers;
+
+import android.app.NotificationChannel;
+import android.os.Build;
+
+import expo.modules.core.arguments.ReadableArguments;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+public interface NotificationsChannelManager {
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  NotificationChannel getNotificationChannel(@NonNull String channelId);
+
+  @NonNull
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  List<NotificationChannel> getNotificationChannels();
+
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  void deleteNotificationChannel(@NonNull String channelId);
+
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  NotificationChannel createNotificationChannel(@NonNull String channelId, CharSequence name, int importance, ReadableArguments channelOptions);
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/serializers/ExpoNotificationsChannelGroupSerializer.java

@@ -0,0 +1,55 @@
+package expo.modules.notifications.notifications.channels.serializers;
+
+import android.app.NotificationChannel;
+import android.app.NotificationChannelGroup;
+import android.os.Build;
+import android.os.Bundle;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+public class ExpoNotificationsChannelGroupSerializer implements NotificationsChannelGroupSerializer {
+
+  private NotificationsChannelSerializer mChannelSerializer;
+
+  public ExpoNotificationsChannelGroupSerializer(NotificationsChannelSerializer channelSerializer) {
+    mChannelSerializer = channelSerializer;
+  }
+
+  @Override
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public Bundle toBundle(@Nullable NotificationChannelGroup group) {
+    if (group == null) {
+      return null;
+    }
+    Bundle result = new Bundle();
+    result.putString(ID_KEY, getId(group));
+    result.putString(NAME_KEY, group.getName().toString());
+    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.P) {
+      result.putString(DESCRIPTION_KEY, group.getDescription());
+      result.putBoolean(IS_BLOCKED_KEY, group.isBlocked());
+    }
+    result.putParcelableArrayList(CHANNELS_KEY, toList(group.getChannels()));
+    return result;
+  }
+
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  protected String getId(@NonNull NotificationChannelGroup channel) {
+    return channel.getId();
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  private ArrayList<Bundle> toList(List<NotificationChannel> channels) {
+    ArrayList<Bundle> results = new ArrayList<>(channels.size());
+    for (NotificationChannel channel : channels) {
+      results.add(mChannelSerializer.toBundle(channel));
+    }
+    return results;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/serializers/ExpoNotificationsChannelSerializer.java

@@ -0,0 +1,101 @@
+package expo.modules.notifications.notifications.channels.serializers;
+
+import android.app.NotificationChannel;
+import android.graphics.Color;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.provider.Settings;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import expo.modules.notifications.notifications.enums.AudioContentType;
+import expo.modules.notifications.notifications.enums.AudioUsage;
+import expo.modules.notifications.notifications.enums.NotificationImportance;
+import expo.modules.notifications.notifications.enums.NotificationVisibility;
+
+public class ExpoNotificationsChannelSerializer implements NotificationsChannelSerializer {
+
+  @Override
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  public Bundle toBundle(@Nullable NotificationChannel channel) {
+    if (channel == null) {
+      return null;
+    }
+
+    Bundle result = new Bundle();
+    result.putString(ID_KEY, getChannelId(channel));
+    result.putString(NAME_KEY, channel.getName().toString());
+    result.putInt(IMPORTANCE_KEY, NotificationImportance.fromNativeValue(channel.getImportance()).getEnumValue());
+    result.putBoolean(BYPASS_DND_KEY, channel.canBypassDnd());
+    result.putString(DESCRIPTION_KEY, channel.getDescription());
+    result.putString(GROUP_ID_KEY, getGroupId(channel));
+    result.putString(LIGHT_COLOR_KEY, String.format("#%08x", Color.valueOf(channel.getLightColor()).toArgb()).toUpperCase());
+    result.putInt(LOCKSCREEN_VISIBILITY_KEY, NotificationVisibility.fromNativeValue(channel.getLockscreenVisibility()).getEnumValue());
+    result.putBoolean(SHOW_BADGE_KEY, channel.canShowBadge());
+    result.putString(SOUND_KEY, toString(channel.getSound()));
+    result.putBundle(SOUND_AUDIO_ATTRIBUTES_KEY, toBundle(channel.getAudioAttributes()));
+    result.putDoubleArray(VIBRATION_PATTERN_KEY, toArray(channel.getVibrationPattern()));
+    result.putBoolean(ENABLE_LIGHTS_KEY, channel.shouldShowLights());
+    result.putBoolean(ENABLE_VIBRATE_KEY, channel.shouldVibrate());
+    return result;
+  }
+
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  protected String getChannelId(@NonNull NotificationChannel channel) {
+    return channel.getId();
+  }
+
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  protected String getGroupId(@NonNull NotificationChannel channel) {
+    return channel.getGroup();
+  }
+
+  @Nullable
+  private String toString(@Nullable Uri uri) {
+    if (uri == null) {
+      return null;
+    }
+
+    if (Settings.System.DEFAULT_NOTIFICATION_URI.equals(uri)) {
+      return "default";
+    }
+
+    return "custom";
+  }
+
+  private Bundle toBundle(@Nullable AudioAttributes attributes) {
+    if (attributes == null) {
+      return null;
+    }
+
+    Bundle result = new Bundle();
+    result.putInt(AUDIO_ATTRIBUTES_USAGE_KEY, AudioUsage.fromNativeValue(attributes.getUsage()).getEnumValue());
+    result.putInt(AUDIO_ATTRIBUTES_CONTENT_TYPE_KEY, AudioContentType.fromNativeValue(attributes.getContentType()).getEnumValue());
+
+    Bundle flags = new Bundle();
+    flags.putBoolean(AUDIO_ATTRIBUTES_FLAGS_HW_AV_SYNC_KEY, (attributes.getFlags() & AudioAttributes.FLAG_HW_AV_SYNC) > 0);
+    flags.putBoolean(AUDIO_ATTRIBUTES_FLAGS_ENFORCE_AUDIBILITY_KEY, (attributes.getFlags() & AudioAttributes.FLAG_AUDIBILITY_ENFORCED) > 0);
+    result.putBundle(AUDIO_ATTRIBUTES_FLAGS_KEY, flags);
+
+    return result;
+  }
+
+  @Nullable
+  private double[] toArray(@Nullable long[] array) {
+    if (array == null) {
+      return null;
+    }
+
+    double[] result = new double[array.length];
+    for (int i = 0; i < array.length; i++) {
+      result[i] = array[i];
+    }
+    return result;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/serializers/NotificationsChannelGroupSerializer.java

@@ -0,0 +1,20 @@
+package expo.modules.notifications.notifications.channels.serializers;
+
+import android.app.NotificationChannelGroup;
+import android.os.Build;
+import android.os.Bundle;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+public interface NotificationsChannelGroupSerializer {
+  String ID_KEY = "id";
+  String NAME_KEY = "name";
+  String DESCRIPTION_KEY = "description";
+  String IS_BLOCKED_KEY = "isBlocked";
+  String CHANNELS_KEY = "channels";
+
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  Bundle toBundle(@Nullable NotificationChannelGroup group);
+}

package/android/src/main/java/expo/modules/notifications/notifications/channels/serializers/NotificationsChannelSerializer.java

@@ -0,0 +1,35 @@
+package expo.modules.notifications.notifications.channels.serializers;
+
+import android.app.NotificationChannel;
+import android.os.Build;
+import android.os.Bundle;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+public interface NotificationsChannelSerializer {
+  String ID_KEY = "id";
+  String NAME_KEY = "name";
+  String IMPORTANCE_KEY = "importance";
+  String BYPASS_DND_KEY = "bypassDnd";
+  String DESCRIPTION_KEY = "description";
+  String GROUP_ID_KEY = "groupId";
+  String LIGHT_COLOR_KEY = "lightColor";
+  String LOCKSCREEN_VISIBILITY_KEY = "lockscreenVisibility";
+  String SHOW_BADGE_KEY = "showBadge";
+  String SOUND_KEY = "sound";
+  String SOUND_AUDIO_ATTRIBUTES_KEY = "audioAttributes";
+  String VIBRATION_PATTERN_KEY = "vibrationPattern";
+  String ENABLE_LIGHTS_KEY = "enableLights";
+  String ENABLE_VIBRATE_KEY = "enableVibrate";
+
+  String AUDIO_ATTRIBUTES_USAGE_KEY = "usage";
+  String AUDIO_ATTRIBUTES_CONTENT_TYPE_KEY = "contentType";
+  String AUDIO_ATTRIBUTES_FLAGS_KEY = "flags";
+  String AUDIO_ATTRIBUTES_FLAGS_ENFORCE_AUDIBILITY_KEY = "enforceAudibility";
+  String AUDIO_ATTRIBUTES_FLAGS_HW_AV_SYNC_KEY = "requestHardwareAudioVideoSynchronization";
+
+  @Nullable
+  @RequiresApi(api = Build.VERSION_CODES.O)
+  Bundle toBundle(@Nullable NotificationChannel channel);
+}

package/android/src/main/java/expo/modules/notifications/notifications/emitting/NotificationsEmitter.kt

@@ -0,0 +1,78 @@
+package expo.modules.notifications.notifications.emitting
+
+import android.os.Bundle
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.notifications.ModuleNotFoundException
+import expo.modules.notifications.notifications.NotificationSerializer
+import expo.modules.notifications.notifications.interfaces.NotificationListener
+import expo.modules.notifications.notifications.interfaces.NotificationManager
+import expo.modules.notifications.notifications.model.Notification
+import expo.modules.notifications.notifications.model.NotificationResponse
+
+private const val NEW_MESSAGE_EVENT_NAME = "onDidReceiveNotification"
+private const val NEW_RESPONSE_EVENT_NAME = "onDidReceiveNotificationResponse"
+private const val MESSAGES_DELETED_EVENT_NAME = "onNotificationsDeleted"
+
+open class NotificationsEmitter : Module(), NotificationListener {
+  private lateinit var notificationManager: NotificationManager
+  private var lastNotificationResponse: NotificationResponse? = null
+  private var eventEmitter: EventEmitter? = null
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoNotificationsEmitter")
+
+    OnCreate {
+      eventEmitter = appContext.legacyModule<EventEmitter>()
+        ?: throw ModuleNotFoundException(EventEmitter::class)
+
+      // Register the module as a listener in NotificationManager singleton module.
+      // Deregistration happens in onDestroy callback.
+      notificationManager = requireNotNull(appContext.legacyModuleRegistry.getSingletonModule("NotificationManager", NotificationManager::class.java))
+      notificationManager.addListener(this@NotificationsEmitter)
+    }
+
+    OnDestroy {
+      notificationManager.removeListener(this@NotificationsEmitter)
+    }
+
+    AsyncFunction("getLastNotificationResponseAsync") {
+      lastNotificationResponse?.let(NotificationSerializer::toBundle)
+    }
+  }
+
+  /**
+   * Callback called when [NotificationManager] gets notified of a new notification.
+   * Emits a [NEW_MESSAGE_EVENT_NAME] event.
+   *
+   * @param notification Notification received
+   */
+  override fun onNotificationReceived(notification: Notification) {
+    eventEmitter?.emit(NEW_MESSAGE_EVENT_NAME, NotificationSerializer.toBundle(notification))
+  }
+
+  /**
+   * Callback called when [NotificationManager] gets notified of a new notification response.
+   * Emits a [NEW_RESPONSE_EVENT_NAME] event.
+   *
+   * @param response Notification response received
+   * @return Whether notification has been handled
+   */
+  override fun onNotificationResponseReceived(response: NotificationResponse): Boolean {
+    lastNotificationResponse = response
+    eventEmitter?.let {
+      it.emit(NEW_RESPONSE_EVENT_NAME, NotificationSerializer.toBundle(response))
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Callback called when [NotificationManager] gets informed of the fact of message dropping.
+   * Emits a [MESSAGES_DELETED_EVENT_NAME] event.
+   */
+  override fun onNotificationsDropped() {
+    eventEmitter?.emit(MESSAGES_DELETED_EVENT_NAME, Bundle.EMPTY)
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/enums/AudioContentType.java

@@ -0,0 +1,45 @@
+package expo.modules.notifications.notifications.enums;
+
+import android.media.AudioAttributes;
+
+public enum AudioContentType {
+  UNKNOWN(AudioAttributes.CONTENT_TYPE_UNKNOWN, 0),
+  SPEECH(AudioAttributes.CONTENT_TYPE_SPEECH, 1),
+  MUSIC(AudioAttributes.CONTENT_TYPE_MUSIC, 2),
+  MOVIE(AudioAttributes.CONTENT_TYPE_MOVIE, 3),
+  SONIFICIATION(AudioAttributes.CONTENT_TYPE_SONIFICATION, 4);
+
+  private final int mNativeVisibility;
+  private final int mEnumValue;
+
+  AudioContentType(int nativeVisibility, int enumValue) {
+    mNativeVisibility = nativeVisibility;
+    mEnumValue = enumValue;
+  }
+
+  public int getNativeValue() {
+    return mNativeVisibility;
+  }
+
+  public int getEnumValue() {
+    return mEnumValue;
+  }
+
+  public static AudioContentType fromEnumValue(int value) {
+    for (AudioContentType visibility : AudioContentType.values()) {
+      if (visibility.getEnumValue() == value) {
+        return visibility;
+      }
+    }
+    return AudioContentType.UNKNOWN;
+  }
+
+  public static AudioContentType fromNativeValue(int value) {
+    for (AudioContentType visibility : AudioContentType.values()) {
+      if (visibility.getEnumValue() == value) {
+        return visibility;
+      }
+    }
+    return AudioContentType.UNKNOWN;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/enums/AudioUsage.java

@@ -0,0 +1,55 @@
+package expo.modules.notifications.notifications.enums;
+
+import android.media.AudioAttributes;
+
+public enum AudioUsage {
+  UNKNOWN(AudioAttributes.USAGE_UNKNOWN, 0),
+  MEDIA(AudioAttributes.USAGE_MEDIA, 1),
+  VOICE_COMMUNICATION(AudioAttributes.USAGE_VOICE_COMMUNICATION, 2),
+  VOICE_COMMUNICATION_SIGNALLING(AudioAttributes.USAGE_VOICE_COMMUNICATION_SIGNALLING, 3),
+  ALARM(AudioAttributes.USAGE_ALARM, 4),
+  NOTIFICATION(AudioAttributes.USAGE_NOTIFICATION, 5),
+  NOTIFICATION_RINGTONE(AudioAttributes.USAGE_NOTIFICATION_RINGTONE, 6),
+  NOTIFICATION_COMMUNICATION_REQUEST(AudioAttributes.USAGE_NOTIFICATION_COMMUNICATION_REQUEST, 7),
+  NOTIFICATION_COMMUNICATION_INSTANT(AudioAttributes.USAGE_NOTIFICATION_COMMUNICATION_INSTANT, 8),
+  NOTIFICATION_COMMUNICATION_DELAYED(AudioAttributes.USAGE_NOTIFICATION_COMMUNICATION_DELAYED, 9),
+  NOTIFICATION_EVENT(AudioAttributes.USAGE_NOTIFICATION_EVENT, 10),
+  ASSISTANCE_ACCESSIBILITY(AudioAttributes.USAGE_ASSISTANCE_ACCESSIBILITY, 11),
+  ASSISTANCE_NAVIGATION_GUIDANCE(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE, 12),
+  ASSISTANCE_SONIFICATION(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION, 13),
+  GAME(AudioAttributes.USAGE_GAME, 14);
+
+  private final int mNativeVisibility;
+  private final int mEnumValue;
+
+  AudioUsage(int nativeVisibility, int enumValue) {
+    mNativeVisibility = nativeVisibility;
+    mEnumValue = enumValue;
+  }
+
+  public int getNativeValue() {
+    return mNativeVisibility;
+  }
+
+  public int getEnumValue() {
+    return mEnumValue;
+  }
+
+  public static AudioUsage fromEnumValue(int value) {
+    for (AudioUsage usage : AudioUsage.values()) {
+      if (usage.getEnumValue() == value) {
+        return usage;
+      }
+    }
+    return AudioUsage.UNKNOWN;
+  }
+
+  public static AudioUsage fromNativeValue(int value) {
+    for (AudioUsage usage : AudioUsage.values()) {
+      if (usage.getEnumValue() == value) {
+        return usage;
+      }
+    }
+    return AudioUsage.UNKNOWN;
+  }
+}