capacitor-voice-recorder-wav-stereo 7.0.0

package/CapacitorVoiceRecorderWavStereo.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorVoiceRecorderWavStereo'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/README.md

@@ -0,0 +1,213 @@
+<p align="center">
+  <img src="https://user-images.githubusercontent.com/236501/85893648-1c92e880-b7a8-11ea-926d-95355b8175c7.png" width="128" height="128" />
+</p>
+<h3 align="center">Capacitor Voice Recorder</h3>
+<p align="center"><strong><code>tchvu3/capacitor-voice-recorder</code></strong></p>
+<p align="center">Capacitor plugin for simple voice recording (For Capacitor 5)</p>
+
+<p align="center">
+  <img src="https://img.shields.io/maintenance/yes/2023" />
+  <a href="https://www.npmjs.com/package/capacitor-voice-recorder"><img src="https://img.shields.io/npm/l/capacitor-voice-recorder" /></a>
+<br>
+  <a href="https://www.npmjs.com/package/capacitor-voice-recorder"><img src="https://img.shields.io/npm/dw/capacitor-voice-recorder" /></a>
+  <a href="https://www.npmjs.com/package/capacitor-voice-recorder"><img src="https://img.shields.io/npm/v/capacitor-voice-recorder" /></a>
+</p>
+
+## Maintainers
+
+| Maintainer | GitHub |
+| -----------| -------|
+| Avihu Harush | [tchvu3](https://github.com/tchvu3) |
+
+## Installation
+
+```
+npm install --save capacitor-voice-recorder
+npx cap sync
+```
+
+#### ios note
+
+Make sure to include the ```NSMicrophoneUsageDescription```
+key, and a corresponding purpose string in your app's Info.plist
+
+## Configuration
+
+No configuration required for this plugin.
+
+## Supported methods
+
+| Name | Android | iOS | Web |
+| :------------------------------ | :------ | :-- | :-- |
+| canDeviceVoiceRecord | ✅ | ✅ | ✅ |
+requestAudioRecordingPermission | ✅ | ✅ | ✅ |
+| hasAudioRecordingPermission | ✅ | ✅ | ✅ |
+| startRecording | ✅ | ✅ | ✅ |
+| stopRecording | ✅ | ✅ | ✅ |
+| pauseRecording | ✅ | ✅ | ✅ |
+| resumeRecording | ✅ | ✅ | ✅ |
+| getCurrentStatus | ✅ | ✅ | ✅ |
+
+## Explanation
+
+* canDeviceVoiceRecord - on mobile this function will always return a promise that resolves to `{ value: true }`,
+  while in a browser it will be resolved to `{ value: true }` / `{ value: false }` based on the browser's ability to record.
+  note that this method does not take into account the permission status,
+  only if the browser itself is capable of recording at all.
+
+---
+
+* requestAudioRecordingPermission - if the permission has already been provided then the promise will resolve with `{ value: true }`,
+  otherwise the promise will resolve to `{ value: true }` / `{ value: false }` based on the answer of the user to the request.
+
+---
+
+* hasAudioRecordingPermission - will resolve to `{ value: true }` / `{ value: false }` based on the status of the permission.
+  please note that the web implementation of this plugin uses the Permissions API under the hood which is not widespread as of now.
+  as a result, if the status of the permission cannot be checked the promise will reject with `COULD_NOT_QUERY_PERMISSION_STATUS`.
+  in that case you have no choice but to use the `requestAudioRecordingPermission` function straight away or `startRecording` and capture any exception that is thrown.
+
+---
+
+* startRecording - if the app lacks the required permission then the promise will reject with the message `MISSING_PERMISSION`.
+  if the current device cannot voice record at all (for example, due to old browser) then the promise will reject with `DEVICE_CANNOT_VOICE_RECORD`.
+  if there's a recording already running then the promise will reject with `ALREADY_RECORDING`,
+  and if other apps are using the microphone then the promise will reject
+  with `MICROPHONE_BEING_USED`. in a case of unknown error the promise will reject with `FAILED_TO_RECORD`.
+
+---
+
+* stopRecording - will stop the recording that has been previously started. if the function `startRecording` has not been called beforehand
+  the promise will reject with `RECORDING_HAS_NOT_STARTED`.
+  if the recording has been stopped immediately after it has been started the promise will reject with `EMPTY_RECORDING`.
+  in a case of unknown error the promise will reject with `FAILED_TO_FETCH_RECORDING`.
+  in case of success, you will get the recording in base-64, the duration of the
+  recording in milliseconds, and the mime type.
+
+---
+
+* pauseRecording - will pause an ongoing recording. note that if the recording has not started yet the promise
+  will reject with `RECORDING_HAS_NOT_STARTED`. in case of success the promise will resolve to `{ value: true }` if the pause
+  was successful or `{ value: false }` if the recording is already paused.
+  note that on certain mobile os versions this function is not supported.
+  in these cases the function will reject with `NOT_SUPPORTED_OS_VERSION` and your only viable options is to stop the recording instead.
+
+---
+
+* resumeRecording - will resume a paused recording. note that if the recording has not started yet the promise
+  will reject with `RECORDING_HAS_NOT_STARTED`. in case of success the promise will resolve to `{ value: true }` if the resume
+  was successful or `{ value: false }` if the recording is already running.
+  note that on certain mobile os versions this function is not supported.
+  in these cases the function will reject with `NOT_SUPPORTED_OS_VERSION` and your only viable options is to stop the recording instead
+
+---
+
+* getCurrentStatus - will let you know the current status of the current recording (if there is any at all).
+  will resolve with one of the following values: `{ status: "NONE" }` if the plugin is idle and waiting to start a new recording.
+  `{ status: "RECORDING" }` if the plugin is in the middle of recording and `{ status: "PAUSED" }` if the recording is paused right now.
+
+## Usage
+
+```
+
+// only 'VoiceRecorder' is mandatory, the rest is for typing
+import { VoiceRecorder, VoiceRecorderPlugin, RecordingData, GenericResponse, CurrentRecordingStatus } from 'capacitor-voice-recorder';
+
+// will print true / false based on the ability of the current device (or web browser) to record audio
+VoiceRecorder.canDeviceVoiceRecord().then((result: GenericResponse) => console.log(result.value))
+
+/**
+* will prompt the user to give the required permission, after that
+* the function will print true / false based on the user response
+*/
+VoiceRecorder.requestAudioRecordingPermission().then((result: GenericResponse) => console.log(result.value))
+
+/**
+* will print true / false based on the status of the recording permission.
+* the promise will reject with "COULD_NOT_QUERY_PERMISSION_STATUS"
+* if the current device cannot query the current status of the recording permission
+*/
+VoiceRecorder.hasAudioRecordingPermission.then((result: GenericResponse) => console.log(result.value))
+
+/**
+* In case of success the promise will resolve to { value: true }
+* in case of an error the promise will reject with one of the following messages:
+* "MISSING_PERMISSION", "ALREADY_RECORDING", "MICROPHONE_BEING_USED", "DEVICE_CANNOT_VOICE_RECORD", or "FAILED_TO_RECORD"
+*/
+VoiceRecorder.startRecording()
+.then((result: GenericResponse) => console.log(result.value))
+.catch(error => console.log(error))
+
+/**
+* In case of success the promise will resolve to:
+* {"value": { recordDataBase64: string, msDuration: number, mimeType: string }},
+* the file will be in one of several possible formats (more on that later).
+* in case of an error the promise will reject with one of the following messages:
+* "RECORDING_HAS_NOT_STARTED" or "FAILED_TO_FETCH_RECORDING"
+*/
+VoiceRecorder.stopRecording()
+.then((result: RecordingData) => console.log(result.value))
+.catch(error => console.log(error))
+
+/**
+* will pause an ongoing recording. note that if the recording has not started yet the promise
+* will reject with `RECORDING_HAS_NOT_STARTED`. in case of success the promise will resolve to `{ value: true }` if the pause
+* was successful or `{ value: false }` if the recording is already paused.
+* if the current mobile os does not support this method the promise will reject with `NOT_SUPPORTED_OS_VERSION`
+*/
+VoiceRecorder.pauseRecording()
+.then((result: GenericResponse) => console.log(result.value))
+.catch(error => console.log(error))
+
+/**
+* will resume a paused recording. note that if the recording has not started yet the promise
+* will reject with `RECORDING_HAS_NOT_STARTED`. in case of success the promise will resolve to `{ value: true }` if the resume
+* was successful or `{ value: false }` if the recording is already running.
+* if the current mobile os does not support this method the promise will reject with `NOT_SUPPORTED_OS_VERSION`
+*/
+VoiceRecorder.resumeRecording()
+.then((result: GenericResponse) => console.log(result.value))
+.catch(error => console.log(error))
+
+/**
+* Will return the current status of the plugin.
+* in this example one of these possible values will be printed: "NONE" / "RECORDING" / "PAUSED"
+*/
+VoiceRecorder.getCurrentStatus()
+.then((result: CurrentRecordingStatus) => console.log(result.status))
+.catch(error => console.log(error))
+
+```
+
+## Format and Mime type
+
+The plugin will return the recording in one of several possible formats.
+the format is dependent on the os / web browser that the user uses.
+on android and ios the mime type will be `audio/aac`, while on chrome and firefox it
+will be `audio/webm;codecs=opus` and on safari it will be `audio/mp4`.
+note that these 3 browsers has been tested on. the plugin should still work on
+other browsers, as there is a list of mime types that the plugin checks against the
+user's browser.
+
+Note that this fact might cause unexpected behavior in case you'll try to play recordings
+between several devices or browsers - as they not all support the same set of audio formats.
+it is recommended to convert the recordings to a format that all your target devices supports.
+as this plugin focuses on the recording aspect, it does not provide any conversion between formats.
+
+## Playback
+
+To play the recorded file you can use plain javascript:
+
+```
+const base64Sound = '...' // from plugin
+const mimeType = '...'  // from plugin
+const audioRef = new Audio(`data:${mimeType};base64,${base64Sound}`)
+audioRef.oncanplaythrough = () => audioRef.play()
+audioRef.load()
+```
+
+## Donation
+
+If you enjoy my work and find it useful, feel free to invite me to a cup of coffee :)
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/tchvu3)

package/android/build.gradle

@@ -0,0 +1,58 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.tchvu3.capacitorvoicerecorder"
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 33
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

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/com/tchvu3/capacitorvoicerecorder/CurrentRecordingStatus.java

@@ -0,0 +1,7 @@
+package com.tchvu3.capacitorvoicerecorder;
+
+public enum CurrentRecordingStatus {
+
+    RECORDING, PAUSED, NONE
+
+}

package/android/src/main/java/com/tchvu3/capacitorvoicerecorder/CustomMediaRecorder.java

@@ -0,0 +1,187 @@
+package com.tchvu3.capacitorvoicerecorder;
+
+import android.content.Context;
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.MediaRecorder;
+import android.os.Build;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+
+public class CustomMediaRecorder {
+
+    private final Context context;
+    private AudioRecord audioRecord;
+    private File outputFile;
+    private CurrentRecordingStatus currentRecordingStatus = CurrentRecordingStatus.NONE;
+    private Thread recordingThread;
+    private boolean isRecording = false;
+
+    private static final int SAMPLE_RATE = 44100;
+    private static final int CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_STEREO;
+    private static final int AUDIO_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+
+    public CustomMediaRecorder(Context context) {
+        this.context = context;
+    }
+
+    public void initializeAudioRecord() throws IOException {
+        int minBufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_CONFIG, AUDIO_FORMAT);
+        try {
+            audioRecord = new AudioRecord(MediaRecorder.AudioSource.DEFAULT, SAMPLE_RATE, CHANNEL_CONFIG, AUDIO_FORMAT, minBufferSize);
+        } catch (SecurityException e) {
+            throw new IOException("Missing permission to record audio", e);
+        }
+        setRecorderOutputFile();
+    }
+
+    private void setRecorderOutputFile() throws IOException {
+        File outputDir = context.getCacheDir();
+        outputFile = File.createTempFile("voice_record_temp", ".wav", outputDir);
+        outputFile.deleteOnExit();
+    }
+
+    public void startRecording() throws IOException {
+        if (audioRecord == null) {
+            initializeAudioRecord();
+        }
+        audioRecord.startRecording();
+        isRecording = true;
+        currentRecordingStatus = CurrentRecordingStatus.RECORDING;
+
+        recordingThread = new Thread(this::writeAudioDataToFile, "AudioRecorder Thread");
+        recordingThread.start();
+    }
+
+    private void writeAudioDataToFile() {
+        byte[] data = new byte[AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_CONFIG, AUDIO_FORMAT)];
+        FileOutputStream os = null;
+        try {
+            os = new FileOutputStream(outputFile);
+            while (isRecording) {
+                int read = audioRecord.read(data, 0, data.length);
+                if (AudioRecord.ERROR_INVALID_OPERATION != read) {
+                    os.write(data);
+                }
+            }
+        } catch (IOException e) {
+            Log.e("CustomMediaRecorder", "Error writing audio data to file", e);
+        } finally {
+            try {
+                if (os != null) {
+                    os.close();
+                }
+            } catch (IOException e) {
+                Log.e("CustomMediaRecorder", "Error closing output stream", e);
+            }
+        }
+    }
+
+    public void stopRecording() {
+        if (audioRecord != null) {
+            isRecording = false;
+            audioRecord.stop();
+            audioRecord.release();
+            audioRecord = null;
+            recordingThread = null;
+            currentRecordingStatus = CurrentRecordingStatus.NONE;
+            writeWavHeader();
+        }
+    }
+
+    private void writeWavHeader() {
+        try {
+            FileInputStream fis = new FileInputStream(outputFile);
+            byte[] audioData = new byte[(int) outputFile.length()];
+            int bytesRead = fis.read(audioData);
+            if (bytesRead < 0) {
+                Log.e("CustomMediaRecorder", "Error reading audio data from file");
+            } else if (bytesRead < audioData.length) {
+                Log.w("CustomMediaRecorder", "Audio data size mismatch");
+            }
+            fis.close();
+            byte[] header = createWavHeader(audioData.length);
+            FileOutputStream os = new FileOutputStream(outputFile);
+            os.write(header);
+            os.write(audioData);
+            os.close();
+        } catch (IOException e) {
+            Log.e("CustomMediaRecorder", "Error writing audio data to file", e);
+        }
+    }
+
+    private byte[] createWavHeader(int audioLength) {
+        int totalLength = audioLength + 36;
+        byte[] header = new byte[44];
+        ByteBuffer buffer = ByteBuffer.wrap(header).order(ByteOrder.LITTLE_ENDIAN);
+
+        buffer.put("RIFF".getBytes());
+        buffer.putInt(totalLength);
+        buffer.put("WAVE".getBytes());
+        buffer.put("fmt ".getBytes());
+        buffer.putInt(16);
+        buffer.putShort((short) 1);
+        buffer.putShort((short) 2);
+        buffer.putInt(SAMPLE_RATE);
+        buffer.putInt(SAMPLE_RATE * 2 * 2);
+        buffer.putShort((short) 4);
+        buffer.putShort((short) 16);
+        buffer.put("data".getBytes());
+        buffer.putInt(audioLength);
+
+        return header;
+    }
+
+    public File getOutputFile() {
+        return outputFile;
+    }
+
+    public boolean pauseRecording() throws NotSupportedOsVersion {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+            throw new NotSupportedOsVersion();
+        }
+
+        if (currentRecordingStatus == CurrentRecordingStatus.RECORDING) {
+            isRecording = false;
+            currentRecordingStatus = CurrentRecordingStatus.PAUSED;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean resumeRecording() throws NotSupportedOsVersion {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+            throw new NotSupportedOsVersion();
+        }
+
+        if (currentRecordingStatus == CurrentRecordingStatus.PAUSED) {
+            isRecording = true;
+            currentRecordingStatus = CurrentRecordingStatus.RECORDING;
+            recordingThread = new Thread(this::writeAudioDataToFile, "AudioRecorder Thread");
+            recordingThread.start();
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public CurrentRecordingStatus getCurrentStatus() {
+        return currentRecordingStatus;
+    }
+
+    public boolean deleteOutputFile() {
+        return outputFile.delete();
+    }
+
+    public static boolean canPhoneCreateMediaRecorder(Context ignoredContext) {
+        return true;
+    }
+}

package/android/src/main/java/com/tchvu3/capacitorvoicerecorder/Messages.java

@@ -0,0 +1,15 @@
+package com.tchvu3.capacitorvoicerecorder;
+
+public abstract class Messages {
+
+    public static final String MISSING_PERMISSION = "MISSING_PERMISSION";
+    public static final String CANNOT_RECORD_ON_THIS_PHONE = "CANNOT_RECORD_ON_THIS_PHONE";
+    public static final String FAILED_TO_RECORD = "FAILED_TO_RECORD";
+    public static final String RECORDING_HAS_NOT_STARTED = "RECORDING_HAS_NOT_STARTED";
+    public static final String FAILED_TO_FETCH_RECORDING = "FAILED_TO_FETCH_RECORDING";
+    public static final String NOT_SUPPORTED_OS_VERSION = "NOT_SUPPORTED_OS_VERSION";
+    public static final String ALREADY_RECORDING = "ALREADY_RECORDING";
+    public static final String EMPTY_RECORDING = "EMPTY_RECORDING";
+    public static final String MICROPHONE_BEING_USED = "MICROPHONE_BEING_USED";
+
+}

package/android/src/main/java/com/tchvu3/capacitorvoicerecorder/NotSupportedOsVersion.java

@@ -0,0 +1,4 @@
+package com.tchvu3.capacitorvoicerecorder;
+
+public class NotSupportedOsVersion extends Exception {
+}

package/android/src/main/java/com/tchvu3/capacitorvoicerecorder/RecordData.java

@@ -0,0 +1,51 @@
+package com.tchvu3.capacitorvoicerecorder;
+
+import com.getcapacitor.JSObject;
+
+public class RecordData {
+
+    private String recordDataBase64;
+    private String mimeType;
+    private int msDuration;
+
+    public RecordData() {
+    }
+
+    public RecordData(String recordDataBase64, int msDuration, String mimeType) {
+        this.recordDataBase64 = recordDataBase64;
+        this.msDuration = msDuration;
+        this.mimeType = mimeType;
+    }
+
+    public String getRecordDataBase64() {
+        return recordDataBase64;
+    }
+
+    public void setRecordDataBase64(String recordDataBase64) {
+        this.recordDataBase64 = recordDataBase64;
+    }
+
+    public int getMsDuration() {
+        return msDuration;
+    }
+
+    public void setMsDuration(int msDuration) {
+        this.msDuration = msDuration;
+    }
+
+    public String getMimeType() {
+        return mimeType;
+    }
+
+    public void setMimeType(String mimeType) {
+        this.mimeType = mimeType;
+    }
+
+    public JSObject toJSObject() {
+        JSObject toReturn = new JSObject();
+        toReturn.put("recordDataBase64", recordDataBase64);
+        toReturn.put("msDuration", msDuration);
+        toReturn.put("mimeType", mimeType);
+        return toReturn;
+    }
+}

package/android/src/main/java/com/tchvu3/capacitorvoicerecorder/ResponseGenerator.java

@@ -0,0 +1,37 @@
+package com.tchvu3.capacitorvoicerecorder;
+
+import com.getcapacitor.JSObject;
+
+public class ResponseGenerator {
+
+    private static final String VALUE_RESPONSE_KEY = "value";
+    private static final String STATUS_RESPONSE_KEY = "status";
+
+    public static JSObject fromBoolean(boolean value) {
+        return value ? successResponse() : failResponse();
+    }
+
+    public static JSObject successResponse() {
+        JSObject success = new JSObject();
+        success.put(VALUE_RESPONSE_KEY, true);
+        return success;
+    }
+
+    public static JSObject failResponse() {
+        JSObject success = new JSObject();
+        success.put(VALUE_RESPONSE_KEY, false);
+        return success;
+    }
+
+    public static JSObject dataResponse(Object data) {
+        JSObject success = new JSObject();
+        success.put(VALUE_RESPONSE_KEY, data);
+        return success;
+    }
+
+    public static JSObject statusResponse(CurrentRecordingStatus status) {
+        JSObject success = new JSObject();
+        success.put(STATUS_RESPONSE_KEY, status.name());
+        return success;
+    }
+}