react-native-audio-api 0.6.0-rc.0 → 0.6.0-rc.1

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -141,12 +141,16 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   nonSilentFramesToProcess = framesToProcess;
 }
 
+void AudioScheduledSourceNode::disable() {
+  AudioNode::disable();
+
+  if (onendedCallback_) {
+    onendedCallback_(getStopTime());
+  }
+}
+
 void AudioScheduledSourceNode::handleStopScheduled() {
   if (isStopScheduled()) {
-    if (onendedCallback_) {
-      onendedCallback_(getStopTime());
-    }
-
     playbackState_ = PlaybackState::FINISHED;
     disable();
   }

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -33,6 +33,7 @@ class AudioScheduledSourceNode : public AudioNode {
   void setOnendedCallback(const std::function<void(double)> &onendedCallback);
 
   virtual double getStopTime() const = 0;
+  void disable() override;
 
  protected:
   PlaybackState playbackState_;

package/common/cpp/audioapi/core/utils/AudioNodeDestructor.cpp

@@ -4,9 +4,9 @@
 
 namespace audioapi {
 
-AudioNodeDestructor::AudioNodeDestructor()
-    : thread_(std::thread(&AudioNodeDestructor::process, this)),
-      isExiting_(false) {}
+AudioNodeDestructor::AudioNodeDestructor() : isExiting_(false) {
+  thread_ = std::thread(&AudioNodeDestructor::process, this);
+}
 
 AudioNodeDestructor::~AudioNodeDestructor() {
   isExiting_ = true;

package/ios/audioapi/ios/AudioManagerModule.mm

@@ -14,7 +14,7 @@ RCT_EXPORT_MODULE(AudioManagerModule);
   if (self == [super init]) {
     self.audioEngine = [AudioEngine sharedInstance];
     self.audioSessionManager = [AudioSessionManager sharedInstance];
-    self.notificationManager = [NotificationManager sharedInstance];
+    self.notificationManager = [NotificationManager sharedInstanceWithAudioManagerModule:self];
     self.lockScreenManager = [LockScreenManager sharedInstanceWithAudioManagerModule:self];
   }
 
@@ -61,6 +61,11 @@ RCT_EXPORT_METHOD(setAudioSessionOptions : (NSString *)category mode : (NSString
   }
 }
 
+RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
+{
+  [self.notificationManager observeAudioInterruptions:enabled];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
 {
   return [self.audioSessionManager getDevicePreferredSampleRate];
@@ -80,13 +85,10 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
     @"onRemoteSkipBackward",
     @"onRemoteSeekForward",
     @"onRemoteSeekBackward",
-    @"onRemoteChangePlaybackPosition"
+    @"onRemoteChangePlaybackPosition",
+    @"onInterruption",
+    @"onRouteChange"
   ];
 }
 
-- (void)sendEventWithValue:(NSString *)event withValue:(NSString *)value
-{
-  [self sendEventWithName:@"AudioManagerModule" body:@{@"name" : event, @"value" : value}];
-}
-
 @end

package/ios/audioapi/ios/system/LockScreenManager.mm

@@ -6,10 +6,8 @@
   @{                                                              \
     @"album" : MPMediaItemPropertyAlbumTitle,                     \
     @"artist" : MPMediaItemPropertyArtist,                        \
-    @"genre" : MPMediaItemPropertyGenre,                          \
     @"duration" : MPMediaItemPropertyPlaybackDuration,            \
     @"title" : MPMediaItemPropertyTitle,                          \
-    @"isLiveStream" : MPNowPlayingInfoPropertyIsLiveStream,       \
     @"speed" : MPNowPlayingInfoPropertyPlaybackRate,              \
     @"elapsedTime" : MPNowPlayingInfoPropertyElapsedPlaybackTime, \
   }
@@ -76,8 +74,6 @@ static LockScreenManager *_sharedInstance = nil;
       self.playingInfoCenter.playbackState = MPNowPlayingPlaybackStatePlaying;
     } else if ([state isEqualToString:@"state_paused"]) {
       self.playingInfoCenter.playbackState = MPNowPlayingPlaybackStatePaused;
-    } else if ([state isEqualToString:@"state_stopped"]) {
-      self.playingInfoCenter.playbackState = MPNowPlayingPlaybackStateStopped;
     }
   }
 
@@ -247,7 +243,7 @@ static LockScreenManager *_sharedInstance = nil;
 - (MPRemoteCommandHandlerStatus)onChangePlaybackRate:(MPChangePlaybackRateCommandEvent *)event
 {
   [self.audioManagerModule sendEventWithName:@"onRemoteChangePlaybackRate"
-                                        body:@{@"playbackRate" : [NSNumber numberWithDouble:event.playbackRate]}];
+                                        body:@{@"value" : [NSNumber numberWithDouble:event.playbackRate]}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
@@ -278,21 +274,21 @@ static LockScreenManager *_sharedInstance = nil;
 - (MPRemoteCommandHandlerStatus)onSkipForward:(MPSkipIntervalCommandEvent *)event
 {
   [self.audioManagerModule sendEventWithName:@"onRemoteSkipForward"
-                                        body:@{@"interval" : [NSNumber numberWithDouble:event.interval]}];
+                                        body:@{@"value" : [NSNumber numberWithDouble:event.interval]}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSkipBackward:(MPSkipIntervalCommandEvent *)event
 {
   [self.audioManagerModule sendEventWithName:@"onRemoteSkipBackward"
-                                        body:@{@"interval" : [NSNumber numberWithDouble:event.interval]}];
+                                        body:@{@"value" : [NSNumber numberWithDouble:event.interval]}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onChangePlaybackPosition:(MPChangePlaybackPositionCommandEvent *)event
 {
   [self.audioManagerModule sendEventWithName:@"onRemoteChangePlaybackPosition"
-                                        body:@{@"positionTime" : [NSNumber numberWithDouble:event.positionTime]}];
+                                        body:@{@"value" : [NSNumber numberWithDouble:event.positionTime]}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 

package/ios/audioapi/ios/system/NotificationManager.h

@@ -3,14 +3,20 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
+@class AudioManagerModule;
+
 @interface NotificationManager : NSObject
 
+@property (nonatomic, weak) AudioManagerModule *audioManagerModule;
 @property (nonatomic, weak) NSNotificationCenter *notificationCenter;
 
 @property (nonatomic, assign) bool isInterrupted;
 @property (nonatomic, assign) bool hadConfigurationChange;
+@property (nonatomic, assign) BOOL audioInterruptionsObserved;
 
-+ (instancetype)sharedInstance;
++ (instancetype)sharedInstanceWithAudioManagerModule:(AudioManagerModule *)audioManagerModule;
 - (void)cleanup;
 
+- (void)observeAudioInterruptions:(BOOL)enabled;
+
 @end

package/ios/audioapi/ios/system/NotificationManager.mm

@@ -1,3 +1,4 @@
+#import <audioapi/ios/AudioManagerModule.h>
 #import <audioapi/ios/system/AudioEngine.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
 #import <audioapi/ios/system/NotificationManager.h>
@@ -6,11 +7,11 @@
 
 static NotificationManager *_sharedInstance = nil;
 
-+ (instancetype)sharedInstance
++ (instancetype)sharedInstanceWithAudioManagerModule:(AudioManagerModule *)audioManagerModule
 {
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
-    _sharedInstance = [[self alloc] initPrivate];
+    _sharedInstance = [[self alloc] initPrivateWithAudioManagerModule:audioManagerModule];
   });
   return _sharedInstance;
 }
@@ -21,10 +22,12 @@ static NotificationManager *_sharedInstance = nil;
   return nil;
 }
 
-- (instancetype)initPrivate
+- (instancetype)initPrivateWithAudioManagerModule:(AudioManagerModule *)audioManagerModule
 {
   if (self = [super init]) {
+    self.audioManagerModule = audioManagerModule;
     self.notificationCenter = [NSNotificationCenter defaultCenter];
+    self.audioInterruptionsObserved = false;
 
     [self configureNotifications];
   }
@@ -38,12 +41,26 @@ static NotificationManager *_sharedInstance = nil;
   self.notificationCenter = nil;
 }
 
+- (void)observeAudioInterruptions:(BOOL)enabled
+{
+  if (self.audioInterruptionsObserved == enabled) {
+    return;
+  }
+
+  if (enabled) {
+    [self.notificationCenter addObserver:self
+                                selector:@selector(handleInterruption:)
+                                    name:AVAudioSessionInterruptionNotification
+                                  object:nil];
+  } else {
+    [self.notificationCenter removeObserver:self name:AVAudioSessionInterruptionNotification object:nil];
+  }
+
+  self.audioInterruptionsObserved = enabled;
+}
+
 - (void)configureNotifications
 {
-  [self.notificationCenter addObserver:self
-                              selector:@selector(handleInterruption:)
-                                  name:AVAudioSessionInterruptionNotification
-                                object:nil];
   [self.notificationCenter addObserver:self
                               selector:@selector(handleRouteChange:)
                                   name:AVAudioSessionRouteChangeNotification
@@ -60,58 +77,63 @@ static NotificationManager *_sharedInstance = nil;
 
 - (void)handleInterruption:(NSNotification *)notification
 {
-  NSError *error;
-  UInt8 type = [[notification.userInfo valueForKey:AVAudioSessionInterruptionTypeKey] intValue];
-  UInt8 option = [[notification.userInfo valueForKey:AVAudioSessionInterruptionOptionKey] intValue];
-  AudioEngine *audioEngine = [AudioEngine sharedInstance];
-  AudioSessionManager *audioSessionManager = [AudioSessionManager sharedInstance];
-
-  if (type == AVAudioSessionInterruptionTypeBegan) {
-    self.isInterrupted = true;
-    NSLog(@"[NotificationManager] Detected interruption, stopping the engine");
-
-    [audioEngine stopEngine];
-
-    return;
-  }
-
-  if (type != AVAudioSessionInterruptionTypeEnded) {
-    NSLog(@"[NotificationManager] Unexpected interruption state, chilling");
+  if (!self.audioInterruptionsObserved) {
     return;
   }
 
-  self.isInterrupted = false;
+  NSInteger interruptionType = [notification.userInfo[AVAudioSessionInterruptionTypeKey] integerValue];
+  NSInteger interruptionOption = [notification.userInfo[AVAudioSessionInterruptionOptionKey] integerValue];
 
-  if (option != AVAudioSessionInterruptionOptionShouldResume) {
-    NSLog(@"[NotificationManager] Interruption ended, but engine is not allowed to resume");
+  if (interruptionType == AVAudioSessionInterruptionTypeBegan) {
+    [self.audioManagerModule sendEventWithName:@"onInterruption"
+                                          body:@{@"type" : @"began", @"shouldResume" : @"false"}];
     return;
   }
 
-  NSLog(@"[NotificationManager] Interruption ended, resuming the engine");
-  bool success = [audioSessionManager setActive:true error:&error];
-
-  if (!success) {
-    NSLog(@"[NotificationManager] Unable to activate the audio session, reason: %@", [error debugDescription]);
+  if (interruptionOption == AVAudioSessionInterruptionOptionShouldResume) {
+    [self.audioManagerModule sendEventWithName:@"onInterruption" body:@{@"type" : @"ended", @"shouldResume" : @"true"}];
     return;
   }
 
-  if (self.hadConfigurationChange) {
-    [audioEngine rebuildAudioEngine];
-  }
-
-  [audioEngine startEngine];
+  [self.audioManagerModule sendEventWithName:@"onInterruption" body:@{@"type" : @"ended", @"shouldResume" : @"false"}];
 }
 
 - (void)handleRouteChange:(NSNotification *)notification
 {
-  UInt8 reason = [[notification.userInfo valueForKey:AVAudioSessionInterruptionTypeKey] intValue];
-  NSLog(@"[NotificationManager] Route change detected, reason: %u", reason);
-  AudioEngine *audioEngine = [AudioEngine sharedInstance];
-
-  if (reason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
-    NSLog(@"[NotificationManager] The previously used audio device became unavailable. Audio engine paused");
-    [audioEngine stopEngine];
+  NSInteger routeChangeReason = [notification.userInfo[AVAudioSessionRouteChangeReasonKey] integerValue];
+  NSString *reasonStr;
+
+  switch (routeChangeReason) {
+    case AVAudioSessionRouteChangeReasonUnknown:
+      reasonStr = @"Unknown";
+      break;
+    case AVAudioSessionRouteChangeReasonOverride:
+      reasonStr = @"Override";
+      break;
+    case AVAudioSessionRouteChangeReasonCategoryChange:
+      reasonStr = @"CategoryChange";
+      break;
+    case AVAudioSessionRouteChangeReasonWakeFromSleep:
+      reasonStr = @"WakeFromSleep";
+      break;
+    case AVAudioSessionRouteChangeReasonNewDeviceAvailable:
+      reasonStr = @"NewDeviceAvailable";
+      break;
+    case AVAudioSessionRouteChangeReasonOldDeviceUnavailable:
+      reasonStr = @"OldDeviceUnavailable";
+      break;
+    case AVAudioSessionRouteChangeReasonRouteConfigurationChange:
+      reasonStr = @"ConfigurationChange";
+      break;
+    case AVAudioSessionRouteChangeReasonNoSuitableRouteForCategory:
+      reasonStr = @"NoSuitableRouteForCategory";
+      break;
+    default:
+      reasonStr = @"DoubleUnknown";
+      break;
   }
+
+  [self.audioManagerModule sendEventWithName:@"onRouteChange" body:@{@"reason" : @"reasonStr"}];
 }
 
 - (void)handleMediaServicesReset:(NSNotification *)notification

package/lib/commonjs/api.js

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AnalyserNode", {
+  enumerable: true,
+  get: function () {
+    return _AnalyserNode.default;
+  }
+});
+Object.defineProperty(exports, "AudioBuffer", {
+  enumerable: true,
+  get: function () {
+    return _AudioBuffer.default;
+  }
+});
+Object.defineProperty(exports, "AudioBufferSourceNode", {
+  enumerable: true,
+  get: function () {
+    return _AudioBufferSourceNode.default;
+  }
+});
+Object.defineProperty(exports, "AudioContext", {
+  enumerable: true,
+  get: function () {
+    return _AudioContext.default;
+  }
+});
+Object.defineProperty(exports, "AudioDestinationNode", {
+  enumerable: true,
+  get: function () {
+    return _AudioDestinationNode.default;
+  }
+});
+Object.defineProperty(exports, "AudioManager", {
+  enumerable: true,
+  get: function () {
+    return _system.default;
+  }
+});
+Object.defineProperty(exports, "AudioNode", {
+  enumerable: true,
+  get: function () {
+    return _AudioNode.default;
+  }
+});
+Object.defineProperty(exports, "AudioParam", {
+  enumerable: true,
+  get: function () {
+    return _AudioParam.default;
+  }
+});
+Object.defineProperty(exports, "AudioScheduledSourceNode", {
+  enumerable: true,
+  get: function () {
+    return _AudioScheduledSourceNode.default;
+  }
+});
+Object.defineProperty(exports, "BaseAudioContext", {
+  enumerable: true,
+  get: function () {
+    return _BaseAudioContext.default;
+  }
+});
+Object.defineProperty(exports, "BiquadFilterNode", {
+  enumerable: true,
+  get: function () {
+    return _BiquadFilterNode.default;
+  }
+});
+Object.defineProperty(exports, "BiquadFilterType", {
+  enumerable: true,
+  get: function () {
+    return _types.BiquadFilterType;
+  }
+});
+Object.defineProperty(exports, "ChannelCountMode", {
+  enumerable: true,
+  get: function () {
+    return _types.ChannelCountMode;
+  }
+});
+Object.defineProperty(exports, "ChannelInterpretation", {
+  enumerable: true,
+  get: function () {
+    return _types.ChannelInterpretation;
+  }
+});
+Object.defineProperty(exports, "ContextState", {
+  enumerable: true,
+  get: function () {
+    return _types.ContextState;
+  }
+});
+Object.defineProperty(exports, "GainNode", {
+  enumerable: true,
+  get: function () {
+    return _GainNode.default;
+  }
+});
+Object.defineProperty(exports, "IndexSizeError", {
+  enumerable: true,
+  get: function () {
+    return _errors.IndexSizeError;
+  }
+});
+Object.defineProperty(exports, "InvalidAccessError", {
+  enumerable: true,
+  get: function () {
+    return _errors.InvalidAccessError;
+  }
+});
+Object.defineProperty(exports, "InvalidStateError", {
+  enumerable: true,
+  get: function () {
+    return _errors.InvalidStateError;
+  }
+});
+Object.defineProperty(exports, "NotSupportedError", {
+  enumerable: true,
+  get: function () {
+    return _errors.NotSupportedError;
+  }
+});
+Object.defineProperty(exports, "OfflineAudioContext", {
+  enumerable: true,
+  get: function () {
+    return _OfflineAudioContext.default;
+  }
+});
+Object.defineProperty(exports, "OscillatorNode", {
+  enumerable: true,
+  get: function () {
+    return _OscillatorNode.default;
+  }
+});
+Object.defineProperty(exports, "OscillatorType", {
+  enumerable: true,
+  get: function () {
+    return _types.OscillatorType;
+  }
+});
+Object.defineProperty(exports, "PeriodicWaveConstraints", {
+  enumerable: true,
+  get: function () {
+    return _types.PeriodicWaveConstraints;
+  }
+});
+Object.defineProperty(exports, "RangeError", {
+  enumerable: true,
+  get: function () {
+    return _errors.RangeError;
+  }
+});
+Object.defineProperty(exports, "StereoPannerNode", {
+  enumerable: true,
+  get: function () {
+    return _StereoPannerNode.default;
+  }
+});
+Object.defineProperty(exports, "WindowType", {
+  enumerable: true,
+  get: function () {
+    return _types.WindowType;
+  }
+});
+var _NativeAudioAPIModule = _interopRequireDefault(require("./specs/NativeAudioAPIModule"));
+var _AudioBuffer = _interopRequireDefault(require("./core/AudioBuffer"));
+var _AudioBufferSourceNode = _interopRequireDefault(require("./core/AudioBufferSourceNode"));
+var _AudioContext = _interopRequireDefault(require("./core/AudioContext"));
+var _OfflineAudioContext = _interopRequireDefault(require("./core/OfflineAudioContext"));
+var _AudioDestinationNode = _interopRequireDefault(require("./core/AudioDestinationNode"));
+var _AudioNode = _interopRequireDefault(require("./core/AudioNode"));
+var _AnalyserNode = _interopRequireDefault(require("./core/AnalyserNode"));
+var _AudioParam = _interopRequireDefault(require("./core/AudioParam"));
+var _AudioScheduledSourceNode = _interopRequireDefault(require("./core/AudioScheduledSourceNode"));
+var _BaseAudioContext = _interopRequireDefault(require("./core/BaseAudioContext"));
+var _BiquadFilterNode = _interopRequireDefault(require("./core/BiquadFilterNode"));
+var _GainNode = _interopRequireDefault(require("./core/GainNode"));
+var _OscillatorNode = _interopRequireDefault(require("./core/OscillatorNode"));
+var _StereoPannerNode = _interopRequireDefault(require("./core/StereoPannerNode"));
+var _system = _interopRequireDefault(require("./system"));
+var _types = require("./types");
+var _errors = require("./errors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable no-var */
+
+/* eslint-disable no-var */
+
+if (global.createAudioContext == null || global.createOfflineAudioContext == null) {
+  if (!_NativeAudioAPIModule.default) {
+    throw new Error(`Failed to install react-native-audio-api: The native module could not be found.`);
+  }
+  _NativeAudioAPIModule.default.install();
+}
+//# sourceMappingURL=api.js.map

package/lib/commonjs/api.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_NativeAudioAPIModule","_interopRequireDefault","require","_AudioBuffer","_AudioBufferSourceNode","_AudioContext","_OfflineAudioContext","_AudioDestinationNode","_AudioNode","_AnalyserNode","_AudioParam","_AudioScheduledSourceNode","_BaseAudioContext","_BiquadFilterNode","_GainNode","_OscillatorNode","_StereoPannerNode","_system","_types","_errors","e","__esModule","default","global","createAudioContext","createOfflineAudioContext","NativeAudioAPIModule","Error","install"],"sourceRoot":"../../src","sources":["api.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,qBAAA,GAAAC,sBAAA,CAAAC,OAAA;AA2BA,IAAAC,YAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,sBAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,aAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,oBAAA,GAAAL,sBAAA,CAAAC,OAAA;AACA,IAAAK,qBAAA,GAAAN,sBAAA,CAAAC,OAAA;AACA,IAAAM,UAAA,GAAAP,sBAAA,CAAAC,OAAA;AACA,IAAAO,aAAA,GAAAR,sBAAA,CAAAC,OAAA;AACA,IAAAQ,WAAA,GAAAT,sBAAA,CAAAC,OAAA;AACA,IAAAS,yBAAA,GAAAV,sBAAA,CAAAC,OAAA;AACA,IAAAU,iBAAA,GAAAX,sBAAA,CAAAC,OAAA;AACA,IAAAW,iBAAA,GAAAZ,sBAAA,CAAAC,OAAA;AACA,IAAAY,SAAA,GAAAb,sBAAA,CAAAC,OAAA;AACA,IAAAa,eAAA,GAAAd,sBAAA,CAAAC,OAAA;AACA,IAAAc,iBAAA,GAAAf,sBAAA,CAAAC,OAAA;AACA,IAAAe,OAAA,GAAAhB,sBAAA,CAAAC,OAAA;AAEA,IAAAgB,MAAA,GAAAhB,OAAA;AAUA,IAAAiB,OAAA,GAAAjB,OAAA;AAMkB,SAAAD,uBAAAmB,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAxDlB;;AASA;;AAEA,IACEG,MAAM,CAACC,kBAAkB,IAAI,IAAI,IACjCD,MAAM,CAACE,yBAAyB,IAAI,IAAI,EACxC;EACA,IAAI,CAACC,6BAAoB,EAAE;IACzB,MAAM,IAAIC,KAAK,CACb,iFACF,CAAC;EACH;EAEAD,6BAAoB,CAACE,OAAO,CAAC,CAAC;AAChC","ignoreList":[]}