Persistence

awallish · awallish · commit c1ef0636a76d · 2025-08-12T15:27:46.000-04:00
diff --git a/android/src/main/java/com/dooboolab.audiorecorderplayer/RNAudioRecorderPlayerModule.kt b/android/src/main/java/com/dooboolab.audiorecorderplayer/RNAudioRecorderPlayerModule.kt
@@ -1,6 +1,8 @@
 package com.dooboolab.audiorecorderplayer
 
 import android.Manifest
+import android.content.Context
+import android.content.SharedPreferences
 import android.content.pm.PackageManager
 import android.media.MediaPlayer
 import android.media.MediaRecorder
@@ -12,13 +14,15 @@ import android.os.SystemClock
 import android.util.Log
 import androidx.core.app.ActivityCompat
 import com.facebook.react.bridge.*
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
 import com.facebook.react.modules.core.PermissionListener
+import java.io.File
 import java.io.IOException
 import java.util.*
 import kotlin.math.log10
 
-class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), PermissionListener {
+class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), PermissionListener, LifecycleEventListener {
     private var audioFileURL = ""
     private var subsDurationMillis = 500
     private var _meteringEnabled = false
@@ -29,7 +33,63 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
     private var mTimer: Timer? = null
     private var pausedRecordTime = 0L
     private var totalPausedRecordTime = 0L
+    private var recordStartTime = 0L
+    private var accumulatedRecordTime = 0L
+    private var isRecordingActive = false
+    private val audioSegmentURLs = mutableListOf<String>()
     var recordHandler: Handler? = Handler(Looper.getMainLooper())
+    
+    // SharedPreferences keys for session recovery
+    private val PREFS_NAME = "RNAudioRecorderPrefs"
+    private val KEY_SEGMENT_URLS = "segmentUrls"
+    private val KEY_ACCUMULATED_TIME = "accumulatedTime"
+    private val KEY_IS_RECORDING = "isRecording"
+    private val KEY_IS_PAUSED = "isPaused"
+    private val KEY_START_TIME = "startTime"
+    
+    private fun getSharedPreferences(): SharedPreferences {
+        return reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    }
+    
+    init {
+        // Register lifecycle listener to handle app termination
+        reactContext.addLifecycleEventListener(this)
+    }
+    
+    private fun saveRecoveryState() {
+        val prefs = getSharedPreferences()
+        val editor = prefs.edit()
+        
+        // Save segment URLs as comma-separated string
+        editor.putString(KEY_SEGMENT_URLS, audioSegmentURLs.joinToString(","))
+        
+        // Save timing information
+        editor.putLong(KEY_ACCUMULATED_TIME, accumulatedRecordTime)
+        
+        // Save recording state
+        editor.putBoolean(KEY_IS_RECORDING, mediaRecorder != null)
+        editor.putBoolean(KEY_IS_PAUSED, !isRecordingActive && mediaRecorder != null)
+        
+        // Save start time if recording is active
+        if (isRecordingActive && recordStartTime > 0) {
+            editor.putLong(KEY_START_TIME, recordStartTime)
+        } else {
+            editor.remove(KEY_START_TIME)
+        }
+        
+        editor.commit() // Use commit() instead of apply() for immediate saving
+    }
+    
+    private fun clearRecoveryState() {
+        val prefs = getSharedPreferences()
+        val editor = prefs.edit()
+        editor.remove(KEY_SEGMENT_URLS)
+        editor.remove(KEY_ACCUMULATED_TIME)
+        editor.remove(KEY_IS_RECORDING)
+        editor.remove(KEY_IS_PAUSED)
+        editor.remove(KEY_START_TIME)
+        editor.apply()
+    }
     override fun getName(): String {
         return tag
     }
@@ -92,6 +152,12 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
             MediaRecorder()
         }
 
+        // Clear any previous recovery state when starting new recording
+        audioSegmentURLs.clear()
+        audioSegmentURLs.add(audioFileURL)
+        accumulatedRecordTime = 0L
+        clearRecoveryState()
+        
         try {
             if (audioSet == null) {
                 newMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC)
@@ -122,6 +188,8 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
 
             mediaRecorder = newMediaRecorder
 
+            recordStartTime = SystemClock.elapsedRealtime()
+            isRecordingActive = true
             val systemTime = SystemClock.elapsedRealtime()
             recorderRunnable = object : Runnable {
                 override fun run() {
@@ -165,6 +233,8 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
         try {
             mediaRecorder!!.resume()
             totalPausedRecordTime += SystemClock.elapsedRealtime() - pausedRecordTime;
+            isRecordingActive = true
+            recordStartTime = SystemClock.elapsedRealtime()
             recorderRunnable?.let { recordHandler!!.postDelayed(it, subsDurationMillis.toLong()) }
             promise.resolve("Recorder resumed.")
         } catch (e: Exception) {
@@ -183,6 +253,14 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
         try {
             mediaRecorder!!.pause()
             pausedRecordTime = SystemClock.elapsedRealtime();
+            
+            // Update timing before pausing
+            if (isRecordingActive && recordStartTime > 0) {
+                accumulatedRecordTime += SystemClock.elapsedRealtime() - recordStartTime
+                recordStartTime = 0
+                isRecordingActive = false
+            }
+            
             recorderRunnable?.let { recordHandler!!.removeCallbacks(it) };
             promise.resolve("Recorder paused.")
         } catch (e: Exception) {
@@ -214,6 +292,13 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
         }
 
         try {
+            // Update timing one final time before stopping
+            if (isRecordingActive && recordStartTime > 0) {
+                accumulatedRecordTime += SystemClock.elapsedRealtime() - recordStartTime
+                recordStartTime = 0
+                isRecordingActive = false
+            }
+            
             mediaRecorder!!.stop()
             mediaRecorder!!.release()
             mediaRecorder = null
@@ -232,6 +317,10 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
                 return
             }
             
+            // Clear recovery state after successful stop
+            clearRecoveryState()
+            audioSegmentURLs.clear()
+            
             Log.d(tag, "Recording completed successfully: ${audioFile.length()} bytes")
             promise.resolve("file:///$audioFileURL")
         } catch (stopException: RuntimeException) {
@@ -448,7 +537,145 @@ class RNAudioRecorderPlayerModule(private val reactContext: ReactApplicationCont
         subsDurationMillis = (sec * 1000).toInt()
         promise.resolve("setSubscriptionDuration: $subsDurationMillis")
     }
+    
+    @ReactMethod
+    fun hasRecoverableSession(promise: Promise) {
+        val prefs = getSharedPreferences()
+        val segmentUrlsString = prefs.getString(KEY_SEGMENT_URLS, "")
+        
+        if (!segmentUrlsString.isNullOrEmpty()) {
+            val segmentUrls = segmentUrlsString.split(",").filter { it.isNotEmpty() }
+            
+            // Verify at least one segment file still exists
+            val validSegments = segmentUrls.filter { path ->
+                File(path).exists()
+            }
+            
+            if (validSegments.isNotEmpty()) {
+                val result = Arguments.createMap()
+                result.putBoolean("hasSession", true)
+                result.putInt("segmentCount", validSegments.size)
+                result.putDouble("accumulatedTime", prefs.getLong(KEY_ACCUMULATED_TIME, 0L).toDouble())
+                result.putBoolean("wasRecording", prefs.getBoolean(KEY_IS_RECORDING, false))
+                result.putBoolean("wasPaused", prefs.getBoolean(KEY_IS_PAUSED, false))
+                promise.resolve(result)
+            } else {
+                // No valid segments found, clear recovery state
+                clearRecoveryState()
+                val result = Arguments.createMap()
+                result.putBoolean("hasSession", false)
+                promise.resolve(result)
+            }
+        } else {
+            val result = Arguments.createMap()
+            result.putBoolean("hasSession", false)
+            promise.resolve(result)
+        }
+    }
+    
+    @ReactMethod
+    fun recoverSession(promise: Promise) {
+        val prefs = getSharedPreferences()
+        val segmentUrlsString = prefs.getString(KEY_SEGMENT_URLS, "")
+        
+        if (segmentUrlsString.isNullOrEmpty()) {
+            promise.reject("NO_SESSION", "No recoverable session found")
+            return
+        }
+        
+        val segmentUrls = segmentUrlsString.split(",").filter { it.isNotEmpty() }
+        
+        // Verify files exist
+        val validSegments = segmentUrls.filter { path ->
+            File(path).exists()
+        }
+        
+        if (validSegments.isEmpty()) {
+            clearRecoveryState()
+            promise.reject("NO_VALID_SEGMENTS", "No valid audio segments found")
+            return
+        }
+        
+        // Restore segment URLs
+        audioSegmentURLs.clear()
+        audioSegmentURLs.addAll(validSegments)
+        
+        // Restore timing information
+        accumulatedRecordTime = prefs.getLong(KEY_ACCUMULATED_TIME, 0L)
+        
+        // Restore recording state flags
+        val wasRecording = prefs.getBoolean(KEY_IS_RECORDING, false)
+        val wasPaused = prefs.getBoolean(KEY_IS_PAUSED, false)
+        
+        // Return comma-separated segment paths and state info
+        val result = Arguments.createMap()
+        result.putString("segments", validSegments.map { "file:///$it" }.joinToString(","))
+        result.putDouble("accumulatedTime", accumulatedRecordTime.toDouble())
+        result.putBoolean("wasRecording", wasRecording)
+        result.putBoolean("wasPaused", wasPaused)
+        
+        // Clear the recovery state after successful recovery
+        clearRecoveryState()
+        
+        promise.resolve(result)
+    }
+    
+    @ReactMethod
+    fun clearRecoverySession(promise: Promise) {
+        clearRecoveryState()
+        promise.resolve("Recovery session cleared")
+    }
 
+    // Lifecycle event handlers for saving state on termination
+    override fun onHostResume() {
+        // App resumed from background
+        // We don't need to do anything here since recording continues in background
+    }
+    
+    override fun onHostPause() {
+        // App is going to background or being terminated
+        // Save state quickly before potential termination
+        if (mediaRecorder != null) {
+            // Update timing if recording
+            if (isRecordingActive && recordStartTime > 0) {
+                val currentTime = SystemClock.elapsedRealtime()
+                accumulatedRecordTime += currentTime - recordStartTime
+                // Don't reset recordStartTime here in case it's just backgrounding
+            }
+            
+            // Add current audio file to segments if not already added
+            if (audioFileURL.isNotEmpty() && !audioSegmentURLs.contains(audioFileURL)) {
+                audioSegmentURLs.add(audioFileURL)
+            }
+            
+            saveRecoveryState()
+        }
+    }
+    
+    override fun onHostDestroy() {
+        // App is being destroyed
+        // Final save before termination
+        if (mediaRecorder != null) {
+            // Final timing update
+            if (isRecordingActive && recordStartTime > 0) {
+                val currentTime = SystemClock.elapsedRealtime()
+                accumulatedRecordTime += currentTime - recordStartTime
+                recordStartTime = 0
+                isRecordingActive = false
+            }
+            
+            // Ensure current segment is saved
+            if (audioFileURL.isNotEmpty() && !audioSegmentURLs.contains(audioFileURL)) {
+                audioSegmentURLs.add(audioFileURL)
+            }
+            
+            saveRecoveryState()
+        }
+        
+        // Unregister lifecycle listener
+        reactContext.removeLifecycleEventListener(this)
+    }
+    
     override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray): Boolean {
         var requestRecordAudioPermission: Int = 200
 
diff --git a/index.ts b/index.ts
@@ -156,6 +156,21 @@ export type PlayBackType = {
   isFinished: boolean;
 };
 
+export type RecoverySessionInfo = {
+  hasSession: boolean;
+  segmentCount?: number;
+  accumulatedTime?: number;
+  wasRecording?: boolean;
+  wasPaused?: boolean;
+};
+
+export type RecoveredSessionData = {
+  segments: string;
+  accumulatedTime: number;
+  wasRecording: boolean;
+  wasPaused: boolean;
+};
+
 class AudioRecorderPlayer {
   private _isRecording: boolean = false;
   private _isPlaying: boolean = false;
@@ -455,6 +470,30 @@ class AudioRecorderPlayer {
   setSubscriptionDuration = async (sec: number): Promise<string> => {
     return RNAudioRecorderPlayer.setSubscriptionDuration(sec);
   };
+
+  /**
+   * Check if there's a recoverable recording session from a previous app termination.
+   * @returns {Promise<RecoverySessionInfo>}
+   */
+  hasRecoverableSession = async (): Promise<RecoverySessionInfo> => {
+    return RNAudioRecorderPlayer.hasRecoverableSession();
+  };
+
+  /**
+   * Recover a recording session from a previous app termination.
+   * @returns {Promise<RecoveredSessionData>}
+   */
+  recoverSession = async (): Promise<RecoveredSessionData> => {
+    return RNAudioRecorderPlayer.recoverSession();
+  };
+
+  /**
+   * Clear any saved recovery session data.
+   * @returns {Promise<string>}
+   */
+  clearRecoverySession = async (): Promise<string> => {
+    return RNAudioRecorderPlayer.clearRecoverySession();
+  };
 }
 
 export default AudioRecorderPlayer;
diff --git a/ios/RNAudioRecorderPlayer.m b/ios/RNAudioRecorderPlayer.m
@@ -56,4 +56,13 @@ @interface RCT_EXTERN_MODULE(RNAudioRecorderPlayer, RCTEventEmitter)
 RCT_EXTERN_METHOD(stopPlayer:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject);
 
+RCT_EXTERN_METHOD(hasRecoverableSession:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(recoverSession:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(clearRecoverySession:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject);
+
 @end
diff --git a/ios/RNAudioRecorderPlayer.swift b/ios/RNAudioRecorderPlayer.swift
