react-native-nitro-audio-record 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iwater
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NitroAudioRecord.podspec

@@ -0,0 +1,33 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroAudioRecord"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/iwater/react-native-nitro-audio-record.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  load 'nitrogen/generated/ios/NitroAudioRecord+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.frameworks = 'AVFoundation', 'AudioToolbox'
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,92 @@
+# react-native-nitro-audio-record
+
+A high-performance audio recording library for React Native powered by **Nitro Modules**.
+
+## Relationship with `react-native-audio-record`
+
+This library is a **modernized, high-performance successor** to the original [react-native-audio-record](https://github.com/goodatlas/react-native-audio-record). 
+
+While it provides similar functionality, it has been completely rewritten to leverage the **New React Native Architecture** and **Nitro Modules** for zero-copy JSI communication. It is designed to be faster, type-safe, and future-proof.
+
+- **Turbo Performance**: Zero-copy data transfer using JSI `ArrayBuffer`.
+- **Modern Architecture**: Built for the new React Native architecture (TurboModules/Fabric).
+- **TypeScript First**: Fully type-safe API.
+- **Real-time Streaming**: Get audio chunks as they are recorded.
+
+## Use Cases
+
+- **Real-time Speech Recognition**: Stream PCM buffers directly to APIs like Google Cloud Speech-to-Text, OpenAI Whisper, or Deepgram.
+- **Audio Visualization**: Draw real-time waveforms or frequency spectrums using the zero-copy `ArrayBuffer`.
+- **Custom Audio Processing**: Apply Noise Suppression, Gain Control, or other DSP algorithms in JavaScript or C++.
+- **Accurate Audio Scoring (GOP)**: High-fidelity audio capture for language learning apps that require precise PCM data.
+- **Low-Latency VOIP**: Lightweight recording for real-time communication.
+
+## Installation
+
+```sh
+npm install react-native-nitro-audio-record react-native-nitro-modules
+npx pod-install
+```
+
+## Usage
+
+```typescript
+import { NitroAudioRecord } from 'react-native-nitro-audio-record';
+
+// Initialize with options
+NitroAudioRecord.setup({
+  sampleRate: 16000,  // default 44100
+  channels: 1,        // 1 or 2
+  bitsPerSample: 16,  // 8 or 16
+  wavFile: 'test.wav' // saved in document directory
+});
+
+// Listen for real-time audio data (ArrayBuffer)
+NitroAudioRecord.onData((data: ArrayBuffer) => {
+  // Direct zero-copy access to PCM data
+  console.log('Chunk size:', data.byteLength);
+});
+
+// Start recording
+NitroAudioRecord.start();
+
+// Stop recording and get the file path
+const audioFile = await NitroAudioRecord.stop();
+console.log('Saved to:', audioFile);
+```
+
+## Migration from `react-native-audio-record`
+
+If you are coming from the original `react-native-audio-record`, here are the key changes:
+
+| Field | original `react-native-audio-record` | `react-native-nitro-audio-record` |
+| --- | --- | --- |
+| **Import** | `import AudioRecord from '...'` | `import { NitroAudioRecord } from '...'` |
+| **Initialization** | `AudioRecord.init(options)` | `NitroAudioRecord.setup(options)` |
+| **Real-time Data** | Event Listener (`.on('data', ...)`) | Callback (`.onData(...)`) |
+| **Data Format** | Base64 String | `ArrayBuffer` (Fast JSI) |
+| **New Arch** | Bridge (Bridge-based) | Nitro (New Arch / JSI) |
+
+### Code Example (Before vs After)
+
+**Before:**
+```javascript
+import AudioRecord from 'react-native-audio-record';
+AudioRecord.init(options);
+AudioRecord.on('data', base64Data => {
+  const buffer = Buffer.from(base64Data, 'base64');
+});
+```
+
+**After:**
+```typescript
+import { NitroAudioRecord } from 'react-native-nitro-audio-record';
+NitroAudioRecord.setup(options);
+NitroAudioRecord.onData(arrayBuffer => {
+  // Use arrayBuffer directly without decoding!
+});
+```
+
+## License
+
+MIT

package/android/CMakeLists.txt

@@ -0,0 +1,32 @@
+project(NitroAudioRecord)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME NitroAudioRecord)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_compile_options(-DRN_SERIALIZABLE_STATE=1)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroAudioRecord+autolinking.cmake)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
+)
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android                                   # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,148 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.8.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroAudioRecord+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroAudioRecord_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroAudioRecord_" + name]).toInteger()
+}
+
+android {
+  namespace "com.nitroaudiorecord"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+        "META-INF",
+        "META-INF/**",
+        "**/libc++_shared.so",
+        "**/libfbjni.so",
+        "**/libjsi.so",
+        "**/libfolly_json.so",
+        "**/libfolly_runtime.so",
+        "**/libglog.so",
+        "**/libhermes.so",
+        "**/libhermes-executor-debug.so",
+        "**/libhermes_executor.so",
+        "**/libreactnative.so",
+        "**/libreactnativejni.so",
+        "**/libturbomodulejsijni.so",
+        "**/libreact_nativemodule_core.so",
+        "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "NitroAudioRecord"
+    codegenJavaPackageName = "com.nitroaudiorecord"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroAudioRecord_kotlinVersion=2.1.20
+NitroAudioRecord_minSdkVersion=23
+NitroAudioRecord_targetSdkVersion=35
+NitroAudioRecord_compileSdkVersion=34
+NitroAudioRecord_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "NitroAudioRecordOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::nitroaudiorecord::registerAllNatives();
+  });
+}

package/android/src/main/java/com/nitroaudiorecord/HybridNitroAudioRecord.kt

@@ -0,0 +1,189 @@
+package com.nitroaudiorecord
+
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaRecorder.AudioSource
+import android.util.Log
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.nitroaudiorecord.AudioRecordOptions
+import com.margelo.nitro.nitroaudiorecord.HybridNitroAudioRecordSpec
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.nio.ByteBuffer
+
+class HybridNitroAudioRecord : HybridNitroAudioRecordSpec() {
+    private val TAG = "NitroAudioRecord"
+
+    private var sampleRateInHz = 44100
+    private var channelConfig = AudioFormat.CHANNEL_IN_MONO
+    private var audioFormat = AudioFormat.ENCODING_PCM_16BIT
+    private var audioSource = AudioSource.VOICE_RECOGNITION
+
+    private var recorder: AudioRecord? = null
+    private var bufferSize = 0
+    private var isRecording = false
+
+    private lateinit var tmpFile: String
+    private lateinit var outFile: String
+    
+    private var onDataCallback: ((data: ArrayBuffer) -> Unit)? = null
+
+    override fun setup(options: AudioRecordOptions) {
+        sampleRateInHz = options.sampleRate.toInt()
+        channelConfig = if (options.channels == 2L) AudioFormat.CHANNEL_IN_STEREO else AudioFormat.CHANNEL_IN_MONO
+        audioFormat = if (options.bitsPerSample == 8L) AudioFormat.ENCODING_PCM_8BIT else AudioFormat.ENCODING_PCM_16BIT
+        audioSource = (options.audioSource ?: AudioSource.VOICE_RECOGNITION.toDouble()).toInt()
+
+        val context = NitroModules.applicationContext
+        val documentDirectoryPath = context.filesDir.absolutePath
+        outFile = "$documentDirectoryPath/${options.wavFile ?: "audio.wav"}"
+        tmpFile = "$documentDirectoryPath/temp.pcm"
+
+        isRecording = false
+        bufferSize = AudioRecord.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat)
+        val recordingBufferSize = bufferSize * 3
+        recorder = AudioRecord(audioSource, sampleRateInHz, channelConfig, audioFormat, recordingBufferSize)
+    }
+
+    override fun start() {
+        if (isRecording) return
+        
+        isRecording = true
+        recorder?.startRecording()
+        Log.d(TAG, "started recording")
+
+        Thread {
+            try {
+                var bytesRead: Int
+                var count = 0
+                val buffer = ByteArray(bufferSize)
+                val os = FileOutputStream(tmpFile)
+
+                while (isRecording) {
+                    bytesRead = recorder?.read(buffer, 0, buffer.length) ?: -1
+
+                    // skip first 2 buffers to eliminate "click sound"
+                    if (bytesRead > 0 && ++count > 2) {
+                        // Create ArrayBuffer and notify callback
+                        onDataCallback?.let { callback ->
+                            val byteBuffer = ByteBuffer.allocateDirect(bytesRead)
+                            byteBuffer.put(buffer, 0, bytesRead)
+                            val arrayBuffer = ArrayBuffer.wrap(byteBuffer)
+                            callback(arrayBuffer)
+                        }
+                        os.write(buffer, 0, bytesRead)
+                    }
+                }
+
+                recorder?.stop()
+                os.close()
+                saveAsWav()
+            } catch (e: Exception) {
+                Log.e(TAG, "Error during recording", e)
+            }
+        }.start()
+    }
+
+    override fun stop(): Promise<String> {
+        isRecording = false
+        return Promise { resolve ->
+            // In a real implementation, we might need a better way to wait for the thread to finish
+            // such as using a CountDownLatch or joining the thread.
+            // For now, we'll wait a bit (simplistic).
+            Thread {
+                Thread.sleep(100)
+                resolve(outFile)
+            }.start()
+        }
+    }
+
+    override fun onData(callback: (data: ArrayBuffer) -> Unit) {
+        onDataCallback = callback
+    }
+
+    private fun saveAsWav() {
+        try {
+            val fileIn = File(tmpFile)
+            val `in` = FileInputStream(fileIn)
+            val out = FileOutputStream(outFile)
+            val totalAudioLen = fileIn.length()
+            val totalDataLen = totalAudioLen + 36
+
+            addWavHeader(out, totalAudioLen, totalDataLen)
+
+            val data = ByteArray(bufferSize)
+            var bytesRead: Int
+            while (`in`.read(data).also { bytesRead = it } != -1) {
+                out.write(data, 0, bytesRead)
+            }
+            Log.d(TAG, "file saved at path: $outFile")
+
+            `in`.close()
+            out.close()
+            fileIn.delete()
+        } catch (e: Exception) {
+            Log.e(TAG, "Error saving as wav", e)
+        }
+    }
+
+    @Throws(Exception::class)
+    private fun addWavHeader(out: FileOutputStream, totalAudioLen: Long, totalDataLen: Long) {
+        val sampleRate = sampleRateInHz.toLong()
+        val channels = if (channelConfig == AudioFormat.CHANNEL_IN_MONO) 1 else 2
+        val bitsPerSample = if (audioFormat == AudioFormat.ENCODING_PCM_8BIT) 8 else 16
+        val byteRate = sampleRate * channels * bitsPerSample / 8
+        val blockAlign = channels * bitsPerSample / 8
+
+        val header = ByteArray(44)
+
+        header[0] = 'R'.toByte()                                    // RIFF chunk
+        header[1] = 'I'.toByte()
+        header[2] = 'F'.toByte()
+        header[3] = 'F'.toByte()
+        header[4] = (totalDataLen and 0xff).toByte()                // how big is the rest of this file
+        header[5] = (totalDataLen shr 8 and 0xff).toByte()
+        header[6] = (totalDataLen shr 16 and 0xff).toByte()
+        header[7] = (totalDataLen shr 24 and 0xff).toByte()
+        header[8] = 'W'.toByte()                                    // WAVE chunk
+        header[9] = 'A'.toByte()
+        header[10] = 'V'.toByte()
+        header[11] = 'E'.toByte()
+        header[12] = 'f'.toByte()                                   // 'fmt ' chunk
+        header[13] = 'm'.toByte()
+        header[14] = 't'.toByte()
+        header[15] = ' '.toByte()
+        header[16] = 16                                             // 4 bytes: size of 'fmt ' chunk
+        header[17] = 0
+        header[18] = 0
+        header[19] = 0
+        header[20] = 1                                              // format = 1 for PCM
+        header[21] = 0
+        header[22] = channels.toByte()                              // mono or stereo
+        header[23] = 0
+        header[24] = (sampleRate and 0xff).toByte()                 // samples per second
+        header[25] = (sampleRate shr 8 and 0xff).toByte()
+        header[26] = (sampleRate shr 16 and 0xff).toByte()
+        header[27] = (sampleRate shr 24 and 0xff).toByte()
+        header[28] = (byteRate and 0xff).toByte()                  // bytes per second
+        header[29] = (byteRate shr 8 and 0xff).toByte()
+        header[30] = (byteRate shr 16 and 0xff).toByte()
+        header[31] = (byteRate shr 24 and 0xff).toByte()
+        header[32] = blockAlign.toByte()                             // bytes in one sample, for all channels
+        header[33] = 0
+        header[34] = bitsPerSample.toByte()                         // bits in a sample
+        header[35] = 0
+        header[36] = 'd'.toByte()                                   // beginning of the data chunk
+        header[37] = 'a'.toByte()
+        header[38] = 't'.toByte()
+        header[39] = 'a'.toByte()
+        header[40] = (totalAudioLen and 0xff).toByte()              // how big is this data chunk
+        header[41] = (totalAudioLen shr 8 and 0xff).toByte()
+        header[42] = (totalAudioLen shr 16 and 0xff).toByte()
+        header[43] = (totalAudioLen shr 24 and 0xff).toByte()
+
+        out.write(header, 0, 44)
+    }
+}

package/android/src/main/java/com/nitroaudiorecord/NitroAudioRecordPackage.kt

@@ -0,0 +1,20 @@
+package com.nitroaudiorecord;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.BaseReactPackage;
+import com.margelo.nitro.nitroaudiorecord.NitroAudioRecordOnLoad;
+
+
+public class NitroAudioRecordPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { emptyMap() }
+
+  companion object {
+    init {
+      NitroAudioRecordOnLoad.initializeNative();
+    }
+  }
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  nitro-audio-record
+//
+//  Created by iwater on 2026/3/25
+//
+
+#pragma once