react-native-audio-api 0.10.0-nightly-c815c40-20251026 → 0.10.0-nightly-d3a7f65-20251028

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

@@ -53,8 +53,6 @@ class AudioAPIModule(
       if (BuildConfig.RN_AUDIO_API_ENABLE_WORKLETS) {
         try {
           workletsModule = reactContext.getNativeModule("WorkletsModule")
-          reanimatedModule = reactContext.getNativeModule("ReanimatedModule")
-          reanimatedModule
         } catch (ex: Exception) {
           throw RuntimeException("WorkletsModule not found - make sure react-native-worklets is properly installed")
         }
@@ -77,11 +75,11 @@ class AudioAPIModule(
   }
 
   override fun onHostPause() {
-    closeAllContexts()
+    // do nothing
   }
 
   override fun onHostDestroy() {
-    // do nothing
+    closeAllContexts()
   }
 
   override fun initialize() {
@@ -89,6 +87,8 @@ class AudioAPIModule(
   }
 
   override fun invalidate() {
+    closeAllContexts()
+    reactContext.get()?.removeLifecycleEventListener(this)
     // think about cleaning up resources, singletons etc.
   }
 

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

@@ -42,13 +42,11 @@ class LockScreenManager(
   private var playbackState: Int = PlaybackStateCompat.STATE_PAUSED
 
   init {
-    this.pb.setActions(controls)
-
-    this.nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-    this.nb.setPriority(NotificationCompat.PRIORITY_HIGH)
+    pb.setActions(controls)
+    nb.setPriority(NotificationCompat.PRIORITY_HIGH)
+    nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
 
     updateNotificationMediaStyle()
-
     mediaNotificationManager.get()?.updateActions(controls)
   }
 
@@ -174,8 +172,31 @@ class LockScreenManager(
     if (artworkThread != null && artworkThread!!.isAlive) artworkThread!!.interrupt()
     artworkThread = null
 
-    mediaNotificationManager.get()?.cancelNotification()
+    title = null
+    artist = null
+    album = null
+    description = null
+    duration = 0L
+    speed = 1.0F
+    elapsedTime = 0L
+    artwork = null
+    playbackState = PlaybackStateCompat.STATE_PAUSED
+    isPlaying = false
+
+    val emptyMetadata = MediaMetadataCompat.Builder().build()
+    mediaSession.get()?.setMetadata(emptyMetadata)
+
+    pb.setState(PlaybackStateCompat.STATE_NONE, 0, 0f)
+    pb.setActions(controls)
+    state = pb.build()
+    mediaSession.get()?.setPlaybackState(state)
     mediaSession.get()?.setActive(false)
+
+    nb.setContentTitle("")
+    nb.setContentText("")
+    nb.setContentInfo("")
+
+    mediaNotificationManager.get()?.updateNotification(nb, isPlaying)
   }
 
   fun enableRemoteCommand(

package/common/cpp/audioapi/utils/ThreadPool.hpp

@@ -20,6 +20,11 @@ class ThreadPool {
   struct TaskEvent { audioapi::move_only_function<void()> task; };
   using Event = std::variant<TaskEvent, StopEvent>;
 
+  struct Cntrl {
+    std::atomic<bool> waitingForTasks{false};
+    std::atomic<size_t> tasksScheduled{0};
+  };
+
   using Sender = channels::spsc::Sender<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
   using Receiver = channels::spsc::Receiver<Event, channels::spsc::OverflowStrategy::WAIT_ON_FULL, channels::spsc::WaitStrategy::ATOMIC_WAIT>;
 public:
@@ -38,8 +43,30 @@ public:
       workerSenders.emplace_back(std::move(workerSender));
     }
     loadBalancerThread = std::thread(&ThreadPool::loadBalancerThreadFunc, this, std::move(receiver), std::move(workerSenders));
+    controlBlock_ = std::make_unique<Cntrl>();
+  }
+  ThreadPool(const ThreadPool&) = delete;
+  ThreadPool& operator=(const ThreadPool&) = delete;
+  ThreadPool(ThreadPool&& other):
+    loadBalancerThread(std::move(other.loadBalancerThread)),
+    workers(std::move(other.workers)),
+    loadBalancerSender(std::move(other.loadBalancerSender)),
+    controlBlock_(std::move(other.controlBlock_)) {}
+  ThreadPool& operator=(ThreadPool&& other) {
+    if (this != &other) {
+      loadBalancerThread = std::move(other.loadBalancerThread);
+      workers = std::move(other.workers);
+      loadBalancerSender = std::move(other.loadBalancerSender);
+      controlBlock_ = std::move(other.controlBlock_);
+      other.movedFrom_ = true;
+    }
+    return *this;
   }
+
   ~ThreadPool() {
+    if (movedFrom_) {
+      return;
+    }
     loadBalancerSender.send(StopEvent{});
     loadBalancerThread.join();
     for (auto& worker : workers) {
@@ -59,16 +86,47 @@ public:
   /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only.
   template<typename Func, typename ... Args, typename = std::enable_if_t<std::is_invocable_r_v<void, Func, Args...>>>
   void schedule(Func &&task, Args &&... args) noexcept {
-    auto boundTask = [f = std::forward<Func>(task), ...capturedArgs = std::forward<Args>(args)]() mutable {
+    controlBlock_->tasksScheduled.fetch_add(1, std::memory_order_release);
+
+    /// We know that lifetime of each worker thus spsc thus lambda is strongly bounded by ThreadPool lifetime
+    /// so we can safely capture control block pointer unsafely here
+    Cntrl *cntrl = controlBlock_.get();
+    auto boundTask = [cntrl, f= std::forward<Func>(task), ...capturedArgs = std::forward<Args>(args)]() mutable {
       f(std::forward<Args>(capturedArgs)...);
+      size_t left = cntrl->tasksScheduled.fetch_sub(1, std::memory_order_acq_rel) - 1;
+      if (left == 0) {
+        cntrl->waitingForTasks.store(false, std::memory_order_release);
+        cntrl->waitingForTasks.notify_one();
+      }
     };
     loadBalancerSender.send(TaskEvent{audioapi::move_only_function<void()>(std::move(boundTask))});
   }
 
+  /// @brief Waits for all scheduled tasks to complete
+  void wait() {
+    /// This logic might seem incorrect at first glance
+    /// Main principle for this is that there is only one thread scheduling tasks
+    /// If he is waiting for the tasks he CANNOT schedule new tasks so we can assume partial
+    /// synchronization here.
+    /// We first store true so if any task finishes at this moment he will flip it
+    /// Then we check if there are any tasks scheduled
+    /// If there are none we can return immediately
+    /// If there are some we wait until the last task flips the flag to false
+    controlBlock_->waitingForTasks.store(true, std::memory_order_release);
+    if (controlBlock_->tasksScheduled.load(std::memory_order_acquire) == 0) {
+      controlBlock_->waitingForTasks.store(false, std::memory_order_release);
+      return;
+    }
+    controlBlock_->waitingForTasks.wait(true, std::memory_order_acquire);
+    return;
+  }
+
 private:
   std::thread loadBalancerThread;
   std::vector<std::thread> workers;
   Sender loadBalancerSender;
+  std::unique_ptr<Cntrl> controlBlock_;
+  bool movedFrom_ = false;
 
   void workerThreadFunc(Receiver &&receiver) {
     Receiver localReceiver = std::move(receiver);

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -18,8 +18,7 @@ class IOSAudioRecorder : public AudioRecorder {
   IOSAudioRecorder(
       float sampleRate,
       int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry>
-          &audioEventHandlerRegistry);
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
 
   ~IOSAudioRecorder() override;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.10.0-nightly-c815c40-20251026",
+  "version": "0.10.0-nightly-d3a7f65-20251028",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"