feat: introduce FileSystem module with load method for file caching

Author: exzos

android/src/main/java/com/margelo/nitro/audioanalyzer/FileSystem.kt

@@ -0,0 +1,45 @@
+package com.margelo.nitro.audioanalyzer
+
+import android.content.Context
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import java.io.File
+import java.net.URL
+import java.security.MessageDigest
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.NitroModules
+
+@DoNotStrip
+class FileSystem(reactContext: ReactApplicationContext) :
+  HybridFileSystemSpec() {
+
+  private val appContext = reactContext.applicationContext
+
+  override fun load(path: String): Promise<String> {
+    return Promise.parallel {
+      try {
+        val url = URL(path)
+        val connection = url.openConnection()
+        val fileName = path.substringAfterLast('/')
+        val fileSize = connection.contentLength
+        val key = "$fileName-$fileSize"
+
+        val digest = MessageDigest.getInstance("MD5")
+        val hash = digest.digest(key.toByteArray())
+          .joinToString("") { "%02x".format(it) }
+
+        val file = File(NitroModules.applicationContext!!.cacheDir, "$hash.audio")
+
+        if (!file.exists()) {
+          url.openStream().use { input ->
+            file.outputStream().use { output -> input.copyTo(output) }
+          }
+        }
+
+        file.absolutePath
+      } catch (e: Exception) {
+        throw RuntimeException("Failed to load and cache file", e)
+      }
+    }
+  }
+}

cpp/AudioAnalyzer.cpp cpp/Processor.cppcpp/AudioAnalyzer.cpp renamed to cpp/Processor.cpp

@@ -1,15 +1,15 @@
-#include "AudioAnalyzer.hpp"
+#include "Processor.hpp"
 #include "miniaudio.h"
 
 #include <cmath>
 #include <iostream>
 #include <algorithm>
 
-#define LOG_TAG "HybridAudioAnalyzer"
+#define LOG_TAG "HybridProcessor"
 
 using namespace margelo::nitro::audioanalyzer;
 
-bool AudioAnalyzer::decodeAudioFile(const std::string &filePath, std::vector<float> &pcmData, unsigned int &sampleRate)
+bool Processor::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);
@@ -51,7 +51,7 @@ bool AudioAnalyzer::decodeAudioFile(const std::string &filePath, std::vector<flo
     return framesRead > 0;
 }
 
-std::vector<double> AudioAnalyzer::computeAmplitude(const std::string &filePath, double outputSampleCount = 1000)
+std::vector<double> Processor::computeAmplitude(const std::string &filePath, double outputSampleCount = 1000)
 {
     size_t outputSampleCountInt = static_cast<size_t>(outputSampleCount);
     std::vector<float> pcm;

cpp/AudioAnalyzer.hpp cpp/Processor.hppcpp/AudioAnalyzer.hpp renamed to cpp/Processor.hpp

@@ -1,10 +1,10 @@
-#include "HybridAudioAnalyzerSpec.hpp"
+#include "HybridProcessorSpec.hpp"
 #include <string>
 #include <vector>
 
 namespace margelo::nitro::audioanalyzer {
-struct AudioAnalyzer: public audioanalyzer::HybridAudioAnalyzerSpec {
-        AudioAnalyzer() : HybridObject(TAG) {}
+struct Processor: public audioanalyzer::HybridProcessorSpec {
+        Processor() : 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);

ios/FileSystem.swift

@@ -0,0 +1,41 @@
+import Foundation
+import CryptoKit
+import NitroModules
+
+class FileSystem: HybridFileSystemSpec {
+  func load(path: String) -> Promise<String> {
+    return Promise.async {
+        guard let url = URL(string: path) else {
+            throw NSError(domain: "FileSystem", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])
+        }
+
+        // HEAD request to get file size
+        var request = URLRequest(url: url)
+        request.httpMethod = "HEAD"
+        let (_, response) = try await URLSession.shared.data(for: request)
+
+        var fileSize: Int64 = 0
+        if let httpResponse = response as? HTTPURLResponse,
+           let lengthString = httpResponse.value(forHTTPHeaderField: "Content-Length"),
+           let length = Int64(lengthString) {
+            fileSize = length
+        }
+
+        // Compute hash based on file name and size
+        let fileName = url.lastPathComponent
+        let key = "\(fileName)-\(fileSize)"
+        let hash = Insecure.MD5.hash(data: Data(key.utf8)).map { String(format: "%02x", $0) }.joined()
+
+        // Cache file path
+        let cacheDir = FileManager.default.temporaryDirectory
+        let fileURL = cacheDir.appendingPathComponent("\(hash).audio")
+
+        if !FileManager.default.fileExists(atPath: fileURL.path) {
+            let (data, _) = try await URLSession.shared.data(from: url)
+            try data.write(to: fileURL)
+        }
+
+        return fileURL.path
+    }
+  }
+}

nitro.json

@@ -8,8 +8,12 @@
     "androidCxxLibName": "audioanalyzer"
   },
   "autolinking": {
-    "AudioAnalyzer": {
-      "cpp": "AudioAnalyzer"
+    "Processor": {
+      "cpp": "Processor"
+    },
+    "FileSystem": {
+      "swift": "FileSystem",
+      "kotlin": "FileSystem"
     }
   },
   "ignorePaths": ["node_modules"]

src/FileSystem.nitro.ts

@@ -0,0 +1,9 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface FileSystem
+  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  /**
+   * Downloads and caches the file.
+   */
+  load(path: string): Promise<string>;
+}

src/AudioAnalyzer.nitro.ts src/Processor.nitro.tssrc/AudioAnalyzer.nitro.ts renamed to src/Processor.nitro.ts

@@ -1,6 +1,6 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 
-export interface AudioAnalyzer
+export interface Processor
   extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
-  computeAmplitude(filePath: string, outputSampleCount: number): number[];
+  computeAmplitude(source: string, outputSampleCount: number): number[];
 }

src/index.ts

@@ -1,9 +1,22 @@
 import { NitroModules } from 'react-native-nitro-modules';
-import type { AudioAnalyzer } from './AudioAnalyzer.nitro';
+import type { Processor } from './Processor.nitro';
+import type { FileSystem } from './FileSystem.nitro';
 
-const AnalyzerHybridObject =
-  NitroModules.createHybridObject<AudioAnalyzer>('AudioAnalyzer');
+const AudioAnalyzerHybridObject =
+  NitroModules.createHybridObject<Processor>('Processor');
 
-export function computeAmplitude(filePath: string, outputSampleCount: number) {
-  return AnalyzerHybridObject.computeAmplitude(filePath, outputSampleCount);
+const FileSystemHybridObject =
+  NitroModules.createHybridObject<FileSystem>('FileSystem');
+
+function computeAmplitude(filePath: string, outputSampleCount: number) {
+  return AudioAnalyzerHybridObject.computeAmplitude(
+    filePath,
+    outputSampleCount
+  );
+}
+
+function load(path: string) {
+  return FileSystemHybridObject.load(path);
 }
+
+export { load, computeAmplitude };