react-native-audio-api 0.6.0-rc.4 → 0.6.0

package/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp

@@ -10,7 +10,10 @@ AudioAPIModule::AudioAPIModule(
     const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
     : javaPart_(make_global(jThis)),
       jsiRuntime_(jsiRuntime),
-      jsCallInvoker_(jsCallInvoker) {}
+      jsCallInvoker_(jsCallInvoker) {
+  audioEventHandlerRegistry_ =
+      std::make_shared<AudioEventHandlerRegistry>(jsiRuntime, jsCallInvoker);
+}
 
 jni::local_ref<AudioAPIModule::jhybriddata> AudioAPIModule::initHybrid(
     jni::alias_ref<jhybridobject> jThis,
@@ -26,10 +29,40 @@ void AudioAPIModule::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", AudioAPIModule::initHybrid),
       makeNativeMethod("injectJSIBindings", AudioAPIModule::injectJSIBindings),
+      makeNativeMethod(
+          "invokeHandlerWithEventNameAndEventBody",
+          AudioAPIModule::invokeHandlerWithEventNameAndEventBody),
   });
 }
 
 void AudioAPIModule::injectJSIBindings() {
-  AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime_, jsCallInvoker_);
+  AudioAPIModuleInstaller::injectJSIBindings(
+      jsiRuntime_, jsCallInvoker_, audioEventHandlerRegistry_);
+}
+
+void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(
+    jni::alias_ref<jni::JString> eventName,
+    jni::alias_ref<jni::JMap<jstring, jobject>> eventBody) {
+  std::unordered_map<std::string, EventValue> body = {};
+
+  for (const auto &entry : *eventBody) {
+    std::string name = entry.first->toStdString();
+    auto value = entry.second;
+
+    if (value->isInstanceOf(jni::JString::javaClassStatic())) {
+      body[name] = jni::static_ref_cast<jni::JString>(value)->toStdString();
+    } else if (value->isInstanceOf(jni::JInteger::javaClassStatic())) {
+      body[name] = jni::static_ref_cast<jni::JInteger>(value)->value();
+    } else if (value->isInstanceOf(jni::JDouble::javaClassStatic())) {
+      body[name] = jni::static_ref_cast<jni::JDouble>(value)->value();
+    } else if (value->isInstanceOf(jni::JFloat::javaClassStatic())) {
+      body[name] = jni::static_ref_cast<jni::JFloat>(value)->value();
+    } else if (value->isInstanceOf(jni::JBoolean::javaClassStatic())) {
+      body[name] = jni::static_ref_cast<jni::JBoolean>(value)->value();
+    }
+  }
+
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+      eventName->toStdString(), body);
 }
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/AudioAPIModule.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/AudioAPIModuleInstaller.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 
 #include <ReactCommon/CallInvokerHolder.h>
 #include <fbjni/fbjni.h>
@@ -8,6 +9,7 @@
 #include <react/jni/JMessageQueueThread.h>
 #include <memory>
 #include <utility>
+#include <unordered_map>
 
 namespace audioapi {
 
@@ -28,6 +30,7 @@ class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
   static void registerNatives();
 
   void injectJSIBindings();
+  void invokeHandlerWithEventNameAndEventBody(jni::alias_ref<jni::JString> eventName, jni::alias_ref<jni::JMap<jstring, jobject>> eventBody);
 
  private:
   friend HybridBase;
@@ -35,6 +38,7 @@ class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
   jni::global_ref<AudioAPIModule::javaobject> javaPart_;
   jsi::Runtime *jsiRuntime_;
   std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
   explicit AudioAPIModule(
       jni::alias_ref<AudioAPIModule::jhybridobject> &jThis,

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -1,23 +1,17 @@
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #include <audioapi/core/Constants.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
 
 namespace audioapi {
 
 AndroidAudioRecorder::AndroidAudioRecorder(
     float sampleRate,
     int bufferLength,
-    const std::function<void(void)> &onError,
-    const std::function<void(void)> &onStatusChange,
-    const std::function<void(std::shared_ptr<AudioBus>, int, double)>
-        &onAudioReady)
-    : AudioRecorder(
-          sampleRate,
-          bufferLength,
-          onError,
-          onStatusChange,
-          onAudioReady) {
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry) {
   AudioStreamBuilder builder;
   builder.setSharingMode(SharingMode::Exclusive)
       ->setDirection(Direction::Input)
@@ -28,7 +22,6 @@ AndroidAudioRecorder::AndroidAudioRecorder(
       ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
       ->setDataCallback(this)
       ->setSampleRate(static_cast<int>(sampleRate))
-      ->setFramesPerDataCallback(bufferLength)
       ->openStream(mStream_);
 }
 
@@ -43,29 +36,50 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
 }
 
 void AndroidAudioRecorder::start() {
+  if (isRunning_.load()) {
+    return;
+  }
+
   if (mStream_) {
     mStream_->requestStart();
   }
+
+  isRunning_.store(true);
 }
 
 void AndroidAudioRecorder::stop() {
+  if (!isRunning_.load()) {
+    return;
+  }
+
+  isRunning_.store(false);
+
   if (mStream_) {
     mStream_->requestStop();
   }
+
+  sendRemainingData();
 }
 
 DataCallbackResult AndroidAudioRecorder::onAudioReady(
     oboe::AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
-  auto buffer = static_cast<float *>(audioData);
+  if (isRunning_.load()) {
+    auto *inputChannel = static_cast<float *>(audioData);
+    circularBuffer_->push_back(inputChannel, numFrames);
+  }
 
-  auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-  memcpy(bus->getChannel(0)->getData(), buffer, numFrames * sizeof(float));
-  auto when = static_cast<double>(
-      oboeStream->getTimestamp(CLOCK_MONOTONIC).value().timestamp);
+  while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
+    auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
+    auto *outputChannel = bus->getChannel(0)->getData();
 
-  onAudioReady_(bus, numFrames, when);
+    circularBuffer_->pop_front(outputChannel, bufferLength_);
+    auto when = static_cast<double>(
+        oboeStream->getTimestamp(CLOCK_MONOTONIC).value().timestamp);
+
+    invokeOnAudioReadyCallback(bus, bufferLength_, when);
+  }
 
   return DataCallbackResult::Continue;
 }

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -16,9 +16,7 @@ class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorde
  public:
     AndroidAudioRecorder(float sampleRate,
                          int bufferLength,
-                         const std::function<void(void)> &onError,
-                         const std::function<void(void)> &onStatusChange,
-                         const std::function<void(std::shared_ptr<AudioBus>, int, double)> &onAudioReady);
+                         const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
 
     ~AndroidAudioRecorder() override;
 

package/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt

@@ -1,11 +1,15 @@
 package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.swmansion.audioapi.system.MediaSessionManager
+import java.lang.ref.WeakReference
 
 @OptIn(FrameworkAPI::class)
 @ReactModule(name = AudioAPIModule.NAME)
@@ -16,6 +20,8 @@ class AudioAPIModule(
     const val NAME = NativeAudioAPIModuleSpec.NAME
   }
 
+  val reactContext: WeakReference<ReactApplicationContext> = WeakReference(reactContext)
+
   private val mHybridData: HybridData
 
   external fun initHybrid(
@@ -25,6 +31,11 @@ class AudioAPIModule(
 
   private external fun injectJSIBindings()
 
+  external fun invokeHandlerWithEventNameAndEventBody(
+    eventName: String,
+    eventBody: Map<String, Any>,
+  )
+
   init {
     try {
       System.loadLibrary("react-native-audio-api")
@@ -35,10 +46,53 @@ class AudioAPIModule(
     }
   }
 
-  @ReactMethod(isBlockingSynchronousMethod = true)
   override fun install(): Boolean {
+    MediaSessionManager.initialize(WeakReference(this), reactContext)
     injectJSIBindings()
 
     return true
   }
+
+  override fun setLockScreenInfo(info: ReadableMap?) {
+    MediaSessionManager.setLockScreenInfo(info)
+  }
+
+  override fun resetLockScreenInfo() {
+    MediaSessionManager.resetLockScreenInfo()
+  }
+
+  override fun enableRemoteCommand(
+    name: String?,
+    enabled: Boolean,
+  ) {
+    MediaSessionManager.enableRemoteCommand(name!!, enabled)
+  }
+
+  override fun setAudioSessionOptions(
+    category: String?,
+    mode: String?,
+    options: ReadableArray?,
+  ) {
+    // noting to do here
+  }
+
+  override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
+
+  override fun observeAudioInterruptions(enabled: Boolean) {
+    MediaSessionManager.observeAudioInterruptions(enabled)
+  }
+
+  override fun observeVolumeChanges(enabled: Boolean) {
+    MediaSessionManager.observeVolumeChanges(enabled)
+  }
+
+  override fun requestRecordingPermissions(promise: Promise?) {
+    val res = MediaSessionManager.requestRecordingPermissions(currentActivity)
+    promise!!.resolve(res)
+  }
+
+  override fun checkRecordingPermissions(promise: Promise?) {
+    val res = MediaSessionManager.checkRecordingPermissions()
+    promise!!.resolve(res)
+  }
 }

package/android/src/main/java/com/swmansion/audioapi/AudioAPIPackage.kt

@@ -10,7 +10,6 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 @ReactModuleList(
   nativeModules = [
     AudioAPIModule::class,
-    AudioManagerModule::class,
   ],
 )
 class AudioAPIPackage : BaseReactPackage() {
@@ -20,7 +19,6 @@ class AudioAPIPackage : BaseReactPackage() {
   ): NativeModule? {
     when (name) {
       AudioAPIModule.NAME -> return AudioAPIModule(reactContext)
-      AudioManagerModule.NAME -> return AudioManagerModule(reactContext)
     }
     return null
   }
@@ -40,16 +38,6 @@ class AudioAPIPackage : BaseReactPackage() {
           isTurboModule = isTurboModule,
         )
 
-      moduleInfos[AudioManagerModule.NAME] =
-        ReactModuleInfo(
-          AudioManagerModule.NAME,
-          AudioManagerModule.NAME,
-          canOverrideExistingModule = true,
-          needsEagerInit = false,
-          hasConstants = true,
-          isCxxModule = false,
-          isTurboModule = false,
-        )
       moduleInfos
     }
 }

package/android/src/main/java/com/swmansion/audioapi/system/AudioFocusListener.kt

@@ -4,11 +4,14 @@ import android.media.AudioFocusRequest
 import android.media.AudioManager
 import android.os.Build
 import android.util.Log
+import com.swmansion.audioapi.AudioAPIModule
+import java.lang.ref.WeakReference
+import java.util.HashMap
 
 class AudioFocusListener(
-  private val audioManager: AudioManager,
-  val eventEmitter: MediaSessionEventEmitter,
-  private val lockScreenManager: LockScreenManager,
+  private val audioManager: WeakReference<AudioManager>,
+  private val audioAPIModule: WeakReference<AudioAPIModule>,
+  private val lockScreenManager: WeakReference<LockScreenManager>,
 ) : AudioManager.OnAudioFocusChangeListener {
   private var playOnAudioFocus = false
   private var focusRequest: AudioFocusRequest? = null
@@ -18,17 +21,37 @@ class AudioFocusListener(
     when (focusChange) {
       AudioManager.AUDIOFOCUS_LOSS -> {
         playOnAudioFocus = false
-        eventEmitter.onInterruption(mapOf("type" to "began", "shouldResume" to false))
+        val body =
+          HashMap<String, Any>().apply {
+            put("value", "began")
+            put("shouldResume", false)
+          }
+        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
       AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-        playOnAudioFocus = lockScreenManager.isPlaying
-        eventEmitter.onInterruption(mapOf("type" to "began", "shouldResume" to playOnAudioFocus))
+        playOnAudioFocus = lockScreenManager.get()?.isPlaying == true
+        val body =
+          HashMap<String, Any>().apply {
+            put("value", "began")
+            put("shouldResume", playOnAudioFocus)
+          }
+        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
       AudioManager.AUDIOFOCUS_GAIN -> {
         if (playOnAudioFocus) {
-          eventEmitter.onInterruption(mapOf("type" to "ended", "shouldResume" to true))
+          val body =
+            HashMap<String, Any>().apply {
+              put("value", "ended")
+              put("shouldResume", true)
+            }
+          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
         } else {
-          eventEmitter.onInterruption(mapOf("type" to "ended", "shouldResume" to false))
+          val body =
+            HashMap<String, Any>().apply {
+              put("value", "ended")
+              put("shouldResume", false)
+            }
+          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
         }
 
         playOnAudioFocus = false
@@ -44,17 +67,17 @@ class AudioFocusListener(
           .setOnAudioFocusChangeListener(this)
           .build()
 
-      audioManager.requestAudioFocus(focusRequest!!)
+      audioManager.get()?.requestAudioFocus(focusRequest!!)
     } else {
-      audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
+      audioManager.get()?.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
     }
   }
 
   fun abandonAudioFocus() {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && this.focusRequest != null) {
-      audioManager.abandonAudioFocusRequest(focusRequest!!)
+      audioManager.get()?.abandonAudioFocusRequest(focusRequest!!)
     } else {
-      audioManager.abandonAudioFocus(this)
+      audioManager.get()?.abandonAudioFocus(this)
     }
   }
 }

package/android/src/main/java/com/swmansion/audioapi/system/LockScreenManager.kt

@@ -14,20 +14,20 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType
 import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper.Companion.instance
 import java.io.IOException
+import java.lang.ref.WeakReference
 import java.net.URL
 
 class LockScreenManager(
-  private val reactContext: ReactApplicationContext,
-  private val mediaSession: MediaSessionCompat,
-  private val mediaNotificationManager: MediaNotificationManager,
-  val channelId: String,
+  private val reactContext: WeakReference<ReactApplicationContext>,
+  private val mediaSession: WeakReference<MediaSessionCompat>,
+  private val mediaNotificationManager: WeakReference<MediaNotificationManager>,
 ) {
   private var pb: PlaybackStateCompat.Builder = PlaybackStateCompat.Builder()
   private var state: PlaybackStateCompat = pb.build()
   private var controls: Long = 0
   var isPlaying: Boolean = false
 
-  private var nb: NotificationCompat.Builder = NotificationCompat.Builder(reactContext, channelId)
+  private var nb: NotificationCompat.Builder = NotificationCompat.Builder(reactContext.get()!!, MediaSessionManager.CHANNEL_ID)
 
   private var artworkThread: Thread? = null
 
@@ -49,7 +49,7 @@ class LockScreenManager(
 
     updateNotificationMediaStyle()
 
-    mediaNotificationManager.updateActions(controls)
+    mediaNotificationManager.get()?.updateActions(controls)
   }
 
   fun setLockScreenInfo(info: ReadableMap?) {
@@ -112,17 +112,17 @@ class LockScreenManager(
           try {
             val bitmap: Bitmap? = artwork?.let { loadArtwork(it, artworkLocal) }
 
-            val currentMetadata: MediaMetadataCompat = mediaSession.controller.metadata
+            val currentMetadata = mediaSession.get()?.controller?.metadata
             val newBuilder =
               MediaMetadataCompat.Builder(
                 currentMetadata,
               )
-            mediaSession.setMetadata(
+            mediaSession.get()?.setMetadata(
               newBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ART, bitmap).build(),
             )
 
             nb.setLargeIcon(bitmap)
-            mediaNotificationManager.show(nb, isPlaying)
+            mediaNotificationManager.get()?.show(nb, isPlaying)
 
             artworkThread = null
           } catch (ex: Exception) {
@@ -164,17 +164,17 @@ class LockScreenManager(
 
     updatePlaybackState(this.playbackState)
 
-    mediaSession.setMetadata(md.build())
-    mediaSession.setActive(true)
-    mediaNotificationManager.show(nb, isPlaying)
+    mediaSession.get()?.setMetadata(md.build())
+    mediaSession.get()?.setActive(true)
+    mediaNotificationManager.get()?.show(nb, isPlaying)
   }
 
   fun resetLockScreenInfo() {
     if (artworkThread != null && artworkThread!!.isAlive) artworkThread!!.interrupt()
     artworkThread = null
 
-    mediaNotificationManager.hide()
-    mediaSession.setActive(false)
+    mediaNotificationManager.get()?.hide()
+    mediaSession.get()?.setActive(false)
   }
 
   fun enableRemoteCommand(
@@ -183,14 +183,15 @@ class LockScreenManager(
   ) {
     var controlValue = 0L
     when (name) {
-      "play" -> controlValue = PlaybackStateCompat.ACTION_PLAY
-      "pause" -> controlValue = PlaybackStateCompat.ACTION_PAUSE
-      "stop" -> controlValue = PlaybackStateCompat.ACTION_STOP
-      "togglePlayPause" -> controlValue = PlaybackStateCompat.ACTION_PLAY_PAUSE
-      "nextTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_NEXT
-      "previousTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
-      "skipForward" -> controlValue = PlaybackStateCompat.ACTION_REWIND
-      "skipBackward" -> controlValue = PlaybackStateCompat.ACTION_REWIND
+      "remotePlay" -> controlValue = PlaybackStateCompat.ACTION_PLAY
+      "remotePause" -> controlValue = PlaybackStateCompat.ACTION_PAUSE
+      "remoteStop" -> controlValue = PlaybackStateCompat.ACTION_STOP
+      "remoteTogglePlayPause" -> controlValue = PlaybackStateCompat.ACTION_PLAY_PAUSE
+      "remoteNextTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_NEXT
+      "remotePreviousTrack" -> controlValue = PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
+      "remoteSkipForward" -> controlValue = PlaybackStateCompat.ACTION_FAST_FORWARD
+      "remoteSkipBackward" -> controlValue = PlaybackStateCompat.ACTION_REWIND
+      "remoteChangePlaybackPosition" -> controlValue = PlaybackStateCompat.ACTION_SEEK_TO
     }
 
     controls =
@@ -200,16 +201,16 @@ class LockScreenManager(
         controls and controlValue.inv()
       }
 
-    mediaNotificationManager.updateActions(controls)
+    mediaNotificationManager.get()?.updateActions(controls)
     pb.setActions(controls)
 
     state = pb.build()
-    mediaSession.setPlaybackState(state)
+    mediaSession.get()?.setPlaybackState(state)
 
     updateNotificationMediaStyle()
 
-    if (mediaSession.isActive) {
-      mediaNotificationManager.show(nb, isPlaying)
+    if (mediaSession.get()?.isActive == true) {
+      mediaNotificationManager.get()?.show(nb, isPlaying)
     }
   }
 
@@ -224,7 +225,7 @@ class LockScreenManager(
       if (local && !url.startsWith("http")) {
         // Gets the drawable from the RN's helper for local resources
         val helper = instance
-        val image = helper.getResourceDrawable(reactContext, url)
+        val image = helper.getResourceDrawable(reactContext.get()!!, url)
 
         bitmap =
           if (image is BitmapDrawable) {
@@ -255,14 +256,14 @@ class LockScreenManager(
     pb.setState(playbackState, elapsedTime, speed)
     pb.setActions(controls)
     state = pb.build()
-    mediaSession.setPlaybackState(state)
+    mediaSession.get()?.setPlaybackState(state)
   }
 
   private fun hasControl(control: Long): Boolean = (controls and control) == control
 
   private fun updateNotificationMediaStyle() {
     val style = MediaStyle()
-    style.setMediaSession(mediaSession.sessionToken)
+    style.setMediaSession(mediaSession.get()?.sessionToken)
     var controlCount = 0
     if (hasControl(PlaybackStateCompat.ACTION_PLAY) ||
       hasControl(PlaybackStateCompat.ACTION_PAUSE) ||

package/android/src/main/java/com/swmansion/audioapi/system/MediaNotificationManager.kt

@@ -21,9 +21,7 @@ import com.swmansion.audioapi.R
 import java.lang.ref.WeakReference
 
 class MediaNotificationManager(
-  val reactContext: ReactApplicationContext,
-  val notificationId: Int,
-  val channelId: String,
+  private val reactContext: WeakReference<ReactApplicationContext>,
 ) {
   private var smallIcon: Int = R.drawable.play
   private var customIcon: Int = 0
@@ -80,12 +78,12 @@ class MediaNotificationManager(
 
     builder.setSmallIcon(if (customIcon != 0) customIcon else smallIcon)
 
-    val packageName: String = reactContext.packageName
-    val openApp: Intent? = reactContext.packageManager.getLaunchIntentForPackage(packageName)
+    val packageName: String? = reactContext.get()?.packageName
+    val openApp: Intent? = reactContext.get()?.packageManager?.getLaunchIntentForPackage(packageName!!)
     try {
       builder.setContentIntent(
         PendingIntent.getActivity(
-          reactContext,
+          reactContext.get(),
           0,
           openApp,
           PendingIntent.FLAG_IMMUTABLE,
@@ -96,10 +94,10 @@ class MediaNotificationManager(
     }
 
     val remove = Intent(REMOVE_NOTIFICATION)
-    remove.putExtra(PACKAGE_NAME, reactContext.applicationInfo.packageName)
+    remove.putExtra(PACKAGE_NAME, reactContext.get()?.applicationInfo?.packageName)
     builder.setDeleteIntent(
       PendingIntent.getBroadcast(
-        reactContext,
+        reactContext.get(),
         0,
         remove,
         PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
@@ -115,8 +113,8 @@ class MediaNotificationManager(
     builder: NotificationCompat.Builder?,
     isPlaying: Boolean,
   ) {
-    NotificationManagerCompat.from(reactContext).notify(
-      notificationId,
+    NotificationManagerCompat.from(reactContext.get()!!).notify(
+      MediaSessionManager.NOTIFICATION_ID,
       prepareNotification(
         builder!!,
         isPlaying,
@@ -125,15 +123,15 @@ class MediaNotificationManager(
   }
 
   fun hide() {
-    NotificationManagerCompat.from(reactContext).cancel(notificationId)
+    NotificationManagerCompat.from(reactContext.get()!!).cancel(MediaSessionManager.NOTIFICATION_ID)
 
     try {
       val myIntent =
         Intent(
-          reactContext,
+          reactContext.get(),
           NotificationService::class.java,
         )
-      reactContext.stopService(myIntent)
+      reactContext.get()?.stopService(myIntent)
     } catch (e: java.lang.Exception) {
       Log.w("AudioManagerModule", "Error stopping service: ${e.message}")
     }
@@ -188,9 +186,9 @@ class MediaNotificationManager(
       return oldAction
     }
 
-    val r: Resources = reactContext.resources
-    val packageName: String = reactContext.packageName
-    val icon = r.getIdentifier(iconName, "drawable", packageName)
+    val r: Resources? = reactContext.get()?.resources
+    val packageName: String? = reactContext.get()?.packageName
+    val icon = r?.getIdentifier(iconName, "drawable", packageName)
 
     val keyCode = PlaybackStateCompat.toKeyCode(action)
     val intent = Intent(MEDIA_BUTTON)
@@ -198,13 +196,13 @@ class MediaNotificationManager(
     intent.putExtra(ContactsContract.Directory.PACKAGE_NAME, packageName)
     val i =
       PendingIntent.getBroadcast(
-        reactContext,
+        reactContext.get(),
         keyCode,
         intent,
         PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
       )
 
-    return NotificationCompat.Action(icon, title, i)
+    return NotificationCompat.Action(icon!!, title, i)
   }
 
   class NotificationService : Service() {
@@ -232,8 +230,8 @@ class MediaNotificationManager(
         ContextCompat.startForegroundService(this, intent)
         notification =
           MediaSessionManager.mediaNotificationManager
-            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.channelId), false)
-        startForeground(MediaSessionManager.notificationId, notification)
+            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.CHANNEL_ID), false)
+        startForeground(MediaSessionManager.NOTIFICATION_ID, notification)
       }
     }
 
@@ -242,8 +240,8 @@ class MediaNotificationManager(
       try {
         notification =
           MediaSessionManager.mediaNotificationManager
-            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.channelId), false)
-        startForeground(MediaSessionManager.notificationId, notification)
+            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.CHANNEL_ID), false)
+        startForeground(MediaSessionManager.NOTIFICATION_ID, notification)
       } catch (ex: Exception) {
         Log.w("AudioManagerModule", "Error starting service: ${ex.message}")
       }