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

package/README.md

@@ -1,43 +1,56 @@
 <img src="./assets/react-native-audio-api-gh-cover.png?v0.0.1" alt="React Native Audio API" width="100%">
 
-### React Native Audio API
+### High-performance audio engine for React Native based on web audio api specification
+
+[![NPM latest](https://img.shields.io/npm/v/react-native-audio-api/latest)](https://www.npmjs.com/package/react-native-audio-api)
+[![NPM next](https://img.shields.io/npm/v/react-native-audio-api/next)](https://www.npmjs.com/package/react-native-audio-api?activeTab=versions)
+[![github ci](https://img.shields.io/github/actions/workflow/status/software-mansion/react-native-audio-api/ci.yml)](https://github.com/software-mansion/react-native-audio-api/actions)
 
 `react-native-audio-api` provides system for controlling audio in React Native environment compatible with Web Audio API specification,
 allowing developers to generate and modify audio in exact same way it is possible in browsers.
 
 ## Installation
 
-1. Install `react-native-audio-api` library
+check out the [Getting Started](https://docs.swmansion.com/react-native-audio-api/fundamentals/getting-started) section of our documentation for detailed instructions!
 
-   ```bash
-   # using npm
-   npm install react-native-audio-api
+## Roadmap
 
-   # or using yarn
-   yarn add react-native-audio-api
-   ```
+- <sub>[![Released in 0.1.0](https://img.shields.io/badge/Released_in-0.1.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.1.0)</sub> **Sound synthesis and system audio** 🐣 <br />
+  Access to devices audio engines and threads, basic nodes for sound synthesis, simple effects and audio graph implementation
+  <br />
 
-## Usage with expo
+- <sub>[![Released in 0.2.0](https://img.shields.io/badge/Released_in-0.2.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.2.0)</sub> **Graph Processing** 🛎️ <br />
+  Support for multi-channel audio processing, audio-graph route optimizations, improved react-native layer for managing audio nodes
+  <br />
+- <sub>[![Released in 0.3.2](https://img.shields.io/badge/Released_in-0.3.2-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.3.2)</sub> **Audio Files** 🎸 <br />
+  Support for local and remote audio file resources: MP3, WAV, FLAC.
+  <br />
 
-`react-native-audio-api` contains native custom code and isn't part of the Expo Go application. In order to be available in expo managed builds, you have to use Expo development build. Simplest way on starting local expo dev builds, is to use:
+- <sub>[![Released in 0.4.0](https://img.shields.io/badge/Released_in-0.4.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.4.0)</sub> **Analyser Node** 🌊 <br />
+  Ability to draw, animate or simply debug audio data in time or frequency domain.
+  <br />
 
-  ```bash
-    # Build native iOS project
-    npx expo run:ios
-    # Build native Android project
-    npx expo run:android
-  ```
+- <sub>[![Released in 0.5.0](https://img.shields.io/badge/Released_in-0.5.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.5.0)</sub> **Pitch correction, extending the web** 💥 <br />
+  Ability to modify playback speed without affecting pitch of the sound
+  <br />
 
-To learn more about expo development builds, please check out [Development Builds Documentation](https://docs.expo.dev/develop/development-builds/introduction/).
+- <sub>![Coming in 0.6.0](https://img.shields.io/badge/Coming_in-0.6.0-blue)</sub> **System configuration** 🛠️ <br />
+  Full control of system audio settings, remote controls, lock screen integration and most importantly configurable background modes
+  <br />
 
-## Documentation
+- **Microphone support** 🎙️ <br />
+  Grab audio data from device microphone or connected device, connect it to the audio graph or stream through the internet
+  <br />
 
-Check out our dedicated documentation page for info about this library, API reference and more:
-[https://software-mansion.github.io/react-native-audio-api/](https://software-mansion.github.io/react-native-audio-api/)
+- **Connect audio param** 🤞 <br />
+  Ability to connect Audio nodes to audio params, which will allow for powerful and efficient modulation of audio parameters, creating effects like tremolo, vibrato or complex envelope followers.
+  <br />
 
-You can also check out [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API) for fully detailed description of the audio api.
+- **JS Audio Worklets** 🐎 <br />
+  Ability to run JS functions connected to the audio graph running on audio thread allowing for full customization of what happens to the audio signal.
+  <br />
 
-## Coverage
+## Web Audio API Specification Coverage
 
 Our current coverage of Web Audio API specification can be found here: [Web Audio API coverage](https://software-mansion.github.io/react-native-audio-api/other/web-audio-api-coverage).
 

package/android/CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.12.0)
 project(react-native-audio-api)
 
 set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_CXX_STANDARD 20)
 
 # Detect the processor and SIMD support
@@ -14,9 +15,11 @@ endif()
 include("${REACT_NATIVE_DIR}/ReactAndroid/cmake-utils/folly-flags.cmake")
 add_compile_options(${folly_FLAGS})
 
-# string(APPEND CMAKE_CXX_FLAGS
-#        " -fexceptions -fno-omit-frame-pointer -frtti -fstack-protector-all\
-#    -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
+# frtti - enable Run-Time Type Information (dynamic_cast, typeid)
+# -std=c++20 - use C++20 standard
+# -Wall - enable all compiler's warning messages
+string(APPEND CMAKE_CXX_FLAGS
+       " -frtti -std=c++${CMAKE_CXX_STANDARD} -Wall")
 
 if(${IS_NEW_ARCHITECTURE_ENABLED})
   string(APPEND CMAKE_CXX_FLAGS " -DRCT_NEW_ARCH_ENABLED")

package/android/build.gradle

@@ -218,6 +218,7 @@ dependencies {
   implementation 'androidx.core:core-ktx:1.13.1'
   implementation 'com.facebook.fbjni:fbjni:0.6.0'
   implementation 'com.google.oboe:oboe:1.9.0'
+  implementation 'androidx.media:media:1.7.0'
 }
 
 def assertMinimalReactNativeVersion = task assertMinimalReactNativeVersionTask {

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -0,0 +1,73 @@
+#include <audioapi/android/core/AndroidAudioRecorder.h>
+#include <audioapi/core/Constants.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+
+AndroidAudioRecorder::AndroidAudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::function<void(void)> &onError,
+    const std::function<void(void)> &onStatusChange,
+    const std::function<void(std::shared_ptr<AudioBus>, int, double)>
+        &onAudioReady)
+    : AudioRecorder(
+          sampleRate,
+          bufferLength,
+          onError,
+          onStatusChange,
+          onAudioReady) {
+  AudioStreamBuilder builder;
+  builder.setSharingMode(SharingMode::Exclusive)
+      ->setDirection(Direction::Input)
+      ->setFormat(AudioFormat::Float)
+      ->setFormatConversionAllowed(true)
+      ->setPerformanceMode(PerformanceMode::None)
+      ->setChannelCount(1)
+      ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
+      ->setDataCallback(this)
+      ->setSampleRate(static_cast<int>(sampleRate))
+      ->setFramesPerDataCallback(bufferLength)
+      ->openStream(mStream_);
+}
+
+AndroidAudioRecorder::~AndroidAudioRecorder() {
+  AudioRecorder::~AudioRecorder();
+
+  if (mStream_) {
+    mStream_->requestStop();
+    mStream_->close();
+    mStream_.reset();
+  }
+}
+
+void AndroidAudioRecorder::start() {
+  if (mStream_) {
+    mStream_->requestStart();
+  }
+}
+
+void AndroidAudioRecorder::stop() {
+  if (mStream_) {
+    mStream_->requestStop();
+  }
+}
+
+DataCallbackResult AndroidAudioRecorder::onAudioReady(
+    oboe::AudioStream *oboeStream,
+    void *audioData,
+    int32_t numFrames) {
+  auto buffer = static_cast<float *>(audioData);
+
+  auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
+  memcpy(bus->getChannel(0)->getData(), buffer, numFrames * sizeof(float));
+  auto when = static_cast<double>(
+      oboeStream->getTimestamp(CLOCK_MONOTONIC).value().timestamp);
+
+  onAudioReady_(bus, numFrames, when);
+
+  return DataCallbackResult::Continue;
+}
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <audioapi/core/inputs/AudioRecorder.h>
+
+#include <oboe/Oboe.h>
+#include <functional>
+#include <memory>
+
+namespace audioapi {
+
+using namespace oboe;
+
+class AudioBus;
+
+class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorder {
+ public:
+    AndroidAudioRecorder(float sampleRate,
+                         int bufferLength,
+                         const std::function<void(void)> &onError,
+                         const std::function<void(void)> &onStatusChange,
+                         const std::function<void(std::shared_ptr<AudioBus>, int, double)> &onAudioReady);
+
+    ~AndroidAudioRecorder() override;
+
+    void start() override;
+    void stop() override;
+
+    DataCallbackResult onAudioReady(
+            AudioStream *oboeStream,
+            void *audioData,
+            int32_t numFrames) override;
+
+ private:
+    std::shared_ptr<AudioStream> mStream_;
+};
+
+} // namespace audioapi

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

@@ -27,11 +27,13 @@ AudioPlayer::AudioPlayer(
   isInitialized_ = true;
 }
 
-float AudioPlayer::getSampleRate() const {
-  return sampleRate_;
+void AudioPlayer::start() {
+  if (mStream_) {
+    mStream_->requestStart();
+  }
 }
 
-void AudioPlayer::start() {
+void AudioPlayer::resume() {
   if (mStream_) {
     mStream_->requestStart();
   }
@@ -47,13 +49,7 @@ void AudioPlayer::stop() {
   }
 }
 
-void AudioPlayer::resume() {
-  if (mStream_) {
-    mStream_->requestStart();
-  }
-}
-
-void AudioPlayer::suspend() {
+void AudioPlayer::pause() {
   if (mStream_) {
     mStream_->requestPause();
   }

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

@@ -18,11 +18,10 @@ class AudioPlayer : public AudioStreamDataCallback {
       const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
       float sampleRate);
 
-  [[nodiscard]] float getSampleRate() const;
   void start();
-  void stop();
   void resume();
-  void suspend();
+  void stop();
+  void pause();
 
   DataCallbackResult onAudioReady(
       AudioStream *oboeStream,

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

@@ -1,12 +1,11 @@
 package com.swmansion.audioapi
 
-import android.content.Context
-import android.media.AudioManager
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.swmansion.audioapi.system.MediaSessionManager
 
 class AudioManagerModule(
   reactContext: ReactApplicationContext,
@@ -15,45 +14,51 @@ class AudioManagerModule(
     const val NAME = "AudioManagerModule"
   }
 
-  private val audioManager: AudioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-
   init {
     try {
       System.loadLibrary("react-native-audio-api")
     } catch (exception: UnsatisfiedLinkError) {
       throw RuntimeException("Could not load native module AudioAPIModule", exception)
     }
+
+    MediaSessionManager.initialize(reactContext)
   }
 
-  @ReactMethod
+  @ReactMethod(isBlockingSynchronousMethod = true)
   fun setLockScreenInfo(info: ReadableMap?) {
+    MediaSessionManager.setLockScreenInfo(info)
   }
 
-  @ReactMethod
+  @ReactMethod(isBlockingSynchronousMethod = true)
   fun resetLockScreenInfo() {
+    MediaSessionManager.resetLockScreenInfo()
   }
 
-  @ReactMethod
+  @ReactMethod(isBlockingSynchronousMethod = true)
   fun enableRemoteCommand(
-    name: String?,
+    name: String,
     enabled: Boolean,
   ) {
+    MediaSessionManager.enableRemoteCommand(name, enabled)
   }
 
-  @ReactMethod
+  @ReactMethod(isBlockingSynchronousMethod = true)
   fun setAudioSessionOptions(
     category: String?,
     mode: String?,
     options: ReadableArray?,
-    active: Boolean,
   ) {
+    // Nothing to do here
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
-  fun getDevicePreferredSampleRate(): Double {
-    val sampleRate = this.audioManager.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE)
-    return sampleRate.toDouble()
-  }
+  fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun observeAudioInterruptions(enable: Boolean) = MediaSessionManager.observeAudioInterruptions(enable)
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun observeVolumeChanges(enable: Boolean) = MediaSessionManager.observeVolumeChanges(enable)
 
   override fun getName(): String = NAME
 }

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

@@ -0,0 +1,60 @@
+package com.swmansion.audioapi.system
+
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+import android.util.Log
+
+class AudioFocusListener(
+  private val audioManager: AudioManager,
+  val eventEmitter: MediaSessionEventEmitter,
+  private val lockScreenManager: LockScreenManager,
+) : AudioManager.OnAudioFocusChangeListener {
+  private var playOnAudioFocus = false
+  private var focusRequest: AudioFocusRequest? = null
+
+  override fun onAudioFocusChange(focusChange: Int) {
+    Log.d("AudioFocusListener", "onAudioFocusChange: $focusChange")
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_LOSS -> {
+        playOnAudioFocus = false
+        eventEmitter.onInterruption(mapOf("type" to "began", "shouldResume" to false))
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        playOnAudioFocus = lockScreenManager.isPlaying
+        eventEmitter.onInterruption(mapOf("type" to "began", "shouldResume" to playOnAudioFocus))
+      }
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        if (playOnAudioFocus) {
+          eventEmitter.onInterruption(mapOf("type" to "ended", "shouldResume" to true))
+        } else {
+          eventEmitter.onInterruption(mapOf("type" to "ended", "shouldResume" to false))
+        }
+
+        playOnAudioFocus = false
+      }
+    }
+  }
+
+  fun requestAudioFocus() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      this.focusRequest =
+        AudioFocusRequest
+          .Builder(AudioManager.AUDIOFOCUS_GAIN)
+          .setOnAudioFocusChangeListener(this)
+          .build()
+
+      audioManager.requestAudioFocus(focusRequest!!)
+    } else {
+      audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
+    }
+  }
+
+  fun abandonAudioFocus() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && this.focusRequest != null) {
+      audioManager.abandonAudioFocusRequest(focusRequest!!)
+    } else {
+      audioManager.abandonAudioFocus(this)
+    }
+  }
+}