react-native-audio-api 0.6.0 → 0.6.1-rc.10

package/common/cpp/audioapi/core/AudioContext.h

@@ -14,7 +14,7 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  explicit AudioContext(float sampleRate, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit AudioContext(float sampleRate, bool initSuspended, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~AudioContext() override;
 
   void close();
@@ -27,6 +27,7 @@ class AudioContext : public BaseAudioContext {
 #else
   std::shared_ptr<IOSAudioPlayer> audioPlayer_;
 #endif
+  bool playerHasBeenStarted_;
 
   std::function<void(std::shared_ptr<AudioBus>, int)> renderAudio();
 };

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -5,6 +5,7 @@
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
@@ -79,6 +80,13 @@ std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
   return bufferSource;
 }
 
+std::shared_ptr<AudioBufferQueueSourceNode>
+BaseAudioContext::createBufferQueueSource() {
+  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(this);
+  nodeManager_->addSourceNode(bufferSource);
+  return bufferSource;
+}
+
 std::shared_ptr<AudioBuffer> BaseAudioContext::createBuffer(
     int numberOfChannels,
     size_t length,
@@ -131,6 +139,10 @@ bool BaseAudioContext::isRunning() const {
   return state_ == ContextState::RUNNING;
 }
 
+bool BaseAudioContext::isSuspended() const {
+  return state_ == ContextState::SUSPENDED;
+}
+
 bool BaseAudioContext::isClosed() const {
   return state_ == ContextState::CLOSED;
 }

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -24,6 +24,7 @@ class AudioNodeManager;
 class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
+class AudioBufferQueueSourceNode;
 class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
@@ -44,6 +45,7 @@ class BaseAudioContext {
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);
+  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource();
   static std::shared_ptr<AudioBuffer>
   createBuffer(int numberOfChannels, size_t length, float sampleRate);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
@@ -60,6 +62,7 @@ class BaseAudioContext {
   AudioNodeManager *getNodeManager();
 
   [[nodiscard]] bool isRunning() const;
+  [[nodiscard]] bool isSuspended() const;
   [[nodiscard]] bool isClosed() const;
 
  protected:
@@ -79,9 +82,7 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
 
- protected:
-    friend class AudioScheduledSourceNode;
-
+ public:
     std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
 

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

@@ -35,6 +35,7 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
 
  private:
   friend class AudioBufferSourceNode;
+  friend class AudioBufferQueueSourceNode;
 
   std::shared_ptr<AudioBus> bus_;
 };

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

@@ -0,0 +1,236 @@
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/Constants.h>
+#include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
+#include <audioapi/core/utils/Locker.h>
+#include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+
+AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
+    BaseAudioContext *context)
+    : AudioScheduledSourceNode(context), vReadIndex_(0.0) {
+  buffers_ = {};
+
+  detuneParam_ = std::make_shared<AudioParam>(
+      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+  playbackRateParam_ = std::make_shared<AudioParam>(
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+
+  playbackRateBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+
+  stretch_ =
+      std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
+  stretch_->presetDefault(channelCount_, context_->getSampleRate(), true);
+
+  onPositionChangedInterval_ = static_cast<int>(context_->getSampleRate() / 10);
+
+  isInitialized_ = true;
+}
+
+AudioBufferQueueSourceNode::~AudioBufferQueueSourceNode() {
+  Locker locker(getBufferLock());
+
+  buffers_ = {};
+}
+
+std::shared_ptr<AudioParam> AudioBufferQueueSourceNode::getDetuneParam() const {
+  return detuneParam_;
+}
+
+std::shared_ptr<AudioParam> AudioBufferQueueSourceNode::getPlaybackRateParam()
+    const {
+  return playbackRateParam_;
+}
+
+void AudioBufferQueueSourceNode::start(double when, double offset) {
+  AudioScheduledSourceNode::start(when);
+
+  vReadIndex_ = static_cast<double>(context_->getSampleRate() * offset);
+}
+
+void AudioBufferQueueSourceNode::enqueueBuffer(
+    const std::shared_ptr<AudioBuffer> &buffer,
+    int bufferId,
+    bool isLastBuffer) {
+  auto locker = Locker(getBufferLock());
+  buffers_.emplace(bufferId, buffer);
+
+  isLastBuffer_ = isLastBuffer;
+}
+
+void AudioBufferQueueSourceNode::disable() {
+  audioapi::AudioNode::disable();
+
+  std::string state = "stopped";
+
+  // if it has not been stopped, it is ended
+  if (stopTime_ < 0) {
+    state = "ended";
+  }
+
+  std::unordered_map<std::string, EventValue> body = {
+      {"value", getStopTime()}, {"state", state}, {"bufferId", bufferId_}};
+
+  context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+      "ended", onEndedCallbackId_, body);
+  buffers_ = {};
+}
+
+std::mutex &AudioBufferQueueSourceNode::getBufferLock() {
+  return bufferLock_;
+}
+
+void AudioBufferQueueSourceNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (auto locker = Locker::tryLock(getBufferLock())) {
+    // No audio data to fill, zero the output and return.
+    if (buffers_.empty()) {
+      processingBus->zero();
+      return;
+    }
+
+    processWithPitchCorrection(processingBus, framesToProcess);
+
+    handleStopScheduled();
+  } else {
+    processingBus->zero();
+  }
+}
+
+double AudioBufferQueueSourceNode::getStopTime() const {
+  return dsp::sampleFrameToTime(
+      static_cast<int>(vReadIndex_), context_->getSampleRate());
+}
+
+void AudioBufferQueueSourceNode::setOnPositionChangedCallbackId(
+    uint64_t callbackId) {
+  onPositionChangedCallbackId_ = callbackId;
+}
+
+void AudioBufferQueueSourceNode::sendOnPositionChangedEvent() {
+  if (onPositionChangedTime_ > onPositionChangedInterval_) {
+    std::unordered_map<std::string, EventValue> body = {
+        {"value", getStopTime()}, {"bufferId", bufferId_}};
+
+    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "positionChanged", onPositionChangedCallbackId_, body);
+
+    onPositionChangedTime_ = 0;
+  }
+
+  onPositionChangedTime_ += RENDER_QUANTUM_SIZE;
+}
+
+void AudioBufferQueueSourceNode::setOnPositionChangedInterval(int interval) {
+  onPositionChangedInterval_ = static_cast<int>(
+      context_->getSampleRate() * static_cast<float>(interval) / 1000);
+}
+
+/**
+ * Helper functions
+ */
+
+void AudioBufferQueueSourceNode::processWithPitchCorrection(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  auto time = context_->getCurrentTime();
+  auto playbackRate = std::clamp(
+      playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
+  auto detune = std::clamp(
+      detuneParam_->processKRateParam(framesToProcess, time) / 100.0f,
+      -12.0f,
+      12.0f);
+
+  playbackRateBus_->zero();
+
+  auto framesNeededToStretch =
+      static_cast<int>(playbackRate * static_cast<float>(framesToProcess));
+
+  updatePlaybackInfo(
+      playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
+
+  if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
+    processingBus->zero();
+    return;
+  }
+
+  // Send position changed event
+  sendOnPositionChangedEvent();
+
+  processWithoutInterpolation(playbackRateBus_, startOffset, offsetLength);
+
+  stretch_->process(
+      playbackRateBus_.get()[0],
+      framesNeededToStretch,
+      processingBus.get()[0],
+      framesToProcess);
+
+  if (detune != 0.0f) {
+    stretch_->setTransposeSemitones(detune);
+  }
+}
+
+void AudioBufferQueueSourceNode::processWithoutInterpolation(
+    const std::shared_ptr<AudioBus> &processingBus,
+    size_t startOffset,
+    size_t offsetLength) {
+  auto readIndex = static_cast<size_t>(vReadIndex_);
+  size_t writeIndex = startOffset;
+
+  auto queueData = buffers_.front();
+  bufferId_ = queueData.first;
+  auto buffer = queueData.second;
+
+  size_t framesLeft = offsetLength;
+
+  while (framesLeft > 0) {
+    size_t framesToEnd = buffer->getLength() - readIndex;
+    size_t framesToCopy = std::min(framesToEnd, framesLeft);
+    framesToCopy = framesToCopy > 0 ? framesToCopy : 0;
+
+    assert(readIndex >= 0);
+    assert(writeIndex >= 0);
+    assert(writeIndex + framesToCopy <= processingBus->getSize());
+
+    processingBus->copy(
+        buffer->bus_.get(), readIndex, writeIndex, framesToCopy);
+
+    writeIndex += framesToCopy;
+    readIndex += framesToCopy;
+    framesLeft -= framesToCopy;
+
+    if (readIndex >= buffer->getLength()) {
+      buffers_.pop();
+
+      if (buffers_.empty()) {
+        processingBus->zero(writeIndex, framesLeft);
+        readIndex = 0;
+
+        if (isLastBuffer_) {
+          playbackState_ = PlaybackState::STOP_SCHEDULED;
+        }
+        break;
+      } else {
+        queueData = buffers_.front();
+        bufferId_ = queueData.first;
+        buffer = queueData.second;
+
+        readIndex = 0;
+      }
+    }
+  }
+
+  // update reading index for next render quantum
+  vReadIndex_ = static_cast<double>(readIndex);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
+
+#include <memory>
+#include <cstddef>
+#include <algorithm>
+#include <string>
+#include <queue>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioParam;
+
+class AudioBufferQueueSourceNode : public AudioScheduledSourceNode {
+ public:
+    explicit AudioBufferQueueSourceNode(BaseAudioContext *context);
+    ~AudioBufferQueueSourceNode() override;
+
+    [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
+    [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
+
+    void start(double when, double offset);
+    void enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer, int bufferId, bool isLastBuffer);
+    void disable() override;
+
+    void setOnPositionChangedCallbackId(uint64_t callbackId);
+    void setOnPositionChangedInterval(int interval);
+    void sendOnPositionChangedEvent();
+
+ protected:
+    std::mutex &getBufferLock();
+    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+    double getStopTime() const override;
+
+ private:
+    std::mutex bufferLock_;
+
+    // pitch correction
+    std::shared_ptr<signalsmith::stretch::SignalsmithStretch<float>> stretch_;
+    std::shared_ptr<AudioBus> playbackRateBus_;
+
+    // k-rate params
+    std::shared_ptr<AudioParam> detuneParam_;
+    std::shared_ptr<AudioParam> playbackRateParam_;
+
+    // internal helper
+    double vReadIndex_;
+
+    // User provided buffers
+    std::queue<std::pair<int, std::shared_ptr<AudioBuffer>>> buffers_;
+    int bufferId_ = 0;
+    bool isLastBuffer_ = false;
+
+    // positionChanged event props: callbackId, update interval in frames, time since last update in frames
+    uint64_t onPositionChangedCallbackId_ = 0;
+    int onPositionChangedInterval_;
+    int onPositionChangedTime_ = 0;
+
+    void processWithPitchCorrection(const std::shared_ptr<AudioBus> &processingBus,
+                                    int framesToProcess);
+
+    void processWithoutInterpolation(
+            const std::shared_ptr<AudioBus>& processingBus,
+            size_t startOffset,
+            size_t offsetLength);
+};
+
+} // namespace audioapi

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

@@ -17,7 +17,7 @@ class AudioParam;
 class AudioBufferSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferSourceNode(BaseAudioContext *context, bool pitchCorrection);
-  ~AudioBufferSourceNode();
+  ~AudioBufferSourceNode() override;
 
   [[nodiscard]] bool getLoop() const;
   [[nodiscard]] double getLoopStart() const;

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

@@ -10,9 +10,9 @@ namespace audioapi {
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
     : AudioNode(context),
-      playbackState_(PlaybackState::UNSCHEDULED),
       startTime_(-1.0),
-      stopTime_(-1.0) {
+      stopTime_(-1.0),
+      playbackState_(PlaybackState::UNSCHEDULED) {
   numberOfInputs_ = 0;
 }
 
@@ -144,7 +144,15 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  std::unordered_map<std::string, EventValue> body = {{"value", getStopTime()}};
+  std::string state = "stopped";
+
+  // if it has not been stopped, it is ended
+  if (stopTime_ < 0) {
+    state = "ended";
+  }
+
+  std::unordered_map<std::string, EventValue> body = {
+      {"value", getStopTime()}, {"state", state}};
 
   context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
       "ended", onEndedCallbackId_, body);

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

@@ -43,6 +43,9 @@ class AudioScheduledSourceNode : public AudioNode {
   void disable() override;
 
  protected:
+  double startTime_;
+  double stopTime_;
+
   PlaybackState playbackState_;
 
   void updatePlaybackInfo(
@@ -53,10 +56,6 @@ class AudioScheduledSourceNode : public AudioNode {
 
   void handleStopScheduled();
 
- private:
-  double startTime_;
-  double stopTime_;
-
   uint64_t onEndedCallbackId_ = 0;
 };
 

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -49,9 +49,10 @@ class AudioEventHandlerRegistry {
         "volumeChange",
     };
 
-    static constexpr std::array<std::string_view, 4> AUDIO_API_EVENT_NAMES = {
+    static constexpr std::array<std::string_view, 5> AUDIO_API_EVENT_NAMES = {
       "ended",
       "audioReady",
+      "positionChanged",
       "audioError",
       "systemStateChanged"
     };

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -80,19 +80,21 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   return @true;
 }
 
-RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
 {
-  [self.lockScreenManager setLockScreenInfo:info];
+  return [self.audioSessionManager getDevicePreferredSampleRate];
 }
 
-RCT_EXPORT_METHOD(resetLockScreenInfo)
+RCT_EXPORT_METHOD(
+    setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
+        reject)
 {
-  [self.lockScreenManager resetLockScreenInfo];
-}
+  if ([self.audioSessionManager setActive:enabled]) {
+    resolve(@"true");
+    return;
+  }
 
-RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
-{
-  [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
+  resolve(@"false");
 }
 
 RCT_EXPORT_METHOD(setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)options)
@@ -100,9 +102,19 @@ RCT_EXPORT_METHOD(setAudioSessionOptions : (NSString *)category mode : (NSString
   [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options];
 }
 
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
+RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
 {
-  return [self.audioSessionManager getDevicePreferredSampleRate];
+  [self.lockScreenManager setLockScreenInfo:info];
+}
+
+RCT_EXPORT_METHOD(resetLockScreenInfo)
+{
+  [self.lockScreenManager resetLockScreenInfo];
+}
+
+RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
+{
+  [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
 }
 
 RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
@@ -115,15 +127,16 @@ RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
   [self.notificationManager observeVolumeChanges:(BOOL)enabled];
 }
 
-RCT_EXPORT_METHOD(requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)
-                      resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+RCT_EXPORT_METHOD(
+    requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)
+        reject)
 {
   NSString *res = [self.audioSessionManager requestRecordingPermissions];
   resolve(res);
 }
 
-RCT_EXPORT_METHOD(checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)
-                      resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+RCT_EXPORT_METHOD(
+    checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
   NSString *res = [self.audioSessionManager checkRecordingPermissions];
   resolve(res);
@@ -158,7 +171,7 @@ RCT_EXPORT_METHOD(checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)
         body[stdKey] = EventValue([value doubleValue]);
       } else if (strcmp(type, @encode(float)) == 0) {
         body[stdKey] = EventValue([value floatValue]);
-      } else if (strcmp(type, @encode(BOOL)) == 0) {
+      } else {
         body[stdKey] = EventValue([value boolValue]);
       }
     }

package/ios/audioapi/ios/core/IOSAudioPlayer.h

@@ -21,9 +21,10 @@ class IOSAudioPlayer {
   ~IOSAudioPlayer();
 
   void start();
-  void resume();
   void stop();
-  void pause();
+  void resume();
+  void suspend();
+  void cleanup();
 
  protected:
   std::shared_ptr<AudioBus> audioBus_;

package/ios/audioapi/ios/core/IOSAudioPlayer.mm

@@ -43,12 +43,7 @@ IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus
 
 IOSAudioPlayer::~IOSAudioPlayer()
 {
-  stop();
-  [audioPlayer_ cleanup];
-
-  if (audioBus_) {
-    audioBus_ = nullptr;
-  }
+  cleanup();
 }
 
 void IOSAudioPlayer::start()
@@ -61,20 +56,36 @@ void IOSAudioPlayer::start()
   isRunning_.store(true);
 }
 
+void IOSAudioPlayer::stop()
+{
+  isRunning_.store(false);
+  [audioPlayer_ stop];
+}
+
 void IOSAudioPlayer::resume()
 {
+  if (isRunning_.load()) {
+    return;
+  }
+
+  [audioPlayer_ resume];
   isRunning_.store(true);
 }
 
-void IOSAudioPlayer::stop()
+void IOSAudioPlayer::suspend()
 {
   isRunning_.store(false);
-  [audioPlayer_ stop];
+  [audioPlayer_ suspend];
 }
 
-void IOSAudioPlayer::pause()
+void IOSAudioPlayer::cleanup()
 {
-  isRunning_.store(false);
+  stop();
+  [audioPlayer_ cleanup];
+
+  if (audioBus_) {
+    audioBus_ = nullptr;
+  }
 }
 
 } // namespace audioapi

package/ios/audioapi/ios/core/NativeAudioPlayer.h

@@ -23,6 +23,10 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 - (void)stop;
 
+- (void)resume;
+
+- (void)suspend;
+
 - (void)cleanup;
 
 @end

package/ios/audioapi/ios/core/NativeAudioPlayer.m

@@ -51,6 +51,21 @@
   self.sourceNodeId = nil;
 }
 
+- (void)resume
+{
+  NSLog(@"[AudioPlayer] resume");
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+  [audioEngine startEngine];
+}
+
+- (void)suspend
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+  [audioEngine pauseEngine];
+}
+
 - (void)cleanup
 {
   self.renderAudio = nil;

package/ios/audioapi/ios/system/AudioEngine.h

@@ -20,6 +20,7 @@
 - (bool)rebuildAudioEngine;
 - (void)startEngine;
 - (void)stopEngine;
+- (void)pauseEngine;
 - (bool)isRunning;
 
 - (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format;