Enhance startRecording function to handle edge cases

where there could be multiple calls to the function

Author: MHShetty

app/src/main/java/app/grapheneos/camera/capturer/VideoCapturer.kt

@@ -147,115 +147,121 @@ class VideoCapturer(private val mActivity: MainActivity) {
         return null
     }
 
+    val startRecordingLock = Any()
+
     fun startRecording() {
-        if (camConfig.camera == null) return
-        val recorder = camConfig.videoCapture?.output ?: return
+        synchronized(startRecordingLock) {
+            if (camConfig.camera == null) return
+            val recorder = camConfig.videoCapture?.output ?: return
+            if (isRecording) return
+            isRecording = true
 
-        val dateString = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
-        val fileName = VIDEO_NAME_PREFIX + dateString + videoFileFormat
+            val dateString = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+            val fileName = VIDEO_NAME_PREFIX + dateString + videoFileFormat
 
-        includeAudio = false
+            includeAudio = false
 
-        val ctx = mActivity
+            val ctx = mActivity
 
-        if (ctx.settingsDialog.includeAudioToggle.isChecked) {
-            if (ctx.checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PERMISSION_GRANTED) {
-                includeAudio = true
-            } else {
-                ctx.restartRecordingWithMicPermission()
-                return
+            if (ctx.settingsDialog.includeAudioToggle.isChecked) {
+                if (ctx.checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PERMISSION_GRANTED) {
+                    includeAudio = true
+                } else {
+                    ctx.restartRecordingWithMicPermission()
+                    isRecording = false
+                    return
+                }
             }
-        }
 
-        val recordingCtx = try {
-            createRecordingContext(recorder, fileName)!!
-        } catch (exception: Exception) {
-            val foreignUri = ctx is VideoCaptureActivity && ctx.isOutputUriAvailable()
-            if (!foreignUri) {
-                camConfig.onStorageLocationNotFound()
+            val recordingCtx = try {
+                createRecordingContext(recorder, fileName)!!
+            } catch (exception: Exception) {
+                val foreignUri = ctx is VideoCaptureActivity && ctx.isOutputUriAvailable()
+                if (!foreignUri) {
+                    camConfig.onStorageLocationNotFound()
+                }
+                ctx.showMessage(R.string.unable_to_access_output_file)
+                isRecording = false
+                return
             }
-            ctx.showMessage(R.string.unable_to_access_output_file)
-            return
-        }
 
-        val pendingRecording = recordingCtx.pendingRecording
-
-        if (includeAudio) {
-            pendingRecording.withAudioEnabled()
-        }
+            val pendingRecording = recordingCtx.pendingRecording
 
-        beforeRecordingStarts()
-
-        isRecording = true
+            if (includeAudio) {
+                pendingRecording.withAudioEnabled()
+            }
 
-        camConfig.mPlayer.playVRStartSound(handler) {
+            beforeRecordingStarts()
 
-            recording = pendingRecording.start(ctx.mainExecutor) { event ->
+            camConfig.mPlayer.playVRStartSound(handler) {
 
-                if (event is VideoRecordEvent.Start) {
-                    onRecordingStart()
-                }
+                recording = pendingRecording.start(ctx.mainExecutor) { event ->
 
-                if (event is VideoRecordEvent.Status) {
-                    updateTimerTime(event.recordingStats.recordedDurationNanos)
-                }
-
-                if (event is VideoRecordEvent.Finalize) {
-                    afterRecordingStops()
+                    if (event is VideoRecordEvent.Start) {
+                        onRecordingStart()
+                    }
 
-                    camConfig.mPlayer.playVRStopSound()
+                    if (event is VideoRecordEvent.Status) {
+                        updateTimerTime(event.recordingStats.recordedDurationNanos)
+                    }
 
-                    if (event.hasError()) {
-                        when (event.error) {
-                            VideoRecordEvent.Finalize.ERROR_NO_VALID_DATA -> {
-                                ctx.showMessage(R.string.recording_too_short_to_be_saved)
-                                return@start
-                            }
-                            VideoRecordEvent.Finalize.ERROR_ENCODING_FAILED,
-                            VideoRecordEvent.Finalize.ERROR_RECORDER_ERROR,
-                            VideoRecordEvent.Finalize.ERROR_UNKNOWN -> {
-                                ctx.showMessage(ctx.getString(R.string.unable_to_save_video_verbose, event.error))
-                                return@start
-                            }
-                            else -> {
-                                ctx.showMessage(ctx.getString(R.string.error_during_recording, event.error))
+                    if (event is VideoRecordEvent.Finalize) {
+                        afterRecordingStops()
+
+                        camConfig.mPlayer.playVRStopSound()
+
+                        if (event.hasError()) {
+                            when (event.error) {
+                                VideoRecordEvent.Finalize.ERROR_NO_VALID_DATA -> {
+                                    ctx.showMessage(R.string.recording_too_short_to_be_saved)
+                                    return@start
+                                }
+                                VideoRecordEvent.Finalize.ERROR_ENCODING_FAILED,
+                                VideoRecordEvent.Finalize.ERROR_RECORDER_ERROR,
+                                VideoRecordEvent.Finalize.ERROR_UNKNOWN -> {
+                                    ctx.showMessage(ctx.getString(R.string.unable_to_save_video_verbose, event.error))
+                                    return@start
+                                }
+                                else -> {
+                                    ctx.showMessage(ctx.getString(R.string.error_during_recording, event.error))
+                                }
                             }
                         }
-                    }
 
-                    val uri = recordingCtx.uri
+                        val uri = recordingCtx.uri
 
-                    if (recordingCtx.isPendingMediaStoreUri) {
-                        try {
-                            removePendingFlagFromUri(ctx.contentResolver, uri)
-                        } catch (e: Exception) {
-                            ctx.showMessage(R.string.unable_to_save_video)
+                        if (recordingCtx.isPendingMediaStoreUri) {
+                            try {
+                                removePendingFlagFromUri(ctx.contentResolver, uri)
+                            } catch (e: Exception) {
+                                ctx.showMessage(R.string.unable_to_save_video)
+                            }
                         }
-                    }
 
-                    if (recordingCtx.shouldAddToGallery) {
-                        val item = CapturedItem(ITEM_TYPE_VIDEO, dateString, uri)
-                        camConfig.updateLastCapturedItem(item)
+                        if (recordingCtx.shouldAddToGallery) {
+                            val item = CapturedItem(ITEM_TYPE_VIDEO, dateString, uri)
+                            camConfig.updateLastCapturedItem(item)
 
-                        ctx.updateThumbnail()
+                            ctx.updateThumbnail()
 
-                        if (ctx is SecureMainActivity) {
-                            ctx.capturedItems.add(item)
+                            if (ctx is SecureMainActivity) {
+                                ctx.capturedItems.add(item)
+                            }
                         }
-                    }
 
-                    if (ctx is VideoCaptureActivity) {
-                        ctx.afterRecording(uri)
+                        if (ctx is VideoCaptureActivity) {
+                            ctx.afterRecording(uri)
+                        }
                     }
                 }
-            }
 
-            try {
-                // FileDescriptorOutputOptions doc says that the file descriptor should be closed by the
-                // caller, and that it's safe to do so as soon as pendingRecording.start() returns
-                recordingCtx.fileDescriptor.close()
-            } catch (e: Exception) {
-                e.printStackTrace()
+                try {
+                    // FileDescriptorOutputOptions doc says that the file descriptor should be closed by the
+                    // caller, and that it's safe to do so as soon as pendingRecording.start() returns
+                    recordingCtx.fileDescriptor.close()
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
             }
         }
     }