native-recorder-nodejs 1.0.1

package/dist/types.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordingState = exports.AudioSDKError = exports.AudioSDKErrorType = exports.AudioDeviceType = void 0;
+/**
+ * Audio device types
+ */
+var AudioDeviceType;
+(function (AudioDeviceType) {
+    AudioDeviceType[AudioDeviceType["MICROPHONE"] = 0] = "MICROPHONE";
+    AudioDeviceType[AudioDeviceType["SYSTEM_AUDIO"] = 1] = "SYSTEM_AUDIO";
+    AudioDeviceType[AudioDeviceType["APPLICATION"] = 2] = "APPLICATION";
+})(AudioDeviceType || (exports.AudioDeviceType = AudioDeviceType = {}));
+/**
+ * Error types
+ */
+var AudioSDKErrorType;
+(function (AudioSDKErrorType) {
+    AudioSDKErrorType["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+    AudioSDKErrorType["DEVICE_NOT_FOUND"] = "DEVICE_NOT_FOUND";
+    AudioSDKErrorType["DEVICE_BUSY"] = "DEVICE_BUSY";
+    AudioSDKErrorType["INITIALIZATION_FAILED"] = "INITIALIZATION_FAILED";
+    AudioSDKErrorType["RECORDING_FAILED"] = "RECORDING_FAILED";
+    AudioSDKErrorType["INVALID_FORMAT"] = "INVALID_FORMAT";
+    AudioSDKErrorType["PLATFORM_NOT_SUPPORTED"] = "PLATFORM_NOT_SUPPORTED";
+})(AudioSDKErrorType || (exports.AudioSDKErrorType = AudioSDKErrorType = {}));
+/**
+ * Custom error class for Audio SDK
+ */
+class AudioSDKError extends Error {
+    constructor(type, message, details) {
+        super(message);
+        this.type = type;
+        this.details = details;
+        this.name = "AudioSDKError";
+    }
+}
+exports.AudioSDKError = AudioSDKError;
+/**
+ * Recording state
+ */
+var RecordingState;
+(function (RecordingState) {
+    RecordingState["IDLE"] = "idle";
+    RecordingState["RECORDING"] = "recording";
+    RecordingState["PAUSED"] = "paused";
+    RecordingState["STOPPED"] = "stopped";
+    RecordingState["ERROR"] = "error";
+})(RecordingState || (exports.RecordingState = RecordingState = {}));
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/typescript/types.ts"],"names":[],"mappings":";;;AAOA;;GAEG;AACH,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,iEAAc,CAAA;IACd,qEAAgB,CAAA;IAChB,mEAAe,CAAA;AACjB,CAAC,EAJW,eAAe,+BAAf,eAAe,QAI1B;AAyDD;;GAEG;AACH,IAAY,iBAQX;AARD,WAAY,iBAAiB;IAC3B,4DAAuC,CAAA;IACvC,0DAAqC,CAAA;IACrC,gDAA2B,CAAA;IAC3B,oEAA+C,CAAA;IAC/C,0DAAqC,CAAA;IACrC,sDAAiC,CAAA;IACjC,sEAAiD,CAAA;AACnD,CAAC,EARW,iBAAiB,iCAAjB,iBAAiB,QAQ5B;AAED;;GAEG;AACH,MAAa,aAAc,SAAQ,KAAK;IACtC,YACS,IAAuB,EAC9B,OAAe,EACR,OAAa;QAEpB,KAAK,CAAC,OAAO,CAAC,CAAC;QAJR,SAAI,GAAJ,IAAI,CAAmB;QAEvB,YAAO,GAAP,OAAO,CAAM;QAGpB,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AATD,sCASC;AAED;;GAEG;AACH,IAAY,cAMX;AAND,WAAY,cAAc;IACxB,+BAAa,CAAA;IACb,yCAAuB,CAAA;IACvB,mCAAiB,CAAA;IACjB,qCAAmB,CAAA;IACnB,iCAAe,CAAA;AACjB,CAAC,EANW,cAAc,8BAAd,cAAc,QAMzB"}

package/native/AudioController.cpp

@@ -0,0 +1,233 @@
+#include "AudioController.h"
+
+// Forward declaration of platform-specific factory
+std::unique_ptr<AudioEngine> CreatePlatformAudioEngine();
+
+Napi::FunctionReference AudioController::constructor;
+
+Napi::Object AudioController::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(
+      env, "AudioController",
+      {InstanceMethod("start", &AudioController::Start),
+       InstanceMethod("stop", &AudioController::Stop),
+       StaticMethod("getDevices", &AudioController::GetDevices),
+       StaticMethod("getDeviceFormat", &AudioController::GetDeviceFormat),
+       StaticMethod("checkPermission", &AudioController::CheckPermission),
+       StaticMethod("requestPermission", &AudioController::RequestPermission)});
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("AudioController", func);
+  return exports;
+}
+
+AudioController::AudioController(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<AudioController>(info) {
+  this->engine = CreatePlatformAudioEngine();
+}
+
+AudioController::~AudioController() {
+  if (this->engine) {
+    this->engine->Stop();
+  }
+  if (this->tsfn) {
+    this->tsfn->Release();
+  }
+}
+
+Napi::Value AudioController::Start(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Expected config object and callback function")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object config = info[0].As<Napi::Object>();
+
+  // Parse deviceType (required)
+  std::string deviceType = AudioEngine::DEVICE_TYPE_INPUT; // default to input
+  if (config.Has("deviceType")) {
+    Napi::Value typeVal = config.Get("deviceType");
+    if (typeVal.IsString()) {
+      deviceType = typeVal.As<Napi::String>().Utf8Value();
+    }
+  }
+
+  // Validate deviceType
+  if (deviceType != AudioEngine::DEVICE_TYPE_INPUT &&
+      deviceType != AudioEngine::DEVICE_TYPE_OUTPUT) {
+    Napi::TypeError::New(env, "deviceType must be 'input' or 'output'")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // Parse deviceId (required)
+  std::string deviceId = "";
+  if (config.Has("deviceId")) {
+    Napi::Value idVal = config.Get("deviceId");
+    if (idVal.IsString()) {
+      deviceId = idVal.As<Napi::String>().Utf8Value();
+    }
+  }
+
+  if (deviceId.empty()) {
+    Napi::TypeError::New(env, "deviceId is required")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Function callback = info[1].As<Napi::Function>();
+
+  // Create a ThreadSafeFunction to call back into JS from the audio thread
+  this->tsfn = std::make_shared<Napi::ThreadSafeFunction>(
+      Napi::ThreadSafeFunction::New(env, callback, "AudioDataCallback", 0, 1));
+
+  auto dataCallback = [tsfn = this->tsfn](const uint8_t *data, size_t size) {
+    // Copy data to a vector to pass to the JS thread safely
+    auto dataVec = new std::vector<uint8_t>(data, data + size);
+
+    napi_status status =
+        tsfn->BlockingCall(dataVec, [](Napi::Env env, Napi::Function jsCallback,
+                                       std::vector<uint8_t> *vec) {
+          // This runs on the JS main thread
+          Napi::Buffer<uint8_t> buffer =
+              Napi::Buffer<uint8_t>::Copy(env, vec->data(), vec->size());
+          jsCallback.Call({env.Null(), buffer});
+          delete vec;
+        });
+
+    if (status != napi_ok) {
+      // Handle error or shutdown
+      delete dataVec;
+    }
+  };
+
+  auto errorCallback = [tsfn = this->tsfn](const std::string &errorMsg) {
+    auto errorStr = new std::string(errorMsg);
+    napi_status status = tsfn->BlockingCall(
+        errorStr,
+        [](Napi::Env env, Napi::Function jsCallback, std::string *str) {
+          // Pass error to JS callback as first argument
+          jsCallback.Call({Napi::Error::New(env, *str).Value(), env.Null()});
+          delete str;
+        });
+    if (status != napi_ok) {
+      delete errorStr;
+    }
+  };
+
+  try {
+    this->engine->Start(deviceType, deviceId, dataCallback, errorCallback);
+  } catch (const std::exception &e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+  }
+
+  return env.Null();
+}
+
+Napi::Value AudioController::Stop(const Napi::CallbackInfo &info) {
+  if (this->engine) {
+    this->engine->Stop();
+  }
+  if (this->tsfn) {
+    this->tsfn->Release();
+    this->tsfn = nullptr;
+  }
+  return info.Env().Null();
+}
+
+Napi::Value AudioController::GetDevices(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  auto tempEngine = CreatePlatformAudioEngine();
+  std::vector<AudioDevice> devices = tempEngine->GetDevices();
+
+  Napi::Array result = Napi::Array::New(env, devices.size());
+  for (size_t i = 0; i < devices.size(); i++) {
+    Napi::Object deviceObj = Napi::Object::New(env);
+    deviceObj.Set("id", devices[i].id);
+    deviceObj.Set("name", devices[i].name);
+    deviceObj.Set("type", devices[i].type);
+    deviceObj.Set("isDefault", devices[i].isDefault);
+    result[i] = deviceObj;
+  }
+
+  return result;
+}
+
+Napi::Value AudioController::GetDeviceFormat(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected deviceId string")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string deviceId = info[0].As<Napi::String>().Utf8Value();
+
+  auto tempEngine = CreatePlatformAudioEngine();
+  AudioFormat format = tempEngine->GetDeviceFormat(deviceId);
+
+  if (format.sampleRate == 0) {
+    Napi::Error::New(env, "Failed to get device format")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object result = Napi::Object::New(env);
+  result.Set("sampleRate", format.sampleRate);
+  result.Set("channels", format.channels);
+  result.Set("bitDepth", format.bitDepth);
+  result.Set("rawBitDepth", format.rawBitDepth);
+
+  return result;
+}
+
+Napi::Value AudioController::CheckPermission(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  auto tempEngine = CreatePlatformAudioEngine();
+  PermissionStatus status = tempEngine->CheckPermission();
+
+  Napi::Object result = Napi::Object::New(env);
+  result.Set("mic", status.mic);
+  result.Set("system", status.system);
+
+  return result;
+}
+
+Napi::Value AudioController::RequestPermission(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env,
+                         "Expected permission type string ('mic' or 'system')")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string typeStr = info[0].As<Napi::String>().Utf8Value();
+  PermissionType type;
+
+  if (typeStr == AudioEngine::PERMISSION_MIC) {
+    type = PermissionType::Mic;
+  } else if (typeStr == AudioEngine::PERMISSION_SYSTEM) {
+    type = PermissionType::System;
+  } else {
+    Napi::TypeError::New(env,
+                         "Invalid permission type. Must be 'mic' or 'system'")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto tempEngine = CreatePlatformAudioEngine();
+  bool granted = tempEngine->RequestPermission(type);
+
+  return Napi::Boolean::New(env, granted);
+}

package/native/AudioController.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "AudioEngine.h"
+#include <memory>
+#include <napi.h>
+#include <thread>
+
+class AudioController : public Napi::ObjectWrap<AudioController> {
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  AudioController(const Napi::CallbackInfo &info);
+  ~AudioController();
+
+private:
+  static Napi::FunctionReference constructor;
+
+  Napi::Value Start(const Napi::CallbackInfo &info);
+  Napi::Value Stop(const Napi::CallbackInfo &info);
+  static Napi::Value GetDevices(const Napi::CallbackInfo &info);
+  static Napi::Value GetDeviceFormat(const Napi::CallbackInfo &info);
+  static Napi::Value CheckPermission(const Napi::CallbackInfo &info);
+  static Napi::Value RequestPermission(const Napi::CallbackInfo &info);
+
+  std::unique_ptr<AudioEngine> engine;
+  std::shared_ptr<Napi::ThreadSafeFunction> tsfn;
+};

package/native/AudioEngine.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+struct AudioDevice {
+  std::string id;
+  std::string name;
+  std::string type; // "input" or "output"
+  bool isDefault;
+};
+
+struct AudioFormat {
+  int sampleRate;
+  int channels;
+  int bitDepth;    // Output bit depth (always 16 for now)
+  int rawBitDepth; // Native device bit depth
+};
+
+// Permission status for audio recording
+struct PermissionStatus {
+  bool mic;    // Microphone permission granted
+  bool system; // System audio permission granted
+};
+
+// Permission type for requesting
+enum class PermissionType { Mic, System };
+
+class AudioEngine {
+public:
+  virtual ~AudioEngine() = default;
+
+  // Device type constants
+  static constexpr const char *DEVICE_TYPE_INPUT = "input";
+  static constexpr const char *DEVICE_TYPE_OUTPUT = "output";
+
+  // Special device ID for system-wide audio capture (macOS)
+  static constexpr const char *SYSTEM_AUDIO_DEVICE_ID = "system";
+
+  // Permission type constants for JS
+  static constexpr const char *PERMISSION_MIC = "mic";
+  static constexpr const char *PERMISSION_SYSTEM = "system";
+
+  // Callback for receiving raw PCM data (16-bit, Native Sample Rate,
+  // Stereo/Mono)
+  using DataCallback = std::function<void(const uint8_t *data, size_t size)>;
+
+  // Callback for receiving error messages
+  using ErrorCallback = std::function<void(const std::string &error)>;
+
+  // Start recording with explicit device type and ID
+  // deviceType: "input" or "output"
+  // deviceId: device identifier from GetDevices() (never empty)
+  virtual void Start(const std::string &deviceType, const std::string &deviceId,
+                     DataCallback dataCb, ErrorCallback errorCb) = 0;
+  virtual void Stop() = 0;
+
+  // Get all available devices (both input and output)
+  // All returned devices have valid id and type fields
+  virtual std::vector<AudioDevice> GetDevices() = 0;
+
+  // Get format for specific device
+  virtual AudioFormat GetDeviceFormat(const std::string &deviceId) = 0;
+
+  // Check permission status for mic and system audio
+  // Returns current permission status without prompting user
+  virtual PermissionStatus CheckPermission() = 0;
+
+  // Request permission for specified type
+  // Returns true if permission was granted, false otherwise
+  // On Windows, always returns true (no permission needed)
+  virtual bool RequestPermission(PermissionType type) = 0;
+};

package/native/Factory.cpp

@@ -0,0 +1,18 @@
+#include "AudioEngine.h"
+#include <memory>
+
+#ifdef _WIN32
+#include "win/WASAPIEngine.h"
+#elif defined(__APPLE__)
+#include "mac/AVFEngine.h"
+#endif
+
+std::unique_ptr<AudioEngine> CreatePlatformAudioEngine() {
+#ifdef _WIN32
+  return std::make_unique<WASAPIEngine>();
+#elif defined(__APPLE__)
+  return std::make_unique<AVFEngine>();
+#else
+  return nullptr;
+#endif
+}

package/native/mac/AVFEngine.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "../AudioEngine.h"
+#include <memory>
+
+class AVFEngine : public AudioEngine {
+public:
+  AVFEngine();
+  ~AVFEngine();
+
+  void Start(const std::string &deviceType, const std::string &deviceId,
+             DataCallback dataCb, ErrorCallback errorCb) override;
+  void Stop() override;
+  std::vector<AudioDevice> GetDevices() override;
+  AudioFormat GetDeviceFormat(const std::string &deviceId) override;
+
+  // Permission handling
+  PermissionStatus CheckPermission() override;
+  bool RequestPermission(PermissionType type) override;
+
+private:
+  struct Impl;
+  std::unique_ptr<Impl> impl;
+};