feat: integrate miniaudio for android

Author: exzos

.java-version

@@ -0,0 +1 @@
+17

android/CMakeLists.txt

@@ -4,16 +4,26 @@ cmake_minimum_required(VERSION 3.9.0)
 set(PACKAGE_NAME test)
 set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 20)
+set(CACHE_DIR ${CMAKE_SOURCE_DIR}/build)
 
-# Define C++ library and add all sources
-add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+file(GLOB_RECURSE CORE_SRC RELATIVE ${CMAKE_SOURCE_DIR} "./src/main/cpp/*.cpp")
+file(GLOB_RECURSE SOURCES RELATIVE ${CMAKE_SOURCE_DIR} "../cpp/*.cpp")
+
+add_library(
+        ${PACKAGE_NAME}
+        SHARED
+        ${CORE_SRC}
+        ${SOURCES}
+)
 
 # Add Nitrogen specs :)
 include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/test+autolinking.cmake)
 
 # Set up local includes
 include_directories("src/main/cpp" "../cpp")
 
+target_include_directories(${PACKAGE_NAME} PRIVATE "${CACHE_DIR}/download-cache")
+
 find_library(LOG_LIB log)
 
 # Link all libraries together

android/build.gradle

@@ -63,6 +63,23 @@ android {
     }
   }
 
+  def miniaudioHeader = file("${layout.buildDirectory.asFile.get()}/download-cache/miniaudio.h")
+  def miniaudioUrl = "https://raw.githubusercontent.com/mackron/miniaudio/master/miniaudio.h"
+
+  task downloadMiniaudioHeader {
+    outputs.file miniaudioHeader
+    doLast {
+      if (!miniaudioHeader.exists()) {
+        miniaudioHeader.parentFile.mkdirs()
+        new URL(miniaudioUrl).withInputStream { input ->
+          miniaudioHeader.withOutputStream { output -> output << input }
+        }
+      }
+    }
+  }
+
+  preBuild.dependsOn downloadMiniaudioHeader
+
   packagingOptions {
     excludes = [
             "META-INF",
@@ -126,4 +143,3 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation project(":react-native-nitro-modules")
 }
-

android/src/main/java/com/margelo/nitro/test/Test.kt

@@ -1,4 +1,4 @@
-package com.test
+package com.margelo.nitro.test
 
 import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule

…id/src/main/java/com/test/TestPackage.kt …va/com/margelo/nitro/test/TestPackage.ktandroid/src/main/java/com/test/TestPackage.kt renamed to android/src/main/java/com/margelo/nitro/test/TestPackage.kt android/src/main/java/com/test/TestPackage.kt renamed to android/src/main/java/com/margelo/nitro/test/TestPackage.kt

@@ -0,0 +1,101 @@
+#include "HybridTest.hpp"
+#define MINIAUDIO_IMPLEMENTATION
+#include "miniaudio.h"
+
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+#include <android/log.h>
+
+#define LOG_TAG "HybridTest"
+
+using namespace margelo::nitro::test;
+
+bool HybridTest::decodeAudioFile(const std::string& filePath, std::vector<float>& pcmData, unsigned int& sampleRate) {
+    ma_decoder decoder;
+    ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, 0);
+    ma_result file = ma_decoder_init_file(filePath.c_str(), &config, &decoder);
+    if (file != MA_SUCCESS) {
+        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "Failed to init decoder for %s (error %d)", filePath.c_str(), file);
+        std::cerr << "Failed to init decoder for " << filePath << std::endl;
+        return false;
+    }
+
+    sampleRate = decoder.outputSampleRate;
+
+    ma_uint64 totalFrames = 0;
+    if (ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrames) != MA_SUCCESS) {
+        std::cerr << "Failed to get length in pcm frames" << std::endl;
+        ma_decoder_uninit(&decoder);
+        return false;
+    }
+
+    size_t totalSamples = static_cast<size_t>(totalFrames * decoder.outputChannels);
+    pcmData.resize(totalSamples);
+
+    ma_uint64 framesRead = 0;
+    ma_result result = ma_decoder_read_pcm_frames(&decoder, pcmData.data(), totalFrames, &framesRead);
+    ma_decoder_uninit(&decoder);
+
+    if (result != MA_SUCCESS) {
+        std::cerr << "Failed to read PCM frames" << std::endl;
+        return false;
+    }
+
+    if (framesRead != totalFrames) {
+        std::cerr << "Warning: Frames read (" << framesRead << ") != total frames (" << totalFrames << ")" << std::endl;
+    }
+
+    return framesRead > 0;
+}
+
+
+std::vector<double> HybridTest::computeAmplitude(const std::string& filePath, double outputSampleCount = 1000) {
+    size_t outputSampleCountInt = static_cast<size_t>(outputSampleCount);
+    std::vector<float> pcm;
+    unsigned int sampleRate = 0;
+
+    // Decode audio file into PCM data
+    if (!decodeAudioFile(filePath, pcm, sampleRate)) {
+        __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "Failed to decode audio file for amplitude computation: %s", filePath.c_str());
+        return {};
+    }
+
+    std::vector<double> result;
+
+    size_t totalSamples = pcm.size();
+    if (totalSamples == 0 || outputSampleCount == 0) {
+        // Return empty result if no samples or zero output requested
+        return result;
+    }
+
+    // Calculate base block size and remainder to evenly split PCM into outputSampleCount blocks
+    size_t baseBlockSize = totalSamples / outputSampleCount;
+    size_t remainder = totalSamples % outputSampleCountInt;
+
+    size_t offset = 0;
+    for (size_t i = 0; i < outputSampleCount; ++i) {
+        // Distribute remainder samples to the first 'remainder' blocks for even split
+        size_t currentBlockSize = baseBlockSize + (i < remainder ? 1 : 0);
+
+        if (currentBlockSize == 0) {
+            // If block size is zero (e.g., outputSampleCount > totalSamples), push zero amplitude
+            result.push_back(0.0);
+            continue;
+        }
+
+        double sum = 0.0;
+        // Sum absolute values of samples in the current block
+        for (size_t j = 0; j < currentBlockSize; ++j) {
+            sum += std::abs(pcm[offset + j]);
+        }
+        // Compute average amplitude for the block
+        double avg = sum / currentBlockSize;
+        result.push_back(avg);
+
+        // Move offset forward by current block size
+        offset += currentBlockSize;
+    }
+
+    return result;
+}

cpp/HybridTest.cpp

@@ -0,0 +1,13 @@
+#include "HybridTestSpec.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::test {
+    struct HybridTest: public HybridTestSpec {
+        HybridTest() : HybridObject(TAG) {}
+        std::vector<double> computeAmplitude(const std::string& filePath, double samplesPerBlock) override;
+
+        bool decodeAudioFile(const std::string& filePath, std::vector<float>& pcmData, unsigned int& sampleRate);
+    };
+}
+

cpp/HybridTest.hpp

@@ -1,20 +1,49 @@
-import { Text, View, StyleSheet } from 'react-native';
-import { multiply } from 'react-native-test';
-
-const result = multiply(3, 7);
+import { useCallback, useEffect, useState } from 'react';
+import { View, StyleSheet, ScrollView } from 'react-native';
+import { computeAmplitude } from 'react-native-test';
 
 export default function App() {
+  const [data, setData] = useState<number[]>([]);
+  const run = useCallback(async () => {
+    try {
+      const result = computeAmplitude(
+        '/data/data/test.example/files/sample-15s.mp3',
+        1000
+      );
+      setData(result);
+    } catch (raw) {
+      console.log(raw);
+    }
+  }, []);
+
+  useEffect(() => {
+    // noinspection JSIgnoredPromiseFromCall
+    run();
+  }, [run]);
+
   return (
-    <View style={styles.container}>
-      <Text>Result: {result}</Text>
-    </View>
+    <ScrollView horizontal contentContainerStyle={styles.root}>
+      <View style={styles.container}>
+        {data.map((item, index) => (
+          <View key={index} style={[styles.item, { height: 500 * item }]} />
+        ))}
+      </View>
+    </ScrollView>
   );
 }
 
 const styles = StyleSheet.create({
+  root: {
+    flexGrow: 1,
+  },
   container: {
     flex: 1,
+    columnGap: 1,
+    flexDirection: 'row',
     alignItems: 'center',
-    justifyContent: 'center',
+  },
+  item: {
+    width: 3,
+    backgroundColor: 'red',
   },
 });

example/src/App.tsx

@@ -1,4 +1,5 @@
 {
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
   "cxxNamespace": ["test"],
   "ios": {
     "iosModuleName": "Test"
@@ -9,8 +10,7 @@
   },
   "autolinking": {
     "Test": {
-      "swift": "Test",
-      "kotlin": "Test"
+      "cpp": "HybridTest"
     }
   },
   "ignorePaths": ["node_modules"]

nitro.json

@@ -1,6 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 
-export interface Test
-  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
-  multiply(a: number, b: number): number;
+export interface Test extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  computeAmplitude(filePath: string, outputSampleCount: number): number[];
 }