feat: Add save last recording functionality again

app/src/main/java/app/myzel394/alibi/helpers/BatchesFolder.kt

@@ -126,23 +126,25 @@ abstract class BatchesFolder(
             extension = extension,
         )
 
-        if (disableCache || !checkIfOutputAlreadyExists(recordingStart, extension)) {
+        if (!disableCache && checkIfOutputAlreadyExists(recordingStart, extension)) {
-            val filePaths = getBatchesForFFmpeg()
+            return outputFile
+        }
 
-            for (parameter in ffmpegParameters) {
+        val filePaths = getBatchesForFFmpeg()
-                Log.i("Concatenation", "Trying parameter $parameter")
-                onNextParameterTry(parameter)
 
-                try {
+        for (parameter in ffmpegParameters) {
-                    concatenateFunction(
+            Log.i("Concatenation", "Trying parameter $parameter")
-                        filePaths,
+            onNextParameterTry(parameter)
-                        outputFile,
+
-                        parameter,
+            try {
-                    ).await()
+                concatenateFunction(
-                    return outputFile
+                    filePaths,
-                } catch (e: MediaConverter.FFmpegException) {
+                    outputFile,
-                    continue
+                    parameter,
-                }
+                ).await()
+                return outputFile
+            } catch (e: MediaConverter.FFmpegException) {
+                continue
             }
         }
 

app/src/main/java/app/myzel394/alibi/ui/components/RecorderScreen/atoms/RecorderEventsHandler.kt

@@ -132,11 +132,19 @@ fun RecorderEventsHandler(
                     // When recording is loaded from lastRecording
                         ?: settings.lastRecording
                         ?: throw Exception("No recording information available")
-                val batchesFolder =
+                val batchesFolder = when (recorder.javaClass) {
-                    if (recorder.javaClass == AudioRecorderModel::class.java)
+                    AudioRecorderModel::class.java -> AudioBatchesFolder.importFromFolder(
-                        AudioBatchesFolder.importFromFolder(recording.folderPath, context)
+                        recording.folderPath,
-                    else
+                        context
-                        VideoBatchesFolder.importFromFolder(recording.folderPath, context)
+                    )
+
+                    VideoRecorderModel::class.java -> VideoBatchesFolder.importFromFolder(
+                        recording.folderPath,
+                        context
+                    )
+
+                    else -> throw Exception("Unknown recorder type")
+                }
 
                 batchesFolder.concatenate(
                     recording.recordingStart,
@@ -151,20 +159,24 @@ fun RecorderEventsHandler(
 
                 when (batchesFolder.type) {
                     BatchesFolder.BatchType.INTERNAL -> {
-                        if (batchesFolder is AudioBatchesFolder) {
+                        when (batchesFolder) {
-                            saveAudioFile(
+                            is AudioBatchesFolder -> {
-                                batchesFolder.asInternalGetOutputFile(
+                                saveAudioFile(
-                                    recording.recordingStart,
+                                    batchesFolder.asInternalGetOutputFile(
-                                    recording.fileExtension,
+                                        recording.recordingStart,
-                                ), name
+                                        recording.fileExtension,
-                            )
+                                    ), name
-                        } else if (batchesFolder is VideoBatchesFolder) {
+                                )
-                            saveVideoFile(
+                            }
-                                batchesFolder.asInternalGetOutputFile(
+
-                                    recording.recordingStart,
+                            is VideoBatchesFolder -> {
-                                    recording.fileExtension,
+                                saveVideoFile(
-                                ), name
+                                    batchesFolder.asInternalGetOutputFile(
-                            )
+                                        recording.recordingStart,
+                                        recording.fileExtension,
+                                    ), name
+                                )
+                            }
                         }
                     }
 
@@ -186,17 +198,21 @@ fun RecorderEventsHandler(
 
     // Register audio recorder events
     DisposableEffect(key1 = audioRecorder, key2 = settings) {
-        audioRecorder.onRecordingSave = {
+        audioRecorder.onRecordingSave = { justSave ->
             scope.launch {
-                audioRecorder.stopRecording(context)
+                if (justSave) {
+                    saveRecording(audioRecorder as RecorderModel)
+                } else {
+                    audioRecorder.stopRecording(context)
 
-                kotlin.runCatching {
+                    runCatching {
-                    saveAsLastRecording(audioRecorder as RecorderModel)
+                        saveAsLastRecording(audioRecorder as RecorderModel)
 
-                    saveRecording(audioRecorder)
+                        saveRecording(audioRecorder)
+                    }
+
+                    audioRecorder.destroyService(context)
                 }
-
-                audioRecorder.destroyService(context)
             }
         }
         audioRecorder.onError = {
@@ -215,17 +231,21 @@ fun RecorderEventsHandler(
 
     // Register video recorder events
     DisposableEffect(key1 = videoRecorder, key2 = settings) {
-        videoRecorder.onRecordingSave = {
+        videoRecorder.onRecordingSave = { justSave ->
             scope.launch {
-                videoRecorder.stopRecording(context)
+                if (justSave) {
+                    saveRecording(videoRecorder as RecorderModel)
+                } else {
+                    videoRecorder.stopRecording(context)
 
-                kotlin.runCatching {
+                    runCatching {
-                    saveAsLastRecording(videoRecorder as RecorderModel)
+                        saveAsLastRecording(videoRecorder as RecorderModel)
 
-                    saveRecording(videoRecorder)
+                        saveRecording(videoRecorder)
+                    }
+
+                    videoRecorder.destroyService(context)
                 }
-
-                videoRecorder.destroyService(context)
             }
         }
         videoRecorder.onError = {

app/src/main/java/app/myzel394/alibi/ui/components/RecorderScreen/organisms/AudioRecordingStatus.kt

@@ -92,7 +92,7 @@ fun AudioRecordingStatus(
                 }
             },
             onSave = {
-                audioRecorder.onRecordingSave()
+                audioRecorder.onRecordingSave(false)
             }
         )
 

app/src/main/java/app/myzel394/alibi/ui/components/RecorderScreen/organisms/VideoRecordingStatus.kt

@@ -169,7 +169,7 @@ fun VideoRecordingStatus(
                     }
                 },
                 onSave = {
-                    videoRecorder.onRecordingSave()
+                    videoRecorder.onRecordingSave(false)
                 }
             )
         }

app/src/main/java/app/myzel394/alibi/ui/models/BaseRecorderModel.kt

@@ -40,7 +40,9 @@ abstract class BaseRecorderModel<S : IntervalRecorderService.Settings, I, T : In
     var recorderService by mutableStateOf<T?>(null)
         protected set
 
-    var onRecordingSave: () -> Unit = {}
+    // If `isSavingAsOldRecording` is true, the user is saving an old recording,
+    // thus the service is not running and thus doesn't need to be stopped or destroyed
+    var onRecordingSave: (isSavingAsOldRecording: Boolean) -> Unit = {}
     var onError: () -> Unit = {}
     abstract var batchesFolder: B
 
@@ -132,8 +134,6 @@ abstract class BaseRecorderModel<S : IntervalRecorderService.Settings, I, T : In
     }
 
     suspend fun stopRecording(context: Context) {
-        // TODO: Make modal on video only appear on long press and by default use back camera
-        // TODO: Also show what camera is in use while recording
         recorderService!!.stopRecording()
 
         runCatching {

app/src/main/java/app/myzel394/alibi/ui/screens/RecorderScreen.kt

@@ -27,6 +27,7 @@ import app.myzel394.alibi.ui.enums.Screen
 import app.myzel394.alibi.R
 import app.myzel394.alibi.dataStore
 import app.myzel394.alibi.db.AppSettings
+import app.myzel394.alibi.db.RecordingInformation
 import app.myzel394.alibi.ui.components.RecorderScreen.atoms.RecorderEventsHandler
 import app.myzel394.alibi.ui.components.RecorderScreen.organisms.VideoRecordingStatus
 import app.myzel394.alibi.ui.effects.rememberSettings
@@ -113,7 +114,13 @@ fun RecorderScreen(
                     videoRecorder = videoRecorder,
                     appSettings = appSettings,
                     onSaveLastRecording = {
-                        // TODO: Improve onSave!
+                        when (settings.lastRecording!!.type) {
+                            RecordingInformation.Type.AUDIO ->
+                                audioRecorder.onRecordingSave(true)
+
+                            RecordingInformation.Type.VIDEO ->
+                                videoRecorder.onRecordingSave(true)
+                        }
                     },
                     showAudioRecorder = topBarVisible,
                     onHideTopBar = {