✨ Added onRecorderStateChanged stream, onCurrentDuration stream and recordedDuration to get recorded duration for android

Author: Ujas-Majithiya

CHANGELOG.md

@@ -1,7 +1,9 @@
 ## 1.0.2 (Unreleased)
 
 - Now, calling `stopAllPlayers` is not mandatory for disposing streams and it will also not dispose controller. With last remaining player they will be disposed (Streams can be re-initialised by creating a new PlayerController).
-- Added legacy normalization with this fixed [#144](https://github.com/SimformSolutionsPvtLtd/audio_waveforms/issues/144). 
+- Added legacy normalization with this fixed [#144](https://github.com/SimformSolutionsPvtLtd/audio_waveforms/issues/144).
+- Added `onRecorderStateChanged` stream to monitor Recorder state changes.
+- Added `onCurrentDuration` stream to get latest recorded audio duration
 
 ## 1.0.1
 

README.md

@@ -99,6 +99,9 @@ controller.androidOutputFormat = AndroidOutputFormat.mpeg4;      // Changing and
 controller.iosEncoder = IosEncoder.kAudioFormatMPEG4AAC;         // Changing ios encoder
 controller.sampleRate = 44100;                                   // Updating sample rate
 controller.bitRate = 48000;                                      // Updating bitrate
+controller.onRecorderStateChanged.listen((state){});             // Listening to recorder state changes
+controller.onCurrentDuration.listen((duration){});               // Listening to current duration updates
+controller.recordedDuration;                                     // Get recorded audio duration 
 controller.currentScrolledDuration;                              // Current duration position notifier
 ```
 

android/src/main/kotlin/com/simform/audio_waveforms/AudioRecorder.kt

@@ -3,6 +3,8 @@ package com.simform.audio_waveforms
 import android.Manifest
 import android.app.Activity
 import android.content.pm.PackageManager
+import android.media.MediaMetadataRetriever
+import android.media.MediaMetadataRetriever.METADATA_KEY_DURATION
 import android.media.MediaRecorder
 import android.os.Build
 import android.util.Log
@@ -20,6 +22,8 @@ private const val RECORD_AUDIO_REQUEST_CODE = 1001
 class AudioRecorder : PluginRegistry.RequestPermissionsResultListener {
     private var permissions = arrayOf(Manifest.permission.RECORD_AUDIO)
     private var useLegacyNormalization = false
+    private var mediaMetadataRetriever = MediaMetadataRetriever()
+    private var audioInfoArrayList = ArrayList<String>()
 
     fun getDecibel(result: MethodChannel.Result, recorder: MediaRecorder?) {
         if (useLegacyNormalization) {
@@ -68,12 +72,25 @@ class AudioRecorder : PluginRegistry.RequestPermissionsResultListener {
                 reset()
                 release()
             }
-            result.success(path)
+            val duration = getDuration(path)
+            audioInfoArrayList.add(path)
+            audioInfoArrayList.add(duration)
+            result.success(audioInfoArrayList)
         } catch (e: IllegalStateException) {
             Log.e(LOG_TAG, "Failed to stop recording")
         }
     }
 
+    private fun getDuration(path: String): String {
+        mediaMetadataRetriever.setDataSource(path)
+        val duration = mediaMetadataRetriever.extractMetadata(METADATA_KEY_DURATION)
+        return duration ?: "-1"
+    }
+
+    fun releaseMetaDataRetriever(){
+        mediaMetadataRetriever.release()
+    }
+
     fun startRecorder(result: MethodChannel.Result, recorder: MediaRecorder?, useLegacy: Boolean) {
         try {
             useLegacyNormalization = useLegacy

android/src/main/kotlin/com/simform/audio_waveforms/AudioWaveformsPlugin.kt

@@ -55,14 +55,15 @@ class AudioWaveformsPlugin : FlutterPlugin, MethodCallHandler, ActivityAware {
                 checkPathAndInitialiseRecorder(result, encoder, outputFormat, sampleRate, bitRate)
             }
             Constants.startRecording -> {
-                var useLegacyNormalization =
+                val useLegacyNormalization =
                     (call.argument(Constants.useLegacyNormalization) as Boolean?) ?: false
                 audioRecorder.startRecorder(result, recorder, useLegacyNormalization)
             }
             Constants.stopRecording -> {
                 audioRecorder.stopRecording(result, recorder, path!!)
                 recorder = null
             }
+            Constants.releaseMetaDataRetriever -> audioRecorder.releaseMetaDataRetriever()
             Constants.pauseRecording -> audioRecorder.pauseRecording(result, recorder)
             Constants.resumeRecording -> audioRecorder.resumeRecording(result, recorder)
             Constants.getDecibel -> audioRecorder.getDecibel(result, recorder)

android/src/main/kotlin/com/simform/audio_waveforms/Utils.kt

@@ -62,6 +62,7 @@ object Constants {
     const val onCurrentExtractedWaveformData = "onCurrentExtractedWaveformData"
     const val waveformData = "waveformData"
     const val useLegacyNormalization = "useLegacyNormalization"
+    const val releaseMetaDataRetriever = "releaseMetaDataRetriever"
 }
 
 enum class FinishMode(val value:Int) {

example/lib/main.dart

@@ -53,7 +53,7 @@ class _HomeState extends State<Home> {
   }
 
   void _initialiseControllers() {
-    recorderController = RecorderController(useLegacyNormalization: true)
+    recorderController = RecorderController()
       ..androidEncoder = AndroidEncoder.aac
       ..androidOutputFormat = AndroidOutputFormat.mpeg4
       ..iosEncoder = IosEncoder.kAudioFormatMPEG4AAC

lib/src/base/audio_waveforms_interface.dart

@@ -63,10 +63,10 @@ class AudioWaveformsInterface {
   }
 
   ///platform call to stop recording
-  Future<String?> stop() async {
-    final isRecording =
+  Future<List<String?>?> stop() async {
+    final audioInfo =
         await _methodChannel.invokeMethod(Constants.stopRecording);
-    return isRecording;
+    return List.from(audioInfo ?? []);
   }
 
   ///platform call to resume recording.
@@ -90,6 +90,10 @@ class AudioWaveformsInterface {
     return hasPermission ?? false;
   }
 
+  Future<void> releaseMetaDataRetriever() async {
+    await _methodChannel.invokeMethod(Constants.releaseMetaDataRetriever);
+  }
+
   ///platform call to prepare player
   Future<bool> preparePlayer(String path, String key, [double? volume]) async {
     var result = await _methodChannel.invokeMethod(Constants.preparePlayer, {

lib/src/base/constants.dart

@@ -43,4 +43,5 @@ class Constants {
   static const String onCurrentExtractedWaveformData =
       "onCurrentExtractedWaveformData";
   static const String useLegacyNormalization = "useLegacyNormalization";
+  static const String releaseMetaDataRetriever = "releaseMetaDataRetriever";
 }

lib/src/controllers/recorder_controller.dart

@@ -70,8 +70,37 @@ class RecorderController extends ChangeNotifier {
 
   bool _useLegacyNormalization = false;
 
+  /// Provides currently recorded audio duration. Use [onCurrentDuration]
+  /// stream to get latest events duration.
+  Duration elapsedDuration = Duration.zero;
+
+  /// Provides duration of recorded audio file when recording has been stopped.
+  /// Until recording has been stopped, this duration will be
+  /// zero(Duration.zero). Also, once new recording is started this duration
+  /// will be reset to zero.
+  Duration recordedDuration = Duration.zero;
+
+  Timer? _recorderTimer;
+
   final ValueNotifier<int> _currentScrolledDuration = ValueNotifier(0);
 
+  final StreamController<Duration> _currentDurationController =
+      StreamController.broadcast();
+
+  /// A stream to get current duration of currently recording audio file.
+  /// Events are emitted every 50 milliseconds which means current duration is
+  /// accurate to 50 milliseconds. To get Fully accurate duration use
+  /// [recordedDuration] after stopping the recording.
+  Stream<Duration> get onCurrentDuration => _currentDurationController.stream;
+
+  final StreamController<RecorderState> _recorderStateController =
+      StreamController.broadcast();
+
+  /// A Stream to monitor change in RecorderState. Events are emitted whenever
+  /// there is change in the RecorderState.
+  Stream<RecorderState> get onRecorderStateChanged =>
+      _recorderStateController.stream;
+
   /// A class having controls for recording audio and other useful handlers.
   ///
   /// Use [useLegacyNormalization] parameter to use normalization before
@@ -140,15 +169,15 @@ class RecorderController extends ChangeNotifier {
           _isRecording = await AudioWaveformsInterface.instance.resume();
           if (_isRecording) {
             _startTimer();
-            _recorderState = RecorderState.recording;
+            _setRecorderState(RecorderState.recording);
           } else {
             throw "Failed to resume recording";
           }
           notifyListeners();
           return;
         }
         if (Platform.isIOS) {
-          _recorderState = RecorderState.initialized;
+          _setRecorderState(RecorderState.initialized);
         }
         if (_recorderState.isInitialized) {
           _isRecording = await AudioWaveformsInterface.instance.record(
@@ -161,15 +190,15 @@ class RecorderController extends ChangeNotifier {
             useLegacyNormalization: _useLegacyNormalization,
           );
           if (_isRecording) {
-            _recorderState = RecorderState.recording;
+            _setRecorderState(RecorderState.recording);
             _startTimer();
           } else {
             throw "Failed to start recording";
           }
           notifyListeners();
         }
       } else {
-        _recorderState = RecorderState.stopped;
+        _setRecorderState(RecorderState.stopped);
         notifyListeners();
       }
     }
@@ -192,7 +221,7 @@ class RecorderController extends ChangeNotifier {
       bitRate: bitRate ?? this.bitRate,
     );
     if (initialized) {
-      _recorderState = RecorderState.initialized;
+      _setRecorderState(RecorderState.initialized);
     } else {
       throw "Failed to initialize recorder";
     }
@@ -223,8 +252,9 @@ class RecorderController extends ChangeNotifier {
       if (_isRecording) {
         throw "Failed to pause recording";
       }
+      _recorderTimer?.cancel();
       _timer?.cancel();
-      _recorderState = RecorderState.paused;
+      _setRecorderState(RecorderState.paused);
     }
     notifyListeners();
   }
@@ -242,14 +272,21 @@ class RecorderController extends ChangeNotifier {
   /// left of for previous recording.
   Future<String?> stop([bool callReset = true]) async {
     if (_recorderState.isRecording || _recorderState.isPaused) {
-      final path = await AudioWaveformsInterface.instance.stop();
-
-      if (path != null) {
+      final audioInfo = await AudioWaveformsInterface.instance.stop();
+      if (audioInfo != null) {
         _isRecording = false;
         _timer?.cancel();
-        _recorderState = RecorderState.stopped;
+        _recorderTimer?.cancel();
+        if (audioInfo[1] != null) {
+          var duration = int.tryParse(audioInfo[1]!);
+          if (duration != null) {
+            recordedDuration = Duration(milliseconds: duration);
+          }
+        }
+        elapsedDuration = Duration.zero;
+        _setRecorderState(RecorderState.stopped);
         if (callReset) reset();
-        return path;
+        return audioInfo[0];
       } else {
         throw "Failed stop recording";
       }
@@ -282,6 +319,13 @@ class RecorderController extends ChangeNotifier {
 
   /// Gets decibel by every defined frequency
   void _startTimer() {
+    recordedDuration = Duration.zero;
+    const duration = Duration(milliseconds: 50);
+    _recorderTimer = Timer.periodic(duration, (_) {
+      elapsedDuration += duration;
+      _currentDurationController.add(elapsedDuration);
+    });
+
     _timer = Timer.periodic(
       updateFrequency,
       (timer) async {
@@ -351,13 +395,30 @@ class RecorderController extends ChangeNotifier {
     _currentScrolledDuration.value = duration;
   }
 
+  void _setRecorderState(RecorderState state) {
+    _recorderStateController.add(state);
+    _recorderState = state;
+  }
+
+  /// This function is to release resources taken by android native
+  /// MetaDataRetriever.
+  void _release() {
+    AudioWaveformsInterface.instance.releaseMetaDataRetriever();
+  }
+
   /// Releases any resources taken by this recorder and with this
   /// controller is also disposed.
   @override
   void dispose() async {
-    if (_timer != null) _timer!.cancel();
     if (recorderState != RecorderState.stopped) await stop();
+    if (Platform.isAndroid) _release();
     _currentScrolledDuration.dispose();
+    _currentDurationController.close();
+    _recorderStateController.close();
+    _recorderTimer?.cancel();
+    _timer?.cancel();
+    _timer = null;
+    _recorderTimer = null;
     super.dispose();
   }
 }