@techoptio/react-native-live-pitch-detection 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 TechOpt.io
+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/README.md

@@ -0,0 +1,146 @@
+# @techoptio/react-native-live-pitch-detection
+
+Live pitch detection (frequency, note and octave) from device microphone for React Native.
+
+This package was heavily inspired by, but not a direct fork of, https://github.com/rnheroes/react-native-pitchy.
+
+This package uses Turbo Modules and is only compatible with the new architecture.
+
+## Installation
+
+```sh
+npm install @techoptio/react-native-live-pitch-detection
+```
+
+### iOS
+
+For iOS, you'll need to add microphone permission to your `Info.plist`:
+
+```xml
+<key>NSMicrophoneUsageDescription</key>
+<string>This app needs microphone access to detect pitch.</string>
+```
+
+### Android
+
+For Android, you'll need to add microphone permission to your `AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+```
+
+## Usage
+
+> **Important:** This library assumes microphone permissions have already been requested and granted before calling `startListening()`. Make sure to request permissions using a library like [`react-native-permissions`](https://github.com/zoontek/react-native-permissions) before using this library.
+
+```tsx
+import PitchDetection from '@techoptio/react-native-live-pitch-detection';
+import { request, PERMISSIONS, RESULTS } from 'react-native-permissions';
+import { Platform } from 'react-native';
+
+// Request microphone permission first
+const permission = Platform.OS === 'ios'
+  ? PERMISSIONS.IOS.MICROPHONE
+  : PERMISSIONS.ANDROID.RECORD_AUDIO;
+
+const result = await request(permission);
+
+if (result === RESULTS.GRANTED) {
+  // Configure options (optional) - should be called while not listening
+  PitchDetection.setOptions({
+    bufferSize: 4096,        // Audio buffer size (default: 4096)
+    minVolume: -20.0,        // Minimum volume threshold in dB (default: -20.0)
+    updateIntervalMs: 100,   // Update interval in milliseconds (default: 100)
+    a4Frequency: 440,        // A4 note frequency in Hz (default: 440)
+  });
+
+  // Start listening
+  await PitchDetection.startListening();
+
+  // Add listener for pitch events
+  const subscription = PitchDetection.addListener((event) => {
+    console.log('Frequency:', event.frequency);
+    console.log('Note:', event.note); // e.g., "C4", "A#3", etc.
+  });
+
+  // Stop listening when done
+  await PitchDetection.stopListening();
+  subscription.remove();
+}
+```
+
+## API
+
+### Methods
+
+#### `setOptions(options: Options)`
+
+Configure the pitch detection settings. This method is optional, as all parameters have defaults. However, if you want to customize the settings, **call this method while not listening** (i.e., before `startListening()` or after `stopListening()`), otherwise all parameters may not be applied until the next listening session.
+
+**Parameters:**
+- `options.bufferSize?: number` - Audio buffer size (default: 4096)
+- `options.minVolume?: number` - Minimum volume threshold in dB (default: -20.0)
+- `options.updateIntervalMs?: number` - Update interval in milliseconds (default: 100)
+- `options.a4Frequency?: number` - A4 note frequency in Hz (default: 440)
+
+#### `startListening(): Promise<void>`
+
+Starts listening to the microphone for pitch detection.
+
+> **Note:** Ensure microphone permissions have been requested and granted before calling this method.
+
+#### `stopListening(): Promise<void>`
+
+Stops listening to the microphone.
+
+#### `addListener(callback: (event: PitchEvent) => void): EventSubscription`
+
+Adds a listener for pitch detection events. Returns an `EventSubscription` that should be removed when no longer needed.
+
+**Event:**
+```typescript
+type PitchEvent = {
+  frequency: number;  // Detected frequency in Hz
+  note: string;       // Musical note (e.g., "C4", "A#3", "-" if no note detected)
+};
+```
+
+#### `isListening(): boolean`
+
+Returns `true` if currently listening, `false` otherwise.
+
+## Types
+
+```typescript
+type Options = {
+  bufferSize?: number;
+  minVolume?: number;
+  updateIntervalMs?: number;
+  a4Frequency?: number;
+};
+
+type PitchEvent = {
+  frequency: number;
+  note: string;
+};
+```
+
+## Example
+
+Check out the [example app](example/) for a complete working implementation.
+
+![Example App Preview](example/preview.png)
+
+## 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/ReactNativeLivePitchDetection.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeLivePitchDetection"
+  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://github.com/techoptio/react-native-live-pitch-detection.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp}", "shared/**/*.{hpp,cpp,c,h}"
+  s.private_header_files = "ios/**/*.h"
+
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,95 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeLivePitchDetection_' + 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["ReactNativeLivePitchDetection_" + name]).toInteger()
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+android {
+  namespace "io.techopt.lib.reactnativelivepitchdetection"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  externalNativeBuild {
+       cmake {
+           path "src/main/jni/CMakeLists.txt"
+       }
+   }
+
+  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 @@
+ReactNativeLivePitchDetection_kotlinVersion=2.0.21
+ReactNativeLivePitchDetection_minSdkVersion=24
+ReactNativeLivePitchDetection_targetSdkVersion=34
+ReactNativeLivePitchDetection_compileSdkVersion=35
+ReactNativeLivePitchDetection_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/io/techopt/lib/reactnativelivepitchdetection/ReactNativeLivePitchDetectionModule.kt

@@ -0,0 +1,115 @@
+package io.techopt.lib.reactnativelivepitchdetection
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import android.media.AudioRecord
+import android.media.AudioFormat
+import android.media.MediaRecorder
+import com.facebook.react.bridge.Promise
+import kotlin.concurrent.thread
+import android.util.Log
+@ReactModule(name = ReactNativeLivePitchDetectionModule.NAME)
+class ReactNativeLivePitchDetectionModule(reactContext: ReactApplicationContext) :
+  NativeReactNativeLivePitchDetectionSpec(reactContext) {
+
+  private var isListening = false
+
+  private var audioRecord: AudioRecord? = null
+  private var recordingThread: Thread? = null
+  
+  private var sampleRate: Int = 44100
+
+  private var updateIntervalMs: Int = 100
+
+  private var minVolume: Double = -20.0
+  private var bufferSize: Int = 4096
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun isListening(): Boolean {
+    return isListening
+  }
+
+  override fun setOptions(bufferSize: Double, minVolume: Double, updateIntervalMs: Double) {
+    this.minVolume = minVolume
+    this.bufferSize = bufferSize.toInt()
+    this.updateIntervalMs = updateIntervalMs.toInt()
+  }
+
+  override fun startListening(promise: Promise) {
+
+    if (isListening) {
+      promise.reject("E_ALREADY_LISTENING", "Already listening")
+      return
+    }
+
+    audioRecord = AudioRecord(MediaRecorder.AudioSource.MIC, sampleRate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, bufferSize)
+    
+    audioRecord?.startRecording()
+
+    recordingThread = thread(start = true) {
+      val buffer = ShortArray(bufferSize)
+      var lastUpdateTime = System.currentTimeMillis()
+
+      while (isListening) {
+        val currentTime = System.currentTimeMillis()
+
+        if (currentTime - lastUpdateTime >= updateIntervalMs) {
+          val read = audioRecord?.read(buffer, 0, bufferSize)
+
+          if (read != null && read > 0) {
+            detectPitch(buffer)
+            lastUpdateTime = currentTime
+          }
+        }
+      }
+    }
+
+    isListening = true
+
+    promise.resolve(null)
+
+  }
+
+  override fun stopListening(promise: Promise) {
+
+    if (!isListening) {
+      promise.reject("E_NOT_LISTENING", "Not listening")
+      return
+    }
+
+    isListening = false
+    audioRecord?.stop()
+    audioRecord?.release()
+    audioRecord = null
+    recordingThread?.interrupt()
+    recordingThread = null
+    promise.resolve(null)
+  }
+
+  private external fun nativeAutoCorrelate(buffer: ShortArray, sampleRate: Int, minVolume: Double): Double
+
+  private fun detectPitch(buffer: ShortArray) {
+    val frequency = nativeAutoCorrelate(buffer, sampleRate, minVolume)
+
+    val eventData = Arguments.createMap().apply {
+      putDouble("frequency", frequency)
+    }
+    
+    emitOnFrequencyDetected(eventData)
+  }
+
+  companion object {
+    const val NAME = "ReactNativeLivePitchDetection"
+    
+    init {
+      System.loadLibrary("reactnativelivepitchdetection")
+    }
+  }
+}

package/android/src/main/java/io/techopt/lib/reactnativelivepitchdetection/ReactNativeLivePitchDetectionPackage.kt

@@ -0,0 +1,33 @@
+package io.techopt.lib.reactnativelivepitchdetection
+
+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 ReactNativeLivePitchDetectionPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == ReactNativeLivePitchDetectionModule.NAME) {
+      ReactNativeLivePitchDetectionModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[ReactNativeLivePitchDetectionModule.NAME] = ReactModuleInfo(
+        ReactNativeLivePitchDetectionModule.NAME,
+        ReactNativeLivePitchDetectionModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.4.1)
+project(ReactNativeLivePitchDetection)
+
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 14)
+
+add_library(reactnativelivepitchdetection            SHARED
+            ../../../../shared/ReactNativeLivePitchDetectionModule.cpp
+            cpp-adapter.cpp
+)
+
+# Specifies a path to native header files.
+include_directories(
+            ../../../../shared
+)

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

@@ -0,0 +1,22 @@
+// Thanks to rnheroes/react-native-pitchy for the original implementation
+// https://github.com/rnheroes/react-native-pitchy/blob/main/android/cpp-adapter.cpp
+
+#include <jni.h>
+#include "../../../../shared/ReactNativeLivePitchDetectionModule.h"
+#include <vector>
+#include <cmath>
+#include <algorithm>
+#include <numeric>
+#include <limits>
+
+extern "C" JNIEXPORT jdouble JNICALL
+Java_io_techopt_lib_reactnativelivepitchdetection_ReactNativeLivePitchDetectionModule_nativeAutoCorrelate(JNIEnv *env, jobject thiz, jshortArray buffer, jint sampleRate, jdouble minVolume)
+{   
+    jshort *buf = env->GetShortArrayElements(buffer, 0);
+    jsize size = env->GetArrayLength(buffer);
+    std::vector<double> vec(buf, buf + size);
+    env->ReleaseShortArrayElements(buffer, buf, 0);
+
+    double result = techoptio::reactnativelivepitchdetection::autoCorrelate(vec, sampleRate, minVolume);
+    return result;
+}

package/ios/ReactNativeLivePitchDetection.h

@@ -0,0 +1,9 @@
+#ifdef __cplusplus
+#import "ReactNativeLivePitchDetectionModule.h"
+#endif
+
+#import <ReactNativeLivePitchDetectionSpec/ReactNativeLivePitchDetectionSpec.h>
+
+@interface ReactNativeLivePitchDetection : NativeReactNativeLivePitchDetectionSpecBase <NativeReactNativeLivePitchDetectionSpec>
+
+@end

package/ios/ReactNativeLivePitchDetection.mm

@@ -0,0 +1,127 @@
+// ReactNativeLivePitchDetection.mm
+
+#import "ReactNativeLivePitchDetection.h"
+
+#import <AVFoundation/AVFoundation.h>
+#import <QuartzCore/QuartzCore.h>
+
+@implementation ReactNativeLivePitchDetection
+    AVAudioEngine *_audioEngine = nil;
+    double _sampleRate = 44100;
+    double _minVolume = -20.0;
+    AVAudioFrameCount _bufferSize = 4096;
+    int _updateIntervalMs = 100;
+    BOOL _isListening = NO;
+    NSTimeInterval _lastUpdateTime = 0;
+
+- (void)setOptions:(double)bufferSize minVolume:(double)minVolume updateIntervalMs:(double)updateIntervalMs {
+    _minVolume = minVolume;
+    _updateIntervalMs = (int)updateIntervalMs;
+    _bufferSize = (AVAudioFrameCount)bufferSize;
+}
+
+- (NSNumber *)isListening {
+    return @(_isListening);
+}
+
+- (void)startListening:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  
+    #if TARGET_IPHONE_SIMULATOR
+        reject(@"E_NOT_SUPPORTED_ON_IOS_SIMULATOR", @"React Native Live Pitch Detection module is not supported on the iOS simulator. Please use a real device for testing.", nil);
+        return;
+    #endif
+
+    if (_isListening) {
+        reject(@"E_ALREADY_LISTENING", @"Already listening", nil);
+        return;
+    }
+  
+  NSError *error = nil;
+
+    if (!_audioEngine) {
+        _audioEngine = [[AVAudioEngine alloc] init];
+
+        AVAudioInputNode *inputNode = [_audioEngine inputNode];
+        
+        AVAudioFormat *format = [inputNode inputFormatForBus:0];
+        _sampleRate = format.sampleRate;
+
+        [inputNode installTapOnBus:0 bufferSize:_bufferSize format:format block:^(AVAudioPCMBuffer * _Nonnull buffer, AVAudioTime * _Nonnull when) {
+            [self detectPitch:buffer];
+        }];
+
+        AVAudioSession *session = [AVAudioSession sharedInstance];
+        
+        [session setCategory:AVAudioSessionCategoryPlayAndRecord
+                        mode:AVAudioSessionModeMeasurement
+                     options:AVAudioSessionCategoryOptionDefaultToSpeaker
+                       error:&error];
+
+        if (error) {
+            reject(@"E_SET_CATEGORY_FAILED", @"Failed to set audio session category", error);
+            return;
+        }
+    }
+
+    [_audioEngine startAndReturnError:&error];
+        
+    if (error) {
+        reject(@"E_SET_ACTIVE_FAILED", @"Failed to set audio engine active", error);
+        return;
+    }
+
+    _isListening = YES;
+
+    resolve(nil);
+}
+
+- (void)stopListening:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+
+    if (!_isListening) {
+        reject(@"E_NOT_LISTENING", @"Not listening", nil);
+        return;
+    }
+
+    if (!_audioEngine) {
+        reject(@"E_NOT_INITIALIZED", @"Not initialized", nil);
+        return;
+    }
+
+    [_audioEngine stop];
+
+    _isListening = NO;
+    _lastUpdateTime = 0;
+    resolve(nil);
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeReactNativeLivePitchDetectionSpecJSI>(params);
+}
+
+- (void)detectPitch:(AVAudioPCMBuffer *)buffer {
+    NSTimeInterval currentTime = CACurrentMediaTime();
+    NSTimeInterval intervalSeconds = _updateIntervalMs / 1000.0;
+    
+    if (_lastUpdateTime == 0 || (currentTime - _lastUpdateTime) >= intervalSeconds) {
+        float *channelData = buffer.floatChannelData[0];
+        std::vector<double> buf(channelData, channelData + buffer.frameLength);
+
+        double frequency = techoptio::reactnativelivepitchdetection::autoCorrelate(buf, _sampleRate, _minVolume);
+
+        [self emitOnFrequencyDetected:@{@"frequency": @(frequency)}];
+        
+        _lastUpdateTime = currentTime;
+    }
+}
+
++ (NSString *)moduleName
+{
+  return @"ReactNativeLivePitchDetection";
+}
+
+@end
+

package/lib/module/NativeReactNativeLivePitchDetection.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('ReactNativeLivePitchDetection');
+//# sourceMappingURL=NativeReactNativeLivePitchDetection.js.map

package/lib/module/NativeReactNativeLivePitchDetection.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeReactNativeLivePitchDetection.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA6C,cAAc;AAUvF,eAAeA,mBAAmB,CAACC,YAAY,CAAO,+BAA+B,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import NativeReactNativeLivePitchDetection from "./NativeReactNativeLivePitchDetection.js";
+let A4 = 440; // A4 note frequency
+const noteNames = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+const ReactNativeLivePitchDetection = {
+  setOptions: options => {
+    A4 = options?.a4Frequency ?? 440;
+    NativeReactNativeLivePitchDetection.setOptions(options?.bufferSize ?? 4096, options?.minVolume ?? -20.0, options?.updateIntervalMs ?? 100);
+  },
+  startListening: () => {
+    return NativeReactNativeLivePitchDetection.startListening();
+  },
+  stopListening: () => {
+    return NativeReactNativeLivePitchDetection.stopListening();
+  },
+  addListener: callback => {
+    return NativeReactNativeLivePitchDetection.onFrequencyDetected(event => {
+      callback({
+        frequency: event.frequency,
+        note: getNoteFromFrequency(event.frequency)
+      });
+    });
+  },
+  isListening: () => {
+    return NativeReactNativeLivePitchDetection.isListening();
+  }
+};
+function getNoteFromFrequency(frequency) {
+  if (frequency <= 0 || !isFinite(frequency)) return "-";
+  const noteNumber = 12 * Math.log2(frequency / A4) + 69;
+  const noteIndex = Math.round(noteNumber) % 12;
+  const octave = Math.floor(Math.round(noteNumber) / 12) - 1;
+  return `${noteNames[noteIndex]}${octave}`;
+}
+;
+export default ReactNativeLivePitchDetection;
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeReactNativeLivePitchDetection","A4","noteNames","ReactNativeLivePitchDetection","setOptions","options","a4Frequency","bufferSize","minVolume","updateIntervalMs","startListening","stopListening","addListener","callback","onFrequencyDetected","event","frequency","note","getNoteFromFrequency","isListening","isFinite","noteNumber","Math","log2","noteIndex","round","octave","floor"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,mCAAmC,MAAM,0CAAuC;AAMvF,IAAIC,EAAE,GAAG,GAAG,CAAC,CAAC;AACd,MAAMC,SAAS,GAAG,CAChB,GAAG,EACH,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,GAAG,EACH,GAAG,EACH,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,GAAG,CACJ;AAED,MAAMC,6BAA6B,GAAG;EACpCC,UAAU,EAAGC,OAAgB,IAAK;IAChCJ,EAAE,GAAGI,OAAO,EAAEC,WAAW,IAAI,GAAG;IAChCN,mCAAmC,CAACI,UAAU,CAC5CC,OAAO,EAAEE,UAAU,IAAI,IAAI,EAC3BF,OAAO,EAAEG,SAAS,IAAI,CAAC,IAAI,EAC3BH,OAAO,EAAEI,gBAAgB,IAAI,GAC/B,CAAC;EACH,CAAC;EACDC,cAAc,EAAEA,CAAA,KAAM;IACpB,OAAOV,mCAAmC,CAACU,cAAc,CAAC,CAAC;EAC7D,CAAC;EACDC,aAAa,EAAEA,CAAA,KAAM;IACnB,OAAOX,mCAAmC,CAACW,aAAa,CAAC,CAAC;EAC5D,CAAC;EACDC,WAAW,EAAGC,QAAoD,IAAK;IACrE,OAAOb,mCAAmC,CAACc,mBAAmB,CAAEC,KAAK,IAAK;MACxEF,QAAQ,CAAC;QACPG,SAAS,EAAED,KAAK,CAACC,SAAS;QAC1BC,IAAI,EAAEC,oBAAoB,CAACH,KAAK,CAACC,SAAS;MAC5C,CAAC,CAAC;IACJ,CAAC,CAAC;EACJ,CAAC;EACDG,WAAW,EAAEA,CAAA,KAAM;IACjB,OAAOnB,mCAAmC,CAACmB,WAAW,CAAC,CAAC;EAC1D;AACF,CAAC;AAED,SAASD,oBAAoBA,CAACF,SAAiB,EAAU;EACvD,IAAIA,SAAS,IAAI,CAAC,IAAI,CAACI,QAAQ,CAACJ,SAAS,CAAC,EAAE,OAAO,GAAG;EAEtD,MAAMK,UAAU,GAAG,EAAE,GAAGC,IAAI,CAACC,IAAI,CAACP,SAAS,GAAGf,EAAE,CAAC,GAAG,EAAE;EACtD,MAAMuB,SAAS,GAAGF,IAAI,CAACG,KAAK,CAACJ,UAAU,CAAC,GAAG,EAAE;EAC7C,MAAMK,MAAM,GAAGJ,IAAI,CAACK,KAAK,CAACL,IAAI,CAACG,KAAK,CAACJ,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;EAE1D,OAAO,GAAGnB,SAAS,CAACsB,SAAS,CAAC,GAAGE,MAAM,EAAE;AAC3C;AAAC;AAGD,eAAevB,6BAA6B;AAE5C,cAAc,YAAS","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["types.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NativeReactNativeLivePitchDetection.d.ts

@@ -0,0 +1,13 @@
+import { type TurboModule, type CodegenTypes } from 'react-native';
+export interface Spec extends TurboModule {
+    setOptions(bufferSize: number, minVolume: number, updateIntervalMs: number): void;
+    startListening(): Promise<void>;
+    stopListening(): Promise<void>;
+    isListening(): boolean;
+    readonly onFrequencyDetected: CodegenTypes.EventEmitter<{
+        frequency: number;
+    }>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeReactNativeLivePitchDetection.d.ts.map

package/lib/typescript/src/NativeReactNativeLivePitchDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeReactNativeLivePitchDetection.d.ts","sourceRoot":"","sources":["../../../src/NativeReactNativeLivePitchDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAExF,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClF,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,WAAW,IAAI,OAAO,CAAC;IACvB,QAAQ,CAAC,mBAAmB,EAAE,YAAY,CAAC,YAAY,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChF;;AAED,wBAAuF"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,11 @@
+import type { Options, ReactNativeLivePitchDetectionEventCallback } from './types';
+declare const ReactNativeLivePitchDetection: {
+    setOptions: (options: Options) => void;
+    startListening: () => Promise<void>;
+    stopListening: () => Promise<void>;
+    addListener: (callback: ReactNativeLivePitchDetectionEventCallback) => import("react-native").EventSubscription;
+    isListening: () => boolean;
+};
+export default ReactNativeLivePitchDetection;
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,0CAA0C,EAC3C,MAAM,SAAS,CAAC;AAkBjB,QAAA,MAAM,6BAA6B;0BACX,OAAO;;;4BAcL,0CAA0C;;CAWnE,CAAC;AAaF,eAAe,6BAA6B,CAAC;AAE7C,cAAc,SAAS,CAAC"}

package/lib/typescript/src/types.d.ts

@@ -0,0 +1,12 @@
+export type PitchEvent = {
+    frequency: number;
+    note: string;
+};
+export type ReactNativeLivePitchDetectionEventCallback = (event: PitchEvent) => void;
+export type Options = {
+    bufferSize?: number;
+    minVolume?: number;
+    updateIntervalMs?: number;
+    a4Frequency?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,0CAA0C,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AAErF,MAAM,MAAM,OAAO,GAAG;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAA"}

package/package.json

@@ -0,0 +1,164 @@
+{
+  "name": "@techoptio/react-native-live-pitch-detection",
+  "version": "1.0.0",
+  "description": "Live pitch detection (frequency, note and octave) from device microphone for React Native.",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace @techoptio/react-native-live-pitch-detection-example",
+    "test": "jest",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "release": "release-it --only-version"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/techoptio/react-native-live-pitch-detection.git"
+  },
+  "author": "TechOpt.io <oss@techopt.io> (https://github.com/techoptio)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/techoptio/react-native-live-pitch-detection/issues"
+  },
+  "homepage": "https://github.com/techoptio/react-native-live-pitch-detection#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@evilmartians/lefthook": "^1.12.3",
+    "@react-native-community/cli": "20.0.1",
+    "@react-native/babel-preset": "0.81.1",
+    "@react-native/eslint-config": "^0.81.1",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.1.0",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "prettier": "^3.6.2",
+    "react": "19.1.0",
+    "react-native": "0.81.1",
+    "react-native-builder-bob": "^0.40.14",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@3.6.1",
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "ReactNativeLivePitchDetectionSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "io.techopt.lib.reactnativelivepitchdetection"
+    }
+  },
+  "create-react-native-library": {
+    "languages": "kotlin-objc",
+    "type": "turbo-module",
+    "version": "0.54.8"
+  }
+}

package/src/NativeReactNativeLivePitchDetection.ts

@@ -0,0 +1,11 @@
+import { TurboModuleRegistry, type TurboModule, type CodegenTypes } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setOptions(bufferSize: number, minVolume: number, updateIntervalMs: number): void;
+  startListening(): Promise<void>;
+  stopListening(): Promise<void>;
+  isListening(): boolean;
+  readonly onFrequencyDetected: CodegenTypes.EventEmitter<{ frequency: number }>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ReactNativeLivePitchDetection');

package/src/index.tsx

@@ -0,0 +1,64 @@
+import NativeReactNativeLivePitchDetection from './NativeReactNativeLivePitchDetection';
+import type {
+  Options,
+  ReactNativeLivePitchDetectionEventCallback,
+} from './types';
+
+let A4 = 440; // A4 note frequency
+const noteNames = [
+  "C",
+  "C#",
+  "D",
+  "D#",
+  "E",
+  "F",
+  "F#",
+  "G",
+  "G#",
+  "A",
+  "A#",
+  "B",
+];
+
+const ReactNativeLivePitchDetection = {
+  setOptions: (options: Options) => {
+    A4 = options?.a4Frequency ?? 440;
+    NativeReactNativeLivePitchDetection.setOptions(
+      options?.bufferSize ?? 4096,
+      options?.minVolume ?? -20.0,
+      options?.updateIntervalMs ?? 100
+    );
+  },
+  startListening: () => {
+    return NativeReactNativeLivePitchDetection.startListening();
+  },
+  stopListening: () => {
+    return NativeReactNativeLivePitchDetection.stopListening();
+  },
+  addListener: (callback: ReactNativeLivePitchDetectionEventCallback) => {
+    return NativeReactNativeLivePitchDetection.onFrequencyDetected((event) => {
+      callback({
+        frequency: event.frequency,
+        note: getNoteFromFrequency(event.frequency),
+      });
+    });
+  },
+  isListening: () => {
+    return NativeReactNativeLivePitchDetection.isListening();
+  },
+};
+
+function getNoteFromFrequency(frequency: number): string {
+  if (frequency <= 0 || !isFinite(frequency)) return "-";
+
+  const noteNumber = 12 * Math.log2(frequency / A4) + 69;
+  const noteIndex = Math.round(noteNumber) % 12;
+  const octave = Math.floor(Math.round(noteNumber) / 12) - 1;
+
+  return `${noteNames[noteIndex]}${octave}`;
+};
+
+
+export default ReactNativeLivePitchDetection;
+
+export * from './types';

package/src/types.ts

@@ -0,0 +1,13 @@
+export type PitchEvent = {
+    frequency: number;
+    note: string;
+};
+
+export type ReactNativeLivePitchDetectionEventCallback = (event: PitchEvent) => void;
+
+export type Options = {
+    bufferSize?: number;
+    minVolume?: number;
+    updateIntervalMs?: number;
+    a4Frequency?: number;
+}