react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.11

package/common/cpp/test/src/biquad/BiquadFilterChromium.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <numbers>
+#include <span>
+
+namespace audioapi {
+
+constexpr double kPiDouble = std::numbers::pi_v<double>;
+
+struct BiquadCoefficients {
+  double b0;
+  double b1;
+  double b2;
+  double a1;
+  double a2;
+};
+
+void getFrequencyResponse(
+    const BiquadCoefficients &coeffs,
+    std::span<const float> frequency,
+    std::span<float> mag_response,
+    std::span<float> phase_response,
+    float nyquistFrequency);
+
+BiquadCoefficients
+normalizeCoefficients(double b0, double b1, double b2, double a0, double a1, double a2);
+
+BiquadCoefficients calculateLowpassCoefficients(double cutoff, double Q);
+BiquadCoefficients calculateHighpassCoefficients(double cutoff, double Q);
+BiquadCoefficients calculateBandpassCoefficients(double frequency, double Q);
+BiquadCoefficients calculateNotchCoefficients(double frequency, double Q);
+BiquadCoefficients calculateAllpassCoefficients(double frequency, double Q);
+BiquadCoefficients calculatePeakingCoefficients(double frequency, double Q, double db_gain);
+BiquadCoefficients calculateLowshelfCoefficients(double frequency, double db_gain);
+BiquadCoefficients calculateHighshelfCoefficients(double frequency, double db_gain);
+
+} // namespace audioapi

package/common/cpp/test/src/biquad/BiquadFilterTest.cpp

@@ -0,0 +1,272 @@
+#include <test/src/biquad/BiquadFilterChromium.h>
+#include <test/src/biquad/BiquadFilterTest.h>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+void BiquadFilterTest::expectCoefficientsNear(
+    const std::shared_ptr<BiquadFilterNode> &biquadNode,
+    const BiquadCoefficients &expected) {
+  EXPECT_NEAR(biquadNode->b0_, expected.b0, tolerance);
+  EXPECT_NEAR(biquadNode->b1_, expected.b1, tolerance);
+  EXPECT_NEAR(biquadNode->b2_, expected.b2, tolerance);
+  EXPECT_NEAR(biquadNode->a1_, expected.a1, tolerance);
+  EXPECT_NEAR(biquadNode->a2_, expected.a2, tolerance);
+}
+
+void BiquadFilterTest::testLowpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(node, calculateLowpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testHighpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(node, calculateHighpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testBandpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setBandpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(node, calculateBandpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testNotch(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setNotchCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(node, calculateNotchCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testAllpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setAllpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(node, calculateAllpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testPeaking(float frequency, float Q, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setPeakingCoefficients(normalizedFrequency, Q, gain);
+  expectCoefficientsNear(node, calculatePeakingCoefficients(normalizedFrequency, Q, gain));
+}
+
+void BiquadFilterTest::testLowshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(node, calculateLowshelfCoefficients(normalizedFrequency, gain));
+}
+
+void BiquadFilterTest::testHighshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(node, calculateHighshelfCoefficients(normalizedFrequency, gain));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    Frequencies,
+    BiquadFilterFrequencyTest,
+    ::testing::Values(
+        0.0f,                       // 0 Hz - the filter should block all input signal
+        10.0f,                      // very low frequency
+        350.0f,                     // default
+        nyquistFrequency - 0.0001f, // frequency near Nyquist
+        nyquistFrequency));         // maximal frequency
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestLowpassHighpass,
+    ::testing::Values(
+        -770.63678f,  // min value for lowpass and highpass
+        0.0f,         // default
+        770.63678f)); // max value for lowpass and highpass
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestRestTypes, // bandpass, notch, allpass, peaking
+    ::testing::Values(
+        0.0f, // default and min value
+        MOST_POSITIVE_SINGLE_FLOAT));
+
+INSTANTIATE_TEST_SUITE_P(
+    GainEdgeCases,
+    BiquadFilterGainTest,
+    ::testing::Values(
+        -40.0f,
+        0.0f, // default
+        40.0f));
+
+TEST_P(BiquadFilterFrequencyTest, SetLowpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetBandpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetNotchCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetAllpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetPeakingCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetLowshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testHighshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetLowpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetHighpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetBandpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetNotchCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetAllpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float gain = GetParam();
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetLowshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetHighshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testHighshelf(frequency, gain);
+}
+
+TEST_F(BiquadFilterTest, GetFrequencyResponse) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  auto coeffs = calculateLowpassCoefficients(normalizedFrequency, Q);
+
+  std::vector<float> TestFrequencies = {
+      -0.0001f,
+      0.0f,
+      0.0001f,
+      0.25f * nyquistFrequency,
+      0.5f * nyquistFrequency,
+      0.75f * nyquistFrequency,
+      nyquistFrequency - 0.0001f,
+      nyquistFrequency,
+      nyquistFrequency + 0.0001f};
+
+  std::vector<float> magResponseNode(TestFrequencies.size());
+  std::vector<float> phaseResponseNode(TestFrequencies.size());
+  std::vector<float> magResponseExpected(TestFrequencies.size());
+  std::vector<float> phaseResponseExpected(TestFrequencies.size());
+
+  node->getFrequencyResponse(
+      TestFrequencies.data(),
+      magResponseNode.data(),
+      phaseResponseNode.data(),
+      TestFrequencies.size());
+  getFrequencyResponse(
+      coeffs, TestFrequencies, magResponseExpected, phaseResponseExpected, nyquistFrequency);
+
+  for (size_t i = 0; i < TestFrequencies.size(); ++i) {
+    float f = TestFrequencies[i];
+    if (std::isnan(magResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(magResponseNode[i])) << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(magResponseNode[i], magResponseExpected[i], tolerance)
+          << "Magnitude mismatch at " << f << " Hz";
+    }
+
+    if (std::isnan(phaseResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(phaseResponseNode[i])) << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(phaseResponseNode[i], phaseResponseExpected[i], tolerance)
+          << "Phase mismatch at " << f << " Hz";
+    }
+  }
+}
+
+} // namespace audioapi

package/common/cpp/test/src/biquad/BiquadFilterTest.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+static constexpr int sampleRate = 44100;
+static constexpr float nyquistFrequency = sampleRate / 2.0f;
+static constexpr float tolerance = 0.0001f;
+
+namespace audioapi {
+class BiquadFilterTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+
+  void expectCoefficientsNear(
+      const std::shared_ptr<BiquadFilterNode> &node,
+      const BiquadCoefficients &expected);
+  void testLowpass(float frequency, float Q);
+  void testHighpass(float frequency, float Q);
+  void testBandpass(float frequency, float Q);
+  void testNotch(float frequency, float Q);
+  void testAllpass(float frequency, float Q);
+  void testPeaking(float frequency, float Q, float gain);
+  void testLowshelf(float frequency, float gain);
+  void testHighshelf(float frequency, float gain);
+};
+
+class BiquadFilterQTestLowpassHighpass : public BiquadFilterTest,
+                                         public ::testing::WithParamInterface<float> {};
+class BiquadFilterQTestRestTypes : public BiquadFilterTest,
+                                   public ::testing::WithParamInterface<float> {};
+class BiquadFilterFrequencyTest : public BiquadFilterTest,
+                                  public ::testing::WithParamInterface<float> {};
+class BiquadFilterGainTest : public BiquadFilterTest,
+                             public ::testing::WithParamInterface<float> {};
+} // namespace audioapi

package/ios/audioapi/ios/AudioAPIModule.h

@@ -1,5 +1,6 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTCallInvokerModule.h>
+#import <React/RCTInvalidating.h>
 #import <rnaudioapi/rnaudioapi.h>
 #else // RCT_NEW_ARCH_ENABLED
 #import <React/RCTBridgeModule.h>
@@ -10,11 +11,11 @@
 @class AudioEngine;
 @class NotificationManager;
 @class AudioSessionManager;
-@class LockScreenManager;
+@class NotificationRegistry;
 
 @interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
-                            <NativeAudioAPIModuleSpec, RCTCallInvokerModule>
+                            <NativeAudioAPIModuleSpec, RCTCallInvokerModule, RCTInvalidating>
 #else
                             <RCTBridgeModule>
 #endif // RCT_NEW_ARCH_ENABLED
@@ -22,7 +23,7 @@
 @property (nonatomic, strong) AudioEngine *audioEngine;
 @property (nonatomic, strong) NotificationManager *notificationManager;
 @property (nonatomic, strong) AudioSessionManager *audioSessionManager;
-@property (nonatomic, strong) LockScreenManager *lockScreenManager;
+@property (nonatomic, strong) NotificationRegistry *notificationRegistry;
 
 - (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody;
 

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -11,8 +11,8 @@
 #import <audioapi/AudioAPIModuleInstaller.h>
 #import <audioapi/ios/system/AudioEngine.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
-#import <audioapi/ios/system/LockScreenManager.h>
 #import <audioapi/ios/system/NotificationManager.h>
+#import <audioapi/ios/system/notification/NotificationRegistry.h>
 
 #import <audioapi/events/AudioEventHandlerRegistry.h>
 
@@ -26,7 +26,7 @@ using namespace worklets;
 
 #if defined(RCT_NEW_ARCH_ENABLED)
 // nothing
-#else // defined(RCT_NEW_ARCH_ENABLED)
+#else  // defined(RCT_NEW_ARCH_ENABLED)
 @interface RCTBridge (RCTTurboModule)
 - (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
 - (void)_tryAndHandleError:(dispatch_block_t)block;
@@ -50,25 +50,30 @@ RCT_EXPORT_MODULE(AudioAPIModule);
   [self.audioEngine cleanup];
   [self.notificationManager cleanup];
   [self.audioSessionManager cleanup];
-  [self.lockScreenManager cleanup];
+  [self.notificationRegistry cleanup];
 
   _eventHandler = nullptr;
 
   [super invalidate];
 }
 
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_queue_create("com.swmansion.audioapi.MainModuleQueue", DISPATCH_QUEUE_SERIAL);
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
   self.audioSessionManager = [[AudioSessionManager alloc] init];
-  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
-  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
+  self.audioEngine = [[AudioEngine alloc] init];
   self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+  self.notificationRegistry = [[NotificationRegistry alloc] initWithAudioAPIModule:self];
 
   auto jsiRuntime = reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
 
 #if defined(RCT_NEW_ARCH_ENABLED)
   auto jsCallInvoker = _callInvoker.callInvoker;
-#else // defined(RCT_NEW_ARCH_ENABLED)
+#else  // defined(RCT_NEW_ARCH_ENABLED)
   auto jsCallInvoker = self.bridge.jsCallInvoker;
 #endif // defined(RCT_NEW_ARCH_ENABLED)
 
@@ -98,7 +103,8 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   }
 
   // Get the actual JSI Runtime reference
-  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler, uiWorkletRuntime);
+  audioapi::AudioAPIModuleInstaller::injectJSIBindings(
+      jsiRuntime, jsCallInvoker, _eventHandler, uiWorkletRuntime);
 #else
   audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler);
 #endif
@@ -113,71 +119,179 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
 }
 
 RCT_EXPORT_METHOD(
-    setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
-        reject)
+    setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
 {
-  if ([self.audioSessionManager setActive:enabled]) {
-    resolve(@"true");
-    return;
-  }
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    auto success = [self.audioSessionManager setActive:enabled];
 
-  resolve(@"false");
+    resolve(@(success));
+  });
 }
 
 RCT_EXPORT_METHOD(
     setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
         options allowHaptics : (BOOL)allowHaptics)
 {
-  [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options allowHaptics:allowHaptics];
+  if (!self.audioSessionManager.shouldManageSession) {
+    [self.audioSessionManager setShouldManageSession:true];
+  }
+  [self.audioSessionManager setAudioSessionOptions:category
+                                              mode:mode
+                                           options:options
+                                      allowHaptics:allowHaptics];
 }
 
-RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
+RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
 {
-  [self.lockScreenManager setLockScreenInfo:info];
+  [self.notificationManager observeAudioInterruptions:enabled];
 }
 
-RCT_EXPORT_METHOD(resetLockScreenInfo)
+RCT_EXPORT_METHOD(activelyReclaimSession : (BOOL)enabled)
 {
-  [self.lockScreenManager resetLockScreenInfo];
+  [self.notificationManager activelyReclaimSession:enabled];
 }
 
-RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
+RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
 {
-  [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
+  [self.notificationManager observeVolumeChanges:(BOOL)enabled];
 }
 
-RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
+RCT_EXPORT_METHOD(
+    requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  [self.notificationManager observeAudioInterruptions:enabled];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager requestRecordingPermissions:resolve reject:reject];
+  });
 }
 
-RCT_EXPORT_METHOD(activelyReclaimSession : (BOOL)enabled)
+RCT_EXPORT_METHOD(
+    checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  [self.notificationManager activelyReclaimSession:enabled];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager checkRecordingPermissions:resolve reject:reject];
+  });
 }
 
-RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
+RCT_EXPORT_METHOD(
+    requestNotificationPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  [self.notificationManager observeVolumeChanges:(BOOL)enabled];
+  // iOS doesn't require explicit notification permissions for media controls
+  // MPNowPlayingInfoCenter and MPRemoteCommandCenter work without permissions
+  // Return 'granted' to match the spec interface
+  resolve(@"granted");
 }
 
 RCT_EXPORT_METHOD(
-    requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)
-        reject)
+    checkNotificationPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  // iOS doesn't require explicit notification permissions for media controls
+  // Return 'granted' to match the spec interface
+  resolve(@"granted");
+}
+
+RCT_EXPORT_METHOD(
+    getDevicesInfo : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  });
+}
+
+RCT_EXPORT_METHOD(disableSessionManagement)
 {
-  [self.audioSessionManager requestRecordingPermissions:resolve reject:reject];
+  [self.audioSessionManager disableSessionManagement];
 }
 
+// New notification system methods
 RCT_EXPORT_METHOD(
-    checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+    registerNotification : (NSString *)type key : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
 {
-  [self.audioSessionManager checkRecordingPermissions:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry registerNotificationType:type withKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to register notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    showNotification : (NSString *)key options : (NSDictionary *)
+        options resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry showNotificationWithKey:key options:options];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to show notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    updateNotification : (NSString *)key options : (NSDictionary *)
+        options resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry updateNotificationWithKey:key options:options];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to update notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    hideNotification : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry hideNotificationWithKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to hide notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    unregisterNotification : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry unregisterNotificationWithKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to unregister notification"});
+    }
+  });
 }
 
 RCT_EXPORT_METHOD(
-    getDevicesInfo : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+    isNotificationActive : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
 {
-  [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL isActive = [self.notificationRegistry isNotificationActiveWithKey:key];
+    resolve(@(isActive));
+  });
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED