react-native-audio-concat 0.2.0

package/ios/AudioConcat.swift

@@ -0,0 +1,75 @@
+import AVFoundation
+import NitroModules
+
+class AudioConcat: HybridAudioConcatSpec {
+    public func concatAudioFiles(data: [AudioDataOrSilence], outputPath: String) throws -> Promise<String> {
+        return Promise.async { [weak self] in
+            guard !data.isEmpty else {
+                throw NSError(domain: "AwesomeLibrary", code: 1, userInfo: [NSLocalizedDescriptionKey: "Data array is empty"])
+            }
+
+            let composition = AVMutableComposition()
+            guard let audioTrack = composition.addMutableTrack(withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid) else {
+                throw NSError(domain: "AwesomeLibrary", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to create audio track"])
+            }
+
+            var currentTime = CMTime.zero
+
+            for (index, item) in data.enumerated() {
+                switch item {
+                case .first(let audioData):
+                    // Audio file
+                    let filePath = audioData.filePath
+                    let fileURL = URL(fileURLWithPath: filePath)
+                    let asset = AVAsset(url: fileURL)
+
+                    guard let sourceTrack = asset.tracks(withMediaType: .audio).first else {
+                        throw NSError(domain: "AwesomeLibrary", code: 3, userInfo: [NSLocalizedDescriptionKey: "No audio track found in \(filePath)"])
+                    }
+
+                    let duration = asset.duration
+                    let timeRange = CMTimeRange(start: .zero, duration: duration)
+
+                    try audioTrack.insertTimeRange(timeRange, of: sourceTrack, at: currentTime)
+                    currentTime = CMTimeAdd(currentTime, duration)
+
+                case .second(let silentData):
+                    // Silence
+                    let durationMs = silentData.durationMs
+                    let silenceDuration = CMTime(seconds: durationMs / 1000.0, preferredTimescale: 600)
+
+                    // In AVMutableComposition, leaving a gap (not inserting anything)
+                    // automatically creates silence
+                    currentTime = CMTimeAdd(currentTime, silenceDuration)
+                }
+            }
+
+            let outputURL = URL(fileURLWithPath: outputPath)
+
+            // Remove existing file if present
+            try? FileManager.default.removeItem(at: outputURL)
+
+            guard let exportSession = AVAssetExportSession(asset: composition, presetName: AVAssetExportPresetAppleM4A) else {
+                throw NSError(domain: "AwesomeLibrary", code: 4, userInfo: [NSLocalizedDescriptionKey: "Failed to create export session"])
+            }
+
+            exportSession.outputURL = outputURL
+            exportSession.outputFileType = .m4a
+
+            return try await withCheckedThrowingContinuation { continuation in
+                exportSession.exportAsynchronously {
+                    switch exportSession.status {
+                    case .completed:
+                        continuation.resume(returning: outputPath)
+                    case .failed:
+                        continuation.resume(throwing: exportSession.error ?? NSError(domain: "AwesomeLibrary", code: 5, userInfo: [NSLocalizedDescriptionKey: "Export failed"]))
+                    case .cancelled:
+                        continuation.resume(throwing: NSError(domain: "AwesomeLibrary", code: 6, userInfo: [NSLocalizedDescriptionKey: "Export cancelled"]))
+                    default:
+                        continuation.resume(throwing: NSError(domain: "AwesomeLibrary", code: 7, userInfo: [NSLocalizedDescriptionKey: "Unknown export status"]))
+                    }
+                }
+            }
+        }
+    }
+}

package/lib/module/AudioConcat.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=AudioConcat.nitro.js.map

package/lib/module/AudioConcat.nitro.js.map

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

package/lib/module/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const AudioConcatHybridObject = NitroModules.createHybridObject('AudioConcat');
+
+/**
+ * Concat audio files and silence periods into a single output file.
+ *
+ * @param data - Array of audio files and silence periods to merge.
+ *               Each item can be either:
+ *               - `{ filePath: string }` for an audio file
+ *               - `{ durationMs: number }` for a silence period
+ * @param outputPath - Absolute path where the merged audio file will be saved (M4A format)
+ * @returns Promise that resolves with the output file path
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   { filePath: '/path/to/audio1.m4a' },
+ *   { durationMs: 500 },  // 500ms silence
+ *   { filePath: '/path/to/audio2.m4a' },
+ *   { durationMs: 1000 }, // 1 second silence
+ *   { filePath: '/path/to/audio3.m4a' }
+ * ];
+ * const output = '/path/to/merged.m4a';
+ * const result = await concatAudioFiles(data, output);
+ * console.log('concat file:', result);
+ * ```
+ */
+export function concatAudioFiles(data, outputPath) {
+  return AudioConcatHybridObject.concatAudioFiles(data, outputPath);
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","AudioConcatHybridObject","createHybridObject","concatAudioFiles","data","outputPath"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,MAAMC,uBAAuB,GAC3BD,YAAY,CAACE,kBAAkB,CAAc,aAAa,CAAC;;AAE7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAC9BC,IAA0B,EAC1BC,UAAkB,EACD;EACjB,OAAOJ,uBAAuB,CAACE,gBAAgB,CAACC,IAAI,EAAEC,UAAU,CAAC;AACnE","ignoreList":[]}

package/lib/module/package.json

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

package/lib/typescript/package.json

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

package/lib/typescript/src/AudioConcat.nitro.d.ts

@@ -0,0 +1,16 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+type SilentData = {
+    durationMs: number;
+};
+type AudioData = {
+    filePath: string;
+};
+export type AudioDataOrSilence = AudioData | SilentData;
+export interface AudioConcat extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    concatAudioFiles(data: AudioDataOrSilence[], outputPath: string): Promise<string>;
+}
+export {};
+//# sourceMappingURL=AudioConcat.nitro.d.ts.map

package/lib/typescript/src/AudioConcat.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioConcat.nitro.d.ts","sourceRoot":"","sources":["../../../src/AudioConcat.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,KAAK,UAAU,GAAG;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,UAAU,CAAC;AAExD,MAAM,WAAW,WACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,gBAAgB,CACd,IAAI,EAAE,kBAAkB,EAAE,EAC1B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAAC;CACpB"}

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

@@ -0,0 +1,28 @@
+import type { AudioDataOrSilence } from './AudioConcat.nitro';
+/**
+ * Concat audio files and silence periods into a single output file.
+ *
+ * @param data - Array of audio files and silence periods to merge.
+ *               Each item can be either:
+ *               - `{ filePath: string }` for an audio file
+ *               - `{ durationMs: number }` for a silence period
+ * @param outputPath - Absolute path where the merged audio file will be saved (M4A format)
+ * @returns Promise that resolves with the output file path
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   { filePath: '/path/to/audio1.m4a' },
+ *   { durationMs: 500 },  // 500ms silence
+ *   { filePath: '/path/to/audio2.m4a' },
+ *   { durationMs: 1000 }, // 1 second silence
+ *   { filePath: '/path/to/audio3.m4a' }
+ * ];
+ * const output = '/path/to/merged.m4a';
+ * const result = await concatAudioFiles(data, output);
+ * console.log('concat file:', result);
+ * ```
+ */
+export declare function concatAudioFiles(data: AudioDataOrSilence[], outputPath: string): Promise<string>;
+export type { AudioDataOrSilence } from './AudioConcat.nitro';
+//# 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,EAAe,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAK3E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,kBAAkB,EAAE,EAC1B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["audioconcat"],
+  "ios": {
+    "iosModuleName": "AudioConcat"
+  },
+  "android": {
+    "androidNamespace": ["audioconcat"],
+    "androidCxxLibName": "audioconcat"
+  },
+  "autolinking": {
+    "AudioConcat": {
+      "swift": "AudioConcat",
+      "kotlin": "AudioConcat"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/audioconcat+autolinking.cmake

@@ -0,0 +1,82 @@
+#
+# audioconcat+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2025 Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/audioconcat+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_AUDIOCONCAT_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  audioconcat PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/audioconcatOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridAudioConcatSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridAudioConcatSpec.cpp
+  ../nitrogen/generated/android/c++/JAudioDataOrSilence.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  audioconcat PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        audioconcat
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        audioconcat
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        audioconcat
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/audioconcat+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// audioconcat+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/audioconcat+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 audioconcat is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/audioconcatOnLoad.cpp

@@ -0,0 +1,44 @@
+///
+/// audioconcatOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_AUDIOCONCAT_WITH_GENERATED_CMAKE_PROJECT
+#error audioconcatOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "audioconcatOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridAudioConcatSpec.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::audioconcat {
+
+int initialize(JavaVM* vm) {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::audioconcat;
+  using namespace facebook;
+
+  return facebook::jni::initialize(vm, [] {
+    // Register native JNI methods
+    margelo::nitro::audioconcat::JHybridAudioConcatSpec::registerNatives();
+
+    // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "AudioConcat",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridAudioConcatSpec::javaobject> object("com/margelo/nitro/audioconcat/AudioConcat");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+  });
+}
+
+} // namespace margelo::nitro::audioconcat

package/nitrogen/generated/android/audioconcatOnLoad.hpp

@@ -0,0 +1,25 @@
+///
+/// audioconcatOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::audioconcat {
+
+  /**
+   * Initializes the native (C++) part of audioconcat, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return margelo::nitro::audioconcat::initialize(vm);
+   * }
+   * ```
+   */
+  int initialize(JavaVM* vm);
+
+} // namespace margelo::nitro::audioconcat

package/nitrogen/generated/android/c++/JAudioData.hpp

@@ -0,0 +1,53 @@
+///
+/// JAudioData.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AudioData.hpp"
+
+#include <string>
+
+namespace margelo::nitro::audioconcat {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AudioData" and the the Kotlin data class "AudioData".
+   */
+  struct JAudioData final: public jni::JavaClass<JAudioData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audioconcat/AudioData;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AudioData by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AudioData toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFilePath = clazz->getField<jni::JString>("filePath");
+      jni::local_ref<jni::JString> filePath = this->getFieldValue(fieldFilePath);
+      return AudioData(
+        filePath->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAudioData::javaobject> fromCpp(const AudioData& value) {
+      return newInstance(
+        jni::make_jstring(value.filePath)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::audioconcat

package/nitrogen/generated/android/c++/JAudioDataOrSilence.cpp

@@ -0,0 +1,26 @@
+///
+/// JAudioDataOrSilence.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JAudioDataOrSilence.hpp"
+
+namespace margelo::nitro::audioconcat {
+  /**
+   * Converts JAudioDataOrSilence to std::variant<AudioData, SilentData>
+   */
+  std::variant<AudioData, SilentData> JAudioDataOrSilence::toCpp() const {
+    if (isInstanceOf(JAudioDataOrSilence_impl::First::javaClassStatic())) {
+      // It's a `AudioData`
+      auto jniValue = static_cast<const JAudioDataOrSilence_impl::First*>(this)->getValue();
+      return jniValue->toCpp();
+    } else if (isInstanceOf(JAudioDataOrSilence_impl::Second::javaClassStatic())) {
+      // It's a `SilentData`
+      auto jniValue = static_cast<const JAudioDataOrSilence_impl::Second*>(this)->getValue();
+      return jniValue->toCpp();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::audioconcat

package/nitrogen/generated/android/c++/JAudioDataOrSilence.hpp

@@ -0,0 +1,72 @@
+///
+/// JAudioDataOrSilence.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+#include "AudioData.hpp"
+#include "SilentData.hpp"
+#include <variant>
+#include "JAudioData.hpp"
+#include <string>
+#include "JSilentData.hpp"
+
+namespace margelo::nitro::audioconcat {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "AudioDataOrSilence".
+   */
+  class JAudioDataOrSilence: public jni::JavaClass<JAudioDataOrSilence> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audioconcat/AudioDataOrSilence;";
+
+    static jni::local_ref<JAudioDataOrSilence> create_0(jni::alias_ref<JAudioData> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JAudioDataOrSilence(jni::alias_ref<JAudioData>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JAudioDataOrSilence> create_1(jni::alias_ref<JSilentData> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JAudioDataOrSilence(jni::alias_ref<JSilentData>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JAudioDataOrSilence> fromCpp(const std::variant<AudioData, SilentData>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JAudioData::fromCpp(std::get<0>(variant)));
+        case 1: return create_1(JSilentData::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<AudioData, SilentData> toCpp() const;
+  };
+
+  namespace JAudioDataOrSilence_impl {
+    class First: public jni::JavaClass<First, JAudioDataOrSilence> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audioconcat/AudioDataOrSilence$First;";
+    
+      [[nodiscard]] jni::local_ref<JAudioData> getValue() const {
+        static const auto field = javaClassStatic()->getField<JAudioData>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second: public jni::JavaClass<Second, JAudioDataOrSilence> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audioconcat/AudioDataOrSilence$Second;";
+    
+      [[nodiscard]] jni::local_ref<JSilentData> getValue() const {
+        static const auto field = javaClassStatic()->getField<JSilentData>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JAudioDataOrSilence_impl
+} // namespace margelo::nitro::audioconcat

package/nitrogen/generated/android/c++/JHybridAudioConcatSpec.cpp

@@ -0,0 +1,77 @@
+///
+/// JHybridAudioConcatSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAudioConcatSpec.hpp"
+
+// Forward declaration of `AudioData` to properly resolve imports.
+namespace margelo::nitro::audioconcat { struct AudioData; }
+// Forward declaration of `SilentData` to properly resolve imports.
+namespace margelo::nitro::audioconcat { struct SilentData; }
+
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "AudioData.hpp"
+#include "SilentData.hpp"
+#include <variant>
+#include <vector>
+#include "JAudioDataOrSilence.hpp"
+#include "JAudioData.hpp"
+#include "JSilentData.hpp"
+
+namespace margelo::nitro::audioconcat {
+
+  jni::local_ref<JHybridAudioConcatSpec::jhybriddata> JHybridAudioConcatSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAudioConcatSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAudioConcatSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAudioConcatSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridAudioConcatSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<std::string>> JHybridAudioConcatSpec::concatAudioFiles(const std::vector<std::variant<AudioData, SilentData>>& data, const std::string& outputPath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JAudioDataOrSilence>> /* data */, jni::alias_ref<jni::JString> /* outputPath */)>("concatAudioFiles");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = data.size();
+      jni::local_ref<jni::JArrayClass<JAudioDataOrSilence>> __array = jni::JArrayClass<JAudioDataOrSilence>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = data[__i];
+        __array->setElement(__i, *JAudioDataOrSilence::fromCpp(__element));
+      }
+      return __array;
+    }(), jni::make_jstring(outputPath));
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::audioconcat