react-native-audio-api 0.4.10 → 0.4.12-beta.1

package/android/build.gradle

@@ -194,6 +194,8 @@ android {
             // This is needed to build Kotlin project with NewArch enabled
             "${project.buildDir}/generated/source/codegen/java"
           ]
+      } else {
+        java.srcDirs += ["src/oldarch"]
       }
     }
   }

package/android/src/main/cpp/{core/AudioAPIInstaller.cpp → AudioAPIModule.cpp}

@@ -1,18 +1,21 @@
-#include "AudioAPIInstaller.h"
+#include "AudioAPIModule.h"
+
+#include "AudioContext.h"
+#include "AudioContextHostObject.h"
 
 namespace audioapi {
 
 using namespace facebook::jni;
 
-AudioAPIInstaller::AudioAPIInstaller(
-    jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
+AudioAPIModule::AudioAPIModule(
+    jni::alias_ref<AudioAPIModule::jhybridobject> &jThis,
     jsi::Runtime *jsiRuntime,
     const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
     : javaPart_(make_global(jThis)),
       jsiRuntime_(jsiRuntime),
       jsCallInvoker_(jsCallInvoker) {}
 
-jni::local_ref<AudioAPIInstaller::jhybriddata> AudioAPIInstaller::initHybrid(
+jni::local_ref<AudioAPIModule::jhybriddata> AudioAPIModule::initHybrid(
     jni::alias_ref<jhybridobject> jThis,
     jlong jsContext,
     jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
@@ -22,16 +25,14 @@ jni::local_ref<AudioAPIInstaller::jhybriddata> AudioAPIInstaller::initHybrid(
   return makeCxxInstance(jThis, rnRuntime, jsCallInvoker);
 }
 
-void AudioAPIInstaller::registerNatives() {
+void AudioAPIModule::registerNatives() {
   registerHybrid({
-      makeNativeMethod("initHybrid", AudioAPIInstaller::initHybrid),
-      makeNativeMethod("install", AudioAPIInstaller::install),
+      makeNativeMethod("initHybrid", AudioAPIModule::initHybrid),
+      makeNativeMethod("injectJSIBindings", AudioAPIModule::injectJSIBindings),
   });
 }
 
-void AudioAPIInstaller::install() {
-  auto hostObject = std::make_shared<AudioAPIInstallerHostObject>(
-      jsiRuntime_, jsCallInvoker_);
-  hostObject->install();
+void AudioAPIModule::injectJSIBindings() {
+  AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime_, jsCallInvoker_);
 }
 } // namespace audioapi

package/android/src/main/cpp/{core/AudioAPIInstaller.h → AudioAPIModule.h}

@@ -6,21 +6,19 @@
 #include <react/jni/JMessageQueueThread.h>
 #include <memory>
 #include <utility>
-
-#include "AudioAPIInstallerHostObject.h"
-#include "AudioContext.h"
+#include "AudioAPIModuleInstaller.h"
 
 namespace audioapi {
 
 using namespace facebook;
 using namespace react;
 
-class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
+class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
  public:
   static auto constexpr kJavaDescriptor =
-      "Lcom/swmansion/audioapi/module/AudioAPIInstaller;";
+      "Lcom/swmansion/audioapi/AudioAPIModule;";
 
-  static jni::local_ref<AudioAPIInstaller::jhybriddata> initHybrid(
+  static jni::local_ref<AudioAPIModule::jhybriddata> initHybrid(
       jni::alias_ref<jhybridobject> jThis,
       jlong jsContext,
       jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
@@ -28,18 +26,18 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
 
   static void registerNatives();
 
-  void install();
+  void injectJSIBindings();
 
  private:
   friend HybridBase;
 
-  jni::global_ref<AudioAPIInstaller::javaobject> javaPart_;
+  jni::global_ref<AudioAPIModule::javaobject> javaPart_;
   jsi::Runtime *jsiRuntime_;
   std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
 
-  explicit AudioAPIInstaller(
-      jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
-      jsi::Runtime *rnRuntime,
+  explicit AudioAPIModule(
+      jni::alias_ref<AudioAPIModule::jhybridobject> &jThis,
+      jsi::Runtime *jsiRuntime,
       const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker);
 };
 

package/android/src/main/cpp/OnLoad.cpp

@@ -1,9 +1,9 @@
 #include <fbjni/fbjni.h>
-#include "AudioAPIInstaller.h"
+#include "AudioAPIModule.h"
 
 using namespace audioapi;
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
   return facebook::jni::initialize(
-      vm, [] { AudioAPIInstaller::registerNatives(); });
+      vm, [] { AudioAPIModule::registerNatives(); });
 }

package/android/src/main/cpp/core/AudioDecoder.cpp

@@ -9,7 +9,8 @@
 
 namespace audioapi {
 
-AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
+std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
+    const std::string &path) const {
   ma_decoder decoder;
   ma_decoder_config config =
       ma_decoder_config_init(ma_format_f32, 2, sampleRate_);
@@ -29,8 +30,8 @@ AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
   ma_uint64 totalFrameCount;
   ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
 
-  auto *audioBus =
-      new AudioBus(static_cast<int>(totalFrameCount), 2, sampleRate_);
+  auto audioBus = std::make_shared<AudioBus>(
+      static_cast<int>(totalFrameCount), 2, sampleRate_);
   auto *buffer = new float[totalFrameCount * 2];
 
   ma_uint64 framesDecoded;
@@ -43,14 +44,13 @@ AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
         path.c_str());
 
     delete[] buffer;
-    delete audioBus;
     ma_decoder_uninit(&decoder);
 
     return nullptr;
   }
 
   for (int i = 0; i < decoder.outputChannels; ++i) {
-    float *channelData = audioBus->getChannel(i)->getData();
+    auto channelData = audioBus->getChannel(i)->getData();
 
     for (ma_uint64 j = 0; j < framesDecoded; ++j) {
       channelData[j] = buffer[j * decoder.outputChannels + i];

package/android/src/main/cpp/core/AudioPlayer.cpp

@@ -70,6 +70,18 @@ void AudioPlayer::stop() {
   }
 }
 
+void AudioPlayer::resume() {
+  if (mStream_) {
+    mStream_->requestStart();
+  }
+}
+
+void AudioPlayer::suspend() {
+  if (mStream_) {
+    mStream_->requestPause();
+  }
+}
+
 DataCallbackResult AudioPlayer::onAudioReady(
     AudioStream *oboeStream,
     void *audioData,

package/android/src/main/cpp/core/AudioPlayer.h

@@ -22,6 +22,8 @@ class AudioPlayer : public AudioStreamDataCallback {
   [[nodiscard]] float getSampleRate() const;
   void start();
   void stop();
+  void resume();
+  void suspend();
 
   DataCallbackResult onAudioReady(
       AudioStream *oboeStream,

package/android/src/main/java/com/swmansion/audioapi/{module/AudioAPIInstaller.kt → AudioAPIModule.kt}

@@ -1,31 +1,43 @@
-package com.swmansion.audioapi.module
+package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 
 @OptIn(FrameworkAPI::class)
-class AudioAPIInstaller(
+@ReactModule(name = AudioAPIModule.NAME)
+class AudioAPIModule(
   reactContext: ReactApplicationContext,
-) {
-  private val mHybridData: HybridData?
-
+) : NativeAudioAPIModuleSpec(reactContext) {
   companion object {
     init {
       System.loadLibrary("react-native-audio-api")
     }
+
+    const val NAME = NativeAudioAPIModuleSpec.NAME
   }
 
+  private val mHybridData: HybridData
+
+  external fun initHybrid(
+    jsContext: Long,
+    callInvoker: CallInvokerHolderImpl,
+  ): HybridData
+
+  private external fun injectJSIBindings()
+
   init {
     val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
     mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
   }
 
-  external fun initHybrid(
-    jsContext: Long,
-    callInvoker: CallInvokerHolderImpl,
-  ): HybridData?
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun install(): Boolean {
+    injectJSIBindings()
 
-  external fun install()
+    return true
+  }
 }

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

@@ -1,16 +1,41 @@
 package com.swmansion.audioapi
 
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.module.annotations.ReactModuleList
-import com.facebook.react.uimanager.ViewManager
-import com.swmansion.audioapi.nativemodules.AudioAPIModule
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 
 @ReactModuleList(nativeModules = [AudioAPIModule::class])
-class AudioAPIPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
-    listOf<NativeModule>(AudioAPIModule(reactContext))
+class AudioAPIPackage :
+  BaseReactPackage(),
+  ReactPackage {
+  @UnstableReactNativeAPI
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? =
+    when (name) {
+      AudioAPIModule.NAME -> AudioAPIModule(reactContext)
+      else -> null
+    }
 
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider(
+      fun (): Map<String, ReactModuleInfo> =
+        mapOf(
+          AudioAPIModule.NAME to
+            ReactModuleInfo(
+              AudioAPIModule.NAME,
+              AudioAPIModule::class.java.simpleName,
+              _canOverrideExistingModule = true,
+              _needsEagerInit = false,
+              isCxxModule = false,
+              isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+            ),
+        ),
+    )
 }

package/android/src/oldarch/NativeAudioAPIModuleSpec.java

@@ -0,0 +1,37 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.swmansion.audioapi;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeAudioAPIModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "AudioAPIModule";
+
+  public NativeAudioAPIModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean install();
+}

package/common/cpp/HostObjects/AudioBufferSourceNodeHostObject.h

@@ -23,8 +23,7 @@ class AudioBufferSourceNodeHostObject
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopStart),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopEnd),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, detune),
-        JSI_EXPORT_PROPERTY_GETTER(
-            AudioBufferSourceNodeHostObject, playbackRate));
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, playbackRate));
 
     addSetters(
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loop),

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -17,7 +17,10 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
       const std::shared_ptr<AudioContext> &audioContext,
       const std::shared_ptr<PromiseVendor> &promiseVendor)
       : BaseAudioContextHostObject(audioContext, promiseVendor) {
-    addFunctions(JSI_EXPORT_FUNCTION(AudioContextHostObject, close));
+    addFunctions(
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, close),
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, resume),
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, suspend));
   }
 
   JSI_HOST_FUNCTION(close) {
@@ -34,5 +37,35 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
 
     return promise;
   }
+
+  JSI_HOST_FUNCTION(resume) {
+    auto promise = promiseVendor_->createPromise([this](std::shared_ptr<Promise> promise) {
+      std::thread([this, promise = std::move(promise)]() {
+          auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+          audioContext->resume();
+
+          promise->resolve([](jsi::Runtime &runtime) {
+              return jsi::Value::undefined();
+          });
+      }).detach();
+    });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(suspend) {
+    auto promise = promiseVendor_->createPromise([this](std::shared_ptr<Promise> promise) {
+      std::thread([this, promise = std::move(promise)]() {
+          auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+          audioContext->suspend();
+
+          promise->resolve([](jsi::Runtime &runtime) {
+              return jsi::Value::undefined();
+          });
+      }).detach();
+    });
+
+    return promise;
+  }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -19,6 +19,7 @@
 #include "PeriodicWaveHostObject.h"
 #include "StereoPannerNodeHostObject.h"
 #include "AnalyserNodeHostObject.h"
+#include "StretcherNodeHostObject.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -44,6 +45,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStretcher),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, decodeAudioDataSource));
   }
 
@@ -140,6 +142,12 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return jsi::Object::createFromHostObject(runtime, analyserHostObject);
   }
 
+  JSI_HOST_FUNCTION(createStretcher) {
+    auto stretcher = context_->createStretcher();
+    auto stretcherHostObject = std::make_shared<StretcherNodeHostObject>(stretcher);
+    return jsi::Object::createFromHostObject(runtime, stretcherHostObject);
+  }
+
   JSI_HOST_FUNCTION(decodeAudioDataSource) {
     auto sourcePath = args[0].getString(runtime).utf8(runtime);
 

package/common/cpp/HostObjects/GainNodeHostObject.h

@@ -19,9 +19,9 @@ class GainNodeHostObject : public AudioNodeHostObject {
 
   JSI_PROPERTY_GETTER(gain) {
     auto gainNode = std::static_pointer_cast<GainNode>(node_);
-    auto gainParam_ =
+    auto gainParam =
         std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
-    return jsi::Object::createFromHostObject(runtime, gainParam_);
+    return jsi::Object::createFromHostObject(runtime, gainParam);
   }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/StretcherNodeHostObject.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioNodeHostObject.h"
+#include "AudioParamHostObject.h"
+#include "StretcherNode.h"
+
+namespace audioapi {
+    using namespace facebook;
+
+    class StretcherNodeHostObject : public AudioNodeHostObject {
+    public:
+        explicit StretcherNodeHostObject(const std::shared_ptr<StretcherNode> &node)
+                : AudioNodeHostObject(node) {
+            addGetters(JSI_EXPORT_PROPERTY_GETTER(StretcherNodeHostObject, rate),
+                       JSI_EXPORT_PROPERTY_GETTER(StretcherNodeHostObject, semitones));
+        }
+
+        JSI_PROPERTY_GETTER(rate) {
+            auto stretcherNode = std::static_pointer_cast<StretcherNode>(node_);
+            auto rateParam =
+                    std::make_shared<AudioParamHostObject>(stretcherNode->getRateParam());
+            return jsi::Object::createFromHostObject(runtime, rateParam);
+        }
+
+        JSI_PROPERTY_GETTER(semitones) {
+            auto stretcherNode = std::static_pointer_cast<StretcherNode>(node_);
+            auto semitonesParam =
+                    std::make_shared<AudioParamHostObject>(stretcherNode->getSemitonesParam());
+            return jsi::Object::createFromHostObject(runtime, semitonesParam);
+        }
+    };
+} // namespace audioapi

package/common/cpp/core/AnalyserNode.cpp

@@ -147,13 +147,13 @@ void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
 }
 
 void AnalyserNode::processNode(
-    audioapi::AudioBus *processingBus,
+    const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   // Analyser should behave like a sniffer node, it should not modify the
   // processingBus but instead copy the data to its own input buffer.
 
   // Down mix the input bus to mono
-  downMixBus_->copy(processingBus);
+  downMixBus_->copy(processingBus.get());
 
   if (vWriteIndex_ + framesToProcess > inputBuffer_->getSize()) {
     auto framesToCopy =

package/common/cpp/core/AnalyserNode.h

@@ -36,7 +36,7 @@ class AnalyserNode : public AudioNode {
   void getByteTimeDomainData(uint8_t *data, int length);
 
  protected:
-  void processNode(AudioBus *processingBus, int framesToProcess) override;
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   int fftSize_;

package/common/cpp/core/AudioBuffer.cpp

@@ -1,4 +1,6 @@
 #include "AudioBuffer.h"
+
+#include <utility>
 #include "AudioArray.h"
 #include "AudioBus.h"
 
@@ -11,8 +13,8 @@ AudioBuffer::AudioBuffer(
   bus_ = std::make_shared<AudioBus>(length, numberOfChannels, sampleRate);
 }
 
-AudioBuffer::AudioBuffer(AudioBus *bus) {
-  bus_ = std::shared_ptr<AudioBus>(bus);
+AudioBuffer::AudioBuffer(std::shared_ptr<AudioBus> bus) {
+  bus_ = std::move(bus);
 }
 
 size_t AudioBuffer::getLength() const {

package/common/cpp/core/AudioBuffer.h

@@ -13,7 +13,7 @@ class AudioBus;
 class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
  public:
   explicit AudioBuffer(int numberOfChannels, size_t length, float sampleRate);
-  explicit AudioBuffer(AudioBus *bus);
+  explicit AudioBuffer(std::shared_ptr<AudioBus> bus);
 
   [[nodiscard]] size_t getLength() const;
   [[nodiscard]] float getSampleRate() const;

package/common/cpp/core/AudioBufferSourceNode.cpp

@@ -117,7 +117,7 @@ std::mutex &AudioBufferSourceNode::getBufferLock() {
 }
 
 void AudioBufferSourceNode::processNode(
-    AudioBus *processingBus,
+    const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   // No audio data to fill, zero the output and return.
   if (!buffer_) {
@@ -158,7 +158,7 @@ void AudioBufferSourceNode::processNode(
  */
 
 void AudioBufferSourceNode::processWithoutInterpolation(
-    AudioBus *processingBus,
+    const std::shared_ptr<AudioBus> &processingBus,
     size_t startOffset,
     size_t offsetLength,
     float playbackRate) {
@@ -216,7 +216,7 @@ void AudioBufferSourceNode::processWithoutInterpolation(
 }
 
 void AudioBufferSourceNode::processWithInterpolation(
-    AudioBus *processingBus,
+    const std::shared_ptr<AudioBus> &processingBus,
     size_t startOffset,
     size_t offsetLength,
     float playbackRate) {

package/common/cpp/core/AudioBufferSourceNode.h

@@ -31,7 +31,7 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
 
  protected:
   std::mutex &getBufferLock();
-  void processNode(AudioBus *processingBus, int framesToProcess) override;
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   // Looping related properties
@@ -57,13 +57,13 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
   double getVirtualEndFrame();
 
   void processWithoutInterpolation(
-      AudioBus *processingBus,
+      const std::shared_ptr<AudioBus>& processingBus,
       size_t startOffset,
       size_t offsetLength,
       float playbackRate);
 
   void processWithInterpolation(
-      AudioBus *processingBus,
+      const std::shared_ptr<AudioBus>& processingBus,
       size_t startOffset,
       size_t offsetLength,
       float playbackRate);

package/common/cpp/core/AudioBus.cpp

@@ -119,6 +119,14 @@ AudioArray *AudioBus::getChannelByType(int channelType) const {
   }
 }
 
+AudioArray &AudioBus::operator[](size_t index) {
+  return *channels_[index];
+}
+
+const AudioArray &AudioBus::operator[](size_t index) const {
+  return *channels_[index];
+}
+
 /**
  * Public interfaces - audio processing and setters
  */

package/common/cpp/core/AudioBus.h

@@ -34,6 +34,9 @@ class AudioBus {
   [[nodiscard]] AudioArray *getChannel(int index) const;
   [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
 
+    AudioArray &operator[](size_t index);
+    const AudioArray &operator[](size_t index) const;
+
   void normalize();
   void scale(float value);
   [[nodiscard]] float maxAbsValue() const;

package/common/cpp/core/AudioContext.cpp

@@ -48,6 +48,16 @@ void AudioContext::close() {
   audioPlayer_->stop();
 }
 
+void AudioContext::resume() {
+  state_ = ContextState::RUNNING;
+  audioPlayer_->resume();
+}
+
+void AudioContext::suspend() {
+  state_ = ContextState::SUSPENDED;
+  audioPlayer_->suspend();
+}
+
 std::function<void(std::shared_ptr<AudioBus>, int)>
 AudioContext::renderAudio() {
   if (!isRunning() || !destination_) {

package/common/cpp/core/AudioContext.h

@@ -19,6 +19,8 @@ class AudioContext : public BaseAudioContext {
   ~AudioContext() override;
 
   void close();
+  void resume();
+  void suspend();
 
  private:
 #ifdef ANDROID

package/common/cpp/core/AudioDecoder.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <string>
 
 namespace audioapi {
@@ -10,7 +11,7 @@ class AudioDecoder {
  public:
   explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
 
-  [[nodiscard]] AudioBus *decodeWithFilePath(const std::string &path) const;
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithFilePath(const std::string &path) const;
 
  private:
   float sampleRate_;

package/common/cpp/core/AudioDestinationNode.cpp

@@ -33,7 +33,7 @@ void AudioDestinationNode::renderAudio(
 
   destinationBus->zero();
 
-  auto processedBus = processAudio(destinationBus, numFrames);
+  auto processedBus = processAudio(destinationBus, numFrames, true);
 
   if (processedBus && processedBus != destinationBus) {
     destinationBus->copy(processedBus.get());

package/common/cpp/core/AudioDestinationNode.h

@@ -24,7 +24,7 @@ class AudioDestinationNode : public AudioNode {
  protected:
   // DestinationNode is triggered by AudioContext using renderAudio
   // processNode function is not necessary and is never called.
-  void processNode(AudioBus *, int) final {};
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int) final {};
 
  private:
   std::size_t currentSampleFrame_;