Deal with stranded plain-text video files

This could be due to a crash

Author: Wavesonics

app/src/main/kotlin/com/darkrockstudios/app/securecamera/MainActivity.kt

@@ -16,6 +16,7 @@ import androidx.lifecycle.repeatOnLifecycle
 import androidx.navigation3.runtime.NavKey
 import androidx.navigation3.runtime.rememberNavBackStack
 import com.darkrockstudios.app.securecamera.auth.AuthorizationRepository
+import com.darkrockstudios.app.securecamera.encryption.VideoEncryptionService
 import com.darkrockstudios.app.securecamera.navigation.*
 import com.darkrockstudios.app.securecamera.navigation.Camera
 import com.darkrockstudios.app.securecamera.preferences.AppSettingsDataSource
@@ -68,6 +69,9 @@ class MainActivity : ComponentActivity() {
 				Camera
 			}
 			if (authorizationRepository.checkSessionValidity()) {
+				// Session is valid - recover any stranded temp video files immediately
+				// This ensures unencrypted videos are encrypted ASAP
+				VideoEncryptionService.recoverStrandedFiles(this)
 				targetKey
 			} else {
 				PinVerification(targetKey)

app/src/main/kotlin/com/darkrockstudios/app/securecamera/auth/PinVerificationViewModel.kt

@@ -5,6 +5,7 @@ import androidx.lifecycle.viewModelScope
 import androidx.navigation3.runtime.NavKey
 import com.darkrockstudios.app.securecamera.BaseViewModel
 import com.darkrockstudios.app.securecamera.R
+import com.darkrockstudios.app.securecamera.encryption.VideoEncryptionService
 import com.darkrockstudios.app.securecamera.gallery.vibrateDevice
 import com.darkrockstudios.app.securecamera.navigation.Introduction
 import com.darkrockstudios.app.securecamera.usecases.InvalidateSessionUseCase
@@ -110,6 +111,10 @@ class PinVerificationViewModel(
 			val isValid = verifyPinUseCase.verifyPin(pin)
 
 			if (isValid) {
+				// Recover any stranded temp video files immediately after auth
+				// This ensures unencrypted videos are encrypted ASAP
+				VideoEncryptionService.recoverStrandedFiles(appContext)
+
 				withContext(Dispatchers.Main) {
 					_uiState.update {
 						it.copy(

app/src/main/kotlin/com/darkrockstudios/app/securecamera/encryption/VideoEncryptionService.kt

@@ -11,6 +11,7 @@ import androidx.core.app.NotificationCompat
 import com.darkrockstudios.app.securecamera.MainActivity
 import com.darkrockstudios.app.securecamera.R
 import com.darkrockstudios.app.securecamera.security.schemes.EncryptionScheme
+import com.darkrockstudios.app.securecamera.security.streaming.SecvFileFormat
 import com.darkrockstudios.app.securecamera.security.streaming.VideoEncryptionHelper
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -121,6 +122,71 @@ class VideoEncryptionService : Service() {
 			}
 			context.startService(intent)
 		}
+
+		/**
+		 * Recover stranded temp files that were left behind due to a crash.
+		 * This should be called after user authentication to ensure any unencrypted
+		 * video files are immediately encrypted.
+		 *
+		 * Handles:
+		 * - temp_*.mp4 files (unencrypted recordings)
+		 * - *.secv.encrypting files (partial encryptions - deleted)
+		 */
+		fun recoverStrandedFiles(context: Context) {
+			val videosDir = File(context.filesDir, "videos")
+			if (!videosDir.exists()) {
+				Timber.d("Videos directory doesn't exist, nothing to recover")
+				return
+			}
+
+			// Find and delete any partial .encrypting files
+			val encryptingFiles = videosDir.listFiles { file ->
+				file.name.endsWith(VideoEncryptionHelper.ENCRYPTING_SUFFIX)
+			} ?: emptyArray()
+
+			encryptingFiles.forEach { file ->
+				Timber.w("Deleting partial encryption file: ${file.name}")
+				file.delete()
+			}
+
+			// Find stranded temp files
+			val tempFiles = videosDir.listFiles { file ->
+				file.name.startsWith("temp_") && file.name.endsWith(".mp4")
+			} ?: emptyArray()
+
+			if (tempFiles.isEmpty()) {
+				Timber.d("No stranded temp files found")
+				return
+			}
+
+			Timber.w("Found ${tempFiles.size} stranded temp file(s), recovering...")
+
+			// Get set of files currently being processed
+			val currentlyProcessing = _encryptionState.value.keys
+
+			tempFiles.forEach { tempFile ->
+				// Derive the expected output file name
+				val outputName = tempFile.name
+					.replace("temp_", "video_")
+					.replace(".mp4", ".${SecvFileFormat.FILE_EXTENSION}")
+				val outputFile = File(videosDir, outputName)
+
+				// Skip if already being processed
+				if (currentlyProcessing.contains(outputName)) {
+					Timber.d("Skipping ${tempFile.name} - already being processed")
+					return@forEach
+				}
+
+				// Delete any existing partial output (shouldn't exist if .encrypting is used, but safety check)
+				if (outputFile.exists()) {
+					Timber.w("Deleting existing partial output: ${outputFile.name}")
+					outputFile.delete()
+				}
+
+				Timber.i("Recovering stranded video: ${tempFile.name} -> ${outputFile.name}")
+				enqueueEncryption(context, tempFile, outputFile)
+			}
+		}
 	}
 
 	override fun onCreate() {
@@ -299,7 +365,6 @@ class VideoEncryptionService : Service() {
 		if (job.tempFile.exists()) {
 			job.tempFile.delete()
 		}
-		showCompletionNotification()
 	}
 
 	private fun handleJobCancelled(job: VideoEncryptionJob) {
@@ -436,20 +501,6 @@ class VideoEncryptionService : Service() {
 		}
 	}
 
-	private fun showCompletionNotification() {
-		val builder = NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
-			.setSmallIcon(android.R.drawable.ic_menu_save)
-			.setContentTitle(getString(R.string.encryption_complete_title))
-			.setContentText(getString(R.string.encryption_complete_content))
-			.setPriority(NotificationCompat.PRIORITY_LOW)
-			.setAutoCancel(true)
-			.setContentIntent(createContentPendingIntent())
-
-		val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
-		// Use a different notification ID for completion so it doesn't interfere with ongoing
-		notificationManager.notify(NOTIFICATION_ID + 100, builder.build())
-	}
-
 	private fun showErrorNotification(message: String) {
 		val builder = NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
 			.setSmallIcon(android.R.drawable.ic_dialog_alert)

app/src/main/kotlin/com/darkrockstudios/app/securecamera/security/streaming/VideoEncryptionHelper.kt

@@ -35,6 +35,8 @@ class VideoEncryptionHelper(
 		chunkSize: Int = SecvFileFormat.DEFAULT_CHUNK_SIZE,
 		isCancelled: () -> Boolean = { false }
 	): Boolean = withContext(Dispatchers.IO) {
+		val encryptingFile = File(outputFile.absolutePath + ENCRYPTING_SUFFIX)
+
 		try {
 			_encryptionProgress.value = EncryptionProgress.Starting
 
@@ -50,7 +52,7 @@ class VideoEncryptionHelper(
 			_encryptionProgress.value = EncryptionProgress.InProgress(0f)
 
 			// Create the streaming encryptor
-			val encryptor = streamingScheme.createStreamingEncryptor(outputFile, chunkSize)
+			val encryptor = streamingScheme.createStreamingEncryptor(encryptingFile, chunkSize)
 
 			try {
 				// Read the temp file in chunks and write to encryptor
@@ -82,13 +84,21 @@ class VideoEncryptionHelper(
 				encryptor.close()
 			}
 
-			// Verify the output file was created
-			if (!outputFile.exists() || outputFile.length() == 0L) {
+			// Verify the encrypting file was created
+			if (!encryptingFile.exists() || encryptingFile.length() == 0L) {
 				Timber.e("Encrypted output file is empty or missing")
 				_encryptionProgress.value = EncryptionProgress.Error("Encryption failed")
 				return@withContext false
 			}
 
+			// Rename .encrypting to final .secv
+			if (!encryptingFile.renameTo(outputFile)) {
+				Timber.e("Failed to rename encrypting file to final output")
+				_encryptionProgress.value = EncryptionProgress.Error("Failed to finalize encryption")
+				encryptingFile.delete()
+				return@withContext false
+			}
+
 			tempFile.delete()
 
 			_encryptionProgress.value = EncryptionProgress.Completed
@@ -99,15 +109,19 @@ class VideoEncryptionHelper(
 			Timber.e(e, "Failed to encrypt video file")
 			_encryptionProgress.value = EncryptionProgress.Error(e.message ?: "Unknown error")
 
-			// Clean up partial output file on error
-			if (outputFile.exists()) {
-				outputFile.delete()
+			// Clean up partial encrypting file on error
+			if (encryptingFile.exists()) {
+				encryptingFile.delete()
 			}
 
 			return@withContext false
 		}
 	}
 
+	companion object {
+		const val ENCRYPTING_SUFFIX = ".encrypting"
+	}
+
 	fun resetProgress() {
 		_encryptionProgress.value = EncryptionProgress.Idle
 	}

app/src/main/res/values/strings.xml

@@ -111,8 +111,6 @@
     <string name="encryption_notification_preparing">Preparing…</string>
     <string name="encryption_notification_progress">Encrypting: %1$d%%</string>
     <string name="encryption_notification_queue">%1$d of %2$d - %3$d%%</string>
-    <string name="encryption_complete_title">Encryption Complete</string>
-    <string name="encryption_complete_content">Video saved securely</string>
     <string name="encryption_error_title">Encryption Failed</string>
     <string name="encryption_cancelled_title">Encryption Cancelled</string>
     <string name="encryption_action_cancel">Cancel</string>