recorder-metering (react-native-audio-toolkit#221)

tbenr · web-flow · commit b4495caffd55 · 2020-07-19T16:28:57.000+10:00
diff --git a/android/src/main/java/com/reactnativecommunity/rctaudiotoolkit/AudioRecorderModule.java b/android/src/main/java/com/reactnativecommunity/rctaudiotoolkit/AudioRecorderModule.java
@@ -2,16 +2,13 @@
 
 import android.annotation.TargetApi;
 import android.media.MediaRecorder;
-import android.os.Build;
-import android.os.Environment;
 import android.util.Log;
 import android.net.Uri;
 import android.webkit.URLUtil;
 import android.content.ContextWrapper;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.Callback;
@@ -23,11 +20,12 @@
 import java.io.IOException;
 import java.io.File;
 import java.lang.Thread;
-import java.net.URISyntaxException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Objects;
+import java.util.Timer;
+import java.util.TimerTask;
 
 public class AudioRecorderModule extends ReactContextBaseJavaModule implements
         MediaRecorder.OnInfoListener, MediaRecorder.OnErrorListener {
@@ -37,6 +35,11 @@ public class AudioRecorderModule extends ReactContextBaseJavaModule implements
     Map<Integer, Boolean> recorderAutoDestroy = new HashMap<>();
 
     private ReactApplicationContext context;
+    private Timer meteringUpdateTimer;
+    private int meteringFrameId = 0;
+    private Integer meteringRecorderId = null;
+    private MediaRecorder meteringRecorder = null;
+    private int meteringInterval = 0;
 
     public AudioRecorderModule(ReactApplicationContext reactContext) {
         super(reactContext);
@@ -140,6 +143,39 @@ private Uri uriFromPath(String path) {
 
         return uri;
     }
+    
+    // metering methods
+    private void startMeteringTimer(int monitorInterval) {
+        meteringUpdateTimer = new Timer();
+        meteringUpdateTimer.scheduleAtFixedRate(new TimerTask() {
+            @Override
+            public void run() {
+                if(meteringRecorderId != null && meteringRecorder != null) {
+                    WritableMap body = Arguments.createMap();
+                    body.putDouble("id", meteringFrameId++);
+
+                    int amplitude = meteringRecorder.getMaxAmplitude();
+                    if (amplitude == 0) {
+                        body.putInt("value", -160);
+                        body.putInt("rawValue", 0);
+                    } else {
+                        body.putInt("rawValue", amplitude);
+                        body.putInt("value", (int) (20 * Math.log10(((double) amplitude) / 32767d)));
+                    }
+                    emitEvent(meteringRecorderId, "meter", body);
+                }
+            }
+        }, 0, monitorInterval);
+    }
+
+    private void stopMeteringTimer() {
+        if (meteringUpdateTimer != null) {
+            meteringUpdateTimer.cancel();
+            meteringUpdateTimer.purge();
+            meteringUpdateTimer = null;
+            meteringFrameId = 0;
+        }
+    }
 
     @ReactMethod
     public void destroy(Integer recorderId, Callback callback) {
@@ -149,6 +185,10 @@ public void destroy(Integer recorderId, Callback callback) {
             recorder.release();
             this.recorderPool.remove(recorderId);
             this.recorderAutoDestroy.remove(recorderId);
+            if(recorderId == meteringRecorderId) {
+                meteringRecorderId = null;
+                meteringRecorder = null;
+            }
 
             WritableMap data = new WritableNativeMap();
             data.putString("message", "Destroyed recorder");
@@ -240,6 +280,20 @@ public void prepare(Integer recorderId, String path, ReadableMap options, Callba
         } catch (IOException e) {
             callback.invoke(errObj("preparefail", e.toString()));
         }
+
+        if (options.hasKey("meteringInterval")) {
+            int meteringInterval = options.getInt("meteringInterval");
+            if (meteringRecorderId != null) {
+                Log.i(LOG_TAG, "multiple recorder metering are not currently supporter. Metering will be active on the last recorder.");
+            }
+            if(meteringInterval <= 0) {
+                Log.w(LOG_TAG, "metering interval must be grater then 0. Ignoring metering");
+            } else {
+                meteringRecorder = recorder;
+                meteringRecorderId = recorderId;
+                this.meteringInterval = meteringInterval;
+            }
+        }
     }
 
     @ReactMethod
@@ -251,6 +305,9 @@ public void record(Integer recorderId, Callback callback) {
         }
 
         try {
+            if(recorderId == meteringRecorderId) {
+                startMeteringTimer(meteringInterval);
+            }
             recorder.start();
 
             callback.invoke();
@@ -268,6 +325,9 @@ public void stop(Integer recorderId, Callback callback) {
         }
 
         try {
+            if(recorderId == meteringRecorderId) {
+                stopMeteringTimer();
+            }
             recorder.stop();
             if (this.recorderAutoDestroy.get(recorderId)) {
                 Log.d(LOG_TAG, "Autodestroying recorder...");
@@ -298,6 +358,9 @@ private void pause24(Integer recorderId, Callback callback) {
         }
 
         try {
+            if(recorderId == meteringRecorderId) {
+                stopMeteringTimer();
+            }
             recorder.pause();
             if (this.recorderAutoDestroy.get(recorderId)) {
                 Log.d(LOG_TAG, "Autodestroying recorder...");
diff --git a/docs/API.md b/docs/API.md
@@ -220,6 +220,11 @@ Player.isPrepared   true if player is prepared
       // Quality of the recording, iOS only.
       // Possible values: 'min', 'low', 'medium', 'high', 'max'
       quality : String (default: 'medium')
+
+      // Optional argument to activate metering events
+      // this will cause 'meter' event to fire everi given milliseconds.
+      // i.e. 250 will fire 4 time in a second.
+      meteringInterval : Number (default: undefined)
     }
     ```
 
@@ -310,6 +315,15 @@ are supported:
 
 * `looped` - Playback of a file has looped.
 
+* `meter` - recurring event during recording session (see `meteringInterval` in `recorderOptions`). `data` associated to this event follows the format:
+    ```js
+    {
+        "id",             // frame number
+        "value",          // sound level in decibels, -160 is a silence level
+        "rawValue"        // raw level value, OS-dependent
+    }
+    ```
+    **Currently, only one recored at a time generates meter events. Last prepared Recorder wins.**
 
 Listen to these events with  `player.on('eventname', callback(data))`.  Data
 may contain additional information about the event, for example a more detailed
diff --git a/ios/ReactNativeAudioToolkit/ReactNativeAudioToolkit/AudioRecorder.m b/ios/ReactNativeAudioToolkit/ReactNativeAudioToolkit/AudioRecorder.m
@@ -21,11 +21,19 @@ @interface AudioRecorder () <AVAudioRecorderDelegate>
 
 @end
 
-@implementation AudioRecorder
+@implementation AudioRecorder {
+    id _meteringUpdateTimer;
+    int _meteringFrameId;
+    int _meteringUpdateInterval;
+    NSNumber *_meteringRecorderId;
+    AVAudioRecorder *_meteringRecorder;
+    NSDate *_prevMeteringUpdateTime;
+}
 
 @synthesize bridge = _bridge;
 
 - (void)dealloc {
+    [self stopMeteringTimer];
     AVAudioSession *audioSession = [AVAudioSession sharedInstance];
     NSError *error = nil;
     [audioSession setActive:NO error:&error];
@@ -47,6 +55,53 @@ -(NSNumber *) keyForRecorder:(nonnull AVAudioRecorder*)recorder {
     return [[_recorderPool allKeysForObject:recorder] firstObject];
 }
 
+#pragma mark - Metering functions
+
+- (void)stopMeteringTimer {
+    [_meteringUpdateTimer invalidate];
+    _meteringFrameId = 0;
+    _prevMeteringUpdateTime = nil;
+    _meteringRecorderId = nil;
+    _meteringRecorder = nil;
+}
+
+- (void)startMeteringTimer:(int)monitorInterval {
+    _meteringUpdateInterval = monitorInterval;
+
+    [self stopMeteringTimer];
+
+    _meteringUpdateTimer = [CADisplayLink displayLinkWithTarget:self selector:@selector(sendMeteringUpdate)];
+    [_meteringUpdateTimer addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
+}
+
+- (void)sendMeteringUpdate {
+    if(!_meteringRecorder) {
+        [self stopMeteringTimer];
+        return;
+    }
+    if (!_meteringRecorder.isRecording) {
+        return;
+    }
+
+    if (_prevMeteringUpdateTime == nil ||
+     (([_prevMeteringUpdateTime timeIntervalSinceNow] * -1000.0) >= _meteringUpdateInterval)) {
+        _meteringFrameId++;
+        NSMutableDictionary *body = [[NSMutableDictionary alloc] init];
+        [body setObject:[NSNumber numberWithFloat:_meteringFrameId] forKey:@"id"];
+
+        [_meteringRecorder updateMeters];
+        float _currentLevel = [_meteringRecorder averagePowerForChannel: 0];
+        [body setObject:[NSNumber numberWithFloat:_currentLevel] forKey:@"value"];
+        [body setObject:[NSNumber numberWithFloat:_currentLevel] forKey:@"rawValue"];
+        NSString *eventName = [NSString stringWithFormat:@"RCTAudioRecorderEvent:%@", _meteringRecorderId];
+        [self.bridge.eventDispatcher sendAppEventWithName:eventName
+                                                     body:@{@"event" : @"meter",
+                                                            @"data" : body
+                                                          }];
+        _prevMeteringUpdateTime = [NSDate date];
+    }
+}
+
 #pragma mark - React exposed functions
 
 RCT_EXPORT_MODULE();
@@ -127,6 +182,16 @@ -(NSNumber *) keyForRecorder:(nonnull AVAudioRecorder*)recorder {
         return;
     }
     
+    NSNumber *meteringInterval = [options objectForKey:@"meteringInterval"];
+    if (meteringInterval) {
+        recorder.meteringEnabled = YES;
+        [self startMeteringTimer:[meteringInterval intValue]];
+        if (_meteringRecorderId != nil)
+            NSLog(@"multiple recorder metering are not currently supporter. Metering will be active on the last recorder.");
+        _meteringRecorderId = recorderId;
+        _meteringRecorder = recorder;
+    }
+    
     callback(@[[NSNull null], filePath]);
 }
 
@@ -155,6 +220,9 @@ -(NSNumber *) keyForRecorder:(nonnull AVAudioRecorder*)recorder {
         callback(@[dict]);
         return;
     }
+    if(recorderId == _meteringRecorderId) {
+        [self stopMeteringTimer];
+    }
     callback(@[[NSNull null]]);
 }
 
diff --git a/typings/index.d.ts b/typings/index.d.ts
@@ -254,6 +254,13 @@ interface RecorderOptions {
      * (Default: 'medium')
      */
     quality: string;
+
+    /**
+     * Set monitor interval in millisecond.
+     * Passing a value recorder will receive
+     * db level while recording.
+     */
+    meteringInterval: number;
 }
 
 /**
