nosnia-audio-recorder 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Parth Thakkar
+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/NosniaAudioRecorder.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NosniaAudioRecorder"
+  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 }
+  s.source       = { :git => "https://nosnia.ai.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,175 @@
+# nosnia-audio-recorder
+
+A compact, high-performance audio recorder library for React Native that records directly to MP3 (M4A/AAC) format on both Android and iOS.
+
+## Features
+
+- 🎙️ **Direct MP3 Recording**: Records audio directly to M4A (AAC codec)
+- 📱 **Cross-Platform**: Works seamlessly on Android and iOS
+- 🎚️ **Configurable**: Adjust bitrate, sample rate, and channels
+- ⏸️ **Pause/Resume**: Full control over recording with pause and resume
+- 🔒 **Permission Handling**: Built-in permission checking and requesting
+- 💾 **File Management**: Automatic file naming and directory management
+- 📦 **Compact**: Minimal dependencies, optimized for bundle size
+
+## Installation
+
+```sh
+npm install nosnia-audio-recorder
+# or
+yarn add nosnia-audio-recorder
+```
+
+## Quick Start
+
+### Request Permission
+
+```js
+import { NosniaAudioRecorder } from 'nosnia-audio-recorder';
+
+// Request microphone permission
+const hasPermission = await NosniaAudioRecorder.requestPermission();
+```
+
+### Record Audio
+
+```js
+// Start recording
+await NosniaAudioRecorder.startRecording({
+  bitrate: 128000,
+  channels: 1,
+  sampleRate: 44100,
+});
+
+// ... recording in progress ...
+
+// Stop and save
+const filePath = await NosniaAudioRecorder.stopRecording();
+console.log('Recording saved to:', filePath);
+```
+
+### Full Example
+
+```js
+import { NosniaAudioRecorder } from 'nosnia-audio-recorder';
+
+// Check and request permission
+const hasPermission = await NosniaAudioRecorder.checkPermission();
+if (!hasPermission) {
+  await NosniaAudioRecorder.requestPermission();
+}
+
+// Start recording
+await NosniaAudioRecorder.startRecording();
+
+// Pause if needed
+await NosniaAudioRecorder.pauseRecording();
+await NosniaAudioRecorder.resumeRecording();
+
+// Get status
+const status = await NosniaAudioRecorder.getStatus();
+console.log(`Recording: ${status.isRecording}, Duration: ${status.duration}ms`);
+
+// Stop and save
+const filePath = await NosniaAudioRecorder.stopRecording();
+
+// Or cancel (discard)
+await NosniaAudioRecorder.cancelRecording();
+```
+
+## API Reference
+
+### Methods
+
+- `requestPermission(): Promise<boolean>` - Request microphone permission
+- `checkPermission(): Promise<boolean>` - Check if permission is granted
+- `startRecording(options?: RecorderOptions): Promise<void>` - Start recording
+- `stopRecording(): Promise<string>` - Stop and save (returns file path)
+- `pauseRecording(): Promise<void>` - Pause recording
+- `resumeRecording(): Promise<void>` - Resume recording
+- `cancelRecording(): Promise<void>` - Cancel and discard
+- `getStatus(): Promise<RecorderStatus>` - Get recorder status
+
+### Types
+
+```ts
+interface RecorderOptions {
+  filename?: string;      // Auto-generated if not provided
+  bitrate?: number;       // Default: 128000 (128 kbps)
+  channels?: number;      // 1 = mono (default), 2 = stereo
+  sampleRate?: number;    // Default: 44100 (44.1 kHz)
+}
+
+interface RecorderStatus {
+  isRecording: boolean;
+  duration: number;           // In milliseconds
+  currentFilePath?: string;
+}
+```
+
+## Platform Setup
+
+### Android
+
+Add permission to `android/app/src/main/AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+```
+
+### iOS
+
+Add microphone permission to `ios/[AppName]/Info.plist`:
+
+```xml
+<key>NSMicrophoneUsageDescription</key>
+<string>This app needs access to your microphone to record audio.</string>
+```
+
+## Configuration
+
+### Default Settings
+
+| Setting | Value |
+|---------|-------|
+| Format | M4A (AAC Codec) |
+| Bitrate | 128 kbps |
+| Sample Rate | 44.1 kHz |
+| Channels | 1 (Mono) |
+
+### Recommended Settings
+
+- **Speech**: 64 kbps, 16 kHz, mono
+- **Music**: 192-320 kbps, 44.1-48 kHz, stereo
+- **Balanced**: 128 kbps, 44.1 kHz, mono
+
+## File Locations
+
+- **Android**: `Documents/NosniaAudioRecorder/` (API 29+) or `Music/NosniaAudioRecorder/`
+- **iOS**: `Documents/NosniaAudioRecorder/`
+
+## Performance
+
+- Lightweight native implementation
+- Minimal memory footprint
+- Direct encoding to M4A format
+- Efficient file handling
+
+## More Documentation
+
+For detailed usage guide, see [USAGE.md](USAGE.md)
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+

package/android/build.gradle

@@ -0,0 +1,77 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['NosniaAudioRecorder_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NosniaAudioRecorder_" + name]).toInteger()
+}
+
+android {
+  namespace "com.nosniaaudiorecorder"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NosniaAudioRecorder_kotlinVersion=2.0.21
+NosniaAudioRecorder_minSdkVersion=24
+NosniaAudioRecorder_targetSdkVersion=34
+NosniaAudioRecorder_compileSdkVersion=35
+NosniaAudioRecorder_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+</manifest>

package/android/src/main/java/com/nosniaaudiorecorder/NosniaAudioRecorderModule.kt

@@ -0,0 +1,232 @@
+package com.nosniaaudiorecorder
+
+import android.Manifest
+import android.content.Context
+import android.media.MediaRecorder
+import android.os.Build
+import android.os.Environment
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.module.annotations.ReactModule
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+@ReactModule(name = NosniaAudioRecorderModule.NAME)
+class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
+  NativeNosniaAudioRecorderSpec(reactContext) {
+
+  private var mediaRecorder: MediaRecorder? = null
+  private var currentFilePath: String? = null
+  private var isRecording = false
+  private var isPaused = false
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun startRecording(options: ReadableMap, promise: Promise) {
+    try {
+      if (isRecording) {
+        promise.reject("ALREADY_RECORDING", "Recording is already in progress")
+        return
+      }
+
+      val filename = options.getString("filename") ?: generateFilename()
+      val bitrate = options.getInt("bitrate").takeIf { it > 0 } ?: 128000
+      val channels = options.getInt("channels").takeIf { it > 0 } ?: 1
+      val sampleRate = options.getInt("sampleRate").takeIf { it > 0 } ?: 44100
+
+      val recordingDir = getRecordingDirectory()
+      if (!recordingDir.exists()) {
+        recordingDir.mkdirs()
+      }
+
+      currentFilePath = File(recordingDir, filename).absolutePath
+
+      mediaRecorder = (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        MediaRecorder(reactApplicationContext)
+      } else {
+        @Suppress("DEPRECATION")
+        MediaRecorder()
+      }).apply {
+        setAudioSource(MediaRecorder.AudioSource.MIC)
+        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+        setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+        setAudioEncodingBitRate(bitrate)
+        setAudioChannels(channels)
+        setAudioSamplingRate(sampleRate)
+        setOutputFile(currentFilePath)
+        prepare()
+        start()
+      }
+
+      isRecording = true
+      isPaused = false
+      promise.resolve(null)
+    } catch (e: Exception) {
+      mediaRecorder?.release()
+      mediaRecorder = null
+      isRecording = false
+      promise.reject("START_RECORDING_ERROR", e.message, e)
+    }
+  }
+
+  override fun stopRecording(promise: Promise) {
+    try {
+      if (!isRecording && mediaRecorder == null) {
+        promise.reject("NOT_RECORDING", "No recording in progress")
+        return
+      }
+
+      mediaRecorder?.apply {
+        stop()
+        release()
+      }
+      mediaRecorder = null
+      isRecording = false
+      isPaused = false
+
+      val filePath = currentFilePath ?: ""
+      currentFilePath = null
+      promise.resolve(filePath)
+    } catch (e: Exception) {
+      mediaRecorder?.release()
+      mediaRecorder = null
+      isRecording = false
+      promise.reject("STOP_RECORDING_ERROR", e.message, e)
+    }
+  }
+
+  override fun pauseRecording(promise: Promise) {
+    try {
+      if (!isRecording) {
+        promise.reject("NOT_RECORDING", "No recording in progress")
+        return
+      }
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        mediaRecorder?.pause()
+        isPaused = true
+        promise.resolve(null)
+      } else {
+        promise.reject("NOT_SUPPORTED", "Pause is not supported on this API level")
+      }
+    } catch (e: Exception) {
+      promise.reject("PAUSE_ERROR", e.message, e)
+    }
+  }
+
+  override fun resumeRecording(promise: Promise) {
+    try {
+      if (!isRecording || !isPaused) {
+        promise.reject("NOT_PAUSED", "Recording is not paused")
+        return
+      }
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        mediaRecorder?.resume()
+        isPaused = false
+        promise.resolve(null)
+      } else {
+        promise.reject("NOT_SUPPORTED", "Resume is not supported on this API level")
+      }
+    } catch (e: Exception) {
+      promise.reject("RESUME_ERROR", e.message, e)
+    }
+  }
+
+  override fun cancelRecording(promise: Promise) {
+    try {
+      mediaRecorder?.apply {
+        try {
+          stop()
+        } catch (e: Exception) {
+          // Might throw if already stopped
+        }
+        release()
+      }
+      mediaRecorder = null
+
+      currentFilePath?.let { filePath ->
+        File(filePath).delete()
+      }
+      currentFilePath = null
+      isRecording = false
+      isPaused = false
+
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("CANCEL_ERROR", e.message, e)
+    }
+  }
+
+  override fun getRecorderStatus(promise: Promise) {
+    try {
+      val status = WritableNativeMap().apply {
+        putBoolean("isRecording", isRecording)
+        putDouble("duration", mediaRecorder?.currentPosition?.toDouble() ?: 0.0)
+        if (currentFilePath != null) {
+          putString("currentFilePath", currentFilePath)
+        }
+      }
+      promise.resolve(status)
+    } catch (e: Exception) {
+      promise.reject("STATUS_ERROR", e.message, e)
+    }
+  }
+
+  override fun requestAudioPermission(promise: Promise) {
+    try {
+      val permission = Manifest.permission.RECORD_AUDIO
+      val hasPermission = ContextCompat.checkSelfPermission(
+        reactApplicationContext,
+        permission
+      ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+
+      promise.resolve(hasPermission)
+    } catch (e: Exception) {
+      promise.reject("PERMISSION_ERROR", e.message, e)
+    }
+  }
+
+  override fun checkAudioPermission(promise: Promise) {
+    try {
+      val permission = Manifest.permission.RECORD_AUDIO
+      val hasPermission = ContextCompat.checkSelfPermission(
+        reactApplicationContext,
+        permission
+      ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+
+      promise.resolve(hasPermission)
+    } catch (e: Exception) {
+      promise.reject("PERMISSION_ERROR", e.message, e)
+    }
+  }
+
+  private fun getRecordingDirectory(): File {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      File(reactApplicationContext.getExternalFilesDir(null), "recordings")
+    } else {
+      @Suppress("DEPRECATION")
+      File(
+        Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC),
+        "NosniaAudioRecorder"
+      )
+    }
+  }
+
+  private fun generateFilename(): String {
+    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+    return "recording_$timestamp.m4a"
+  }
+
+  companion object {
+    const val NAME = "NosniaAudioRecorder"
+  }
+}

package/android/src/main/java/com/nosniaaudiorecorder/NosniaAudioRecorderPackage.kt

@@ -0,0 +1,33 @@
+package com.nosniaaudiorecorder
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class NosniaAudioRecorderPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == NosniaAudioRecorderModule.NAME) {
+      NosniaAudioRecorderModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[NosniaAudioRecorderModule.NAME] = ReactModuleInfo(
+        NosniaAudioRecorderModule.NAME,
+        NosniaAudioRecorderModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/NosniaAudioRecorder.h

@@ -0,0 +1,6 @@
+#import <NosniaAudioRecorderSpec/NosniaAudioRecorderSpec.h>
+#import <React/RCTBridgeModule.h>
+
+@interface NosniaAudioRecorder : NSObject <NativeNosniaAudioRecorderSpec>
+
+@end