Add support for specifying a minimum recording duration

chenxiaolong · chenxiaolong · commit e5fe6ce7d7df · 2024-09-19T22:45:25.000-04:00
If the recording isn't long enough, it will be discarded at the end of the call. The duration is computed based on the recording duration (number of encoded frames), not the call duration, so it excludes regions where the user explicitly paused the recording and regions where the call was placed on hold. Similar to the record rules, this can be overridden during the call from BCR's notification. Fixes: #411 Fixes: #604 Signed-off-by: Andrew Gunnerson <accounts+github@chiller3.com>
diff --git a/app/src/main/java/com/chiller3/bcr/Preferences.kt b/app/src/main/java/com/chiller3/bcr/Preferences.kt
@@ -29,6 +29,7 @@ class Preferences(initialContext: Context) {
         const val PREF_OUTPUT_DIR = "output_dir"
         const val PREF_FILENAME_TEMPLATE = "filename_template"
         const val PREF_OUTPUT_FORMAT = "output_format"
+        const val PREF_MIN_DURATION = "min_duration"
         const val PREF_INHIBIT_BATT_OPT = "inhibit_batt_opt"
         private const val PREF_WRITE_METADATA = "write_metadata"
         private const val PREF_RECORD_TELECOM_APPS = "record_telecom_apps"
@@ -384,6 +385,14 @@ class Preferences(initialContext: Context) {
         }
     }
 
+    /**
+     * Minimum recording duration for it to be kept if the record rules would have allowed it to be
+     * kept in the first place.
+     */
+    var minDuration: Int
+        get() = prefs.getInt(PREF_MIN_DURATION, 0)
+        set(seconds) = prefs.edit { putInt(PREF_MIN_DURATION, seconds) }
+
     /**
      * Whether to write call metadata file.
      */
diff --git a/app/src/main/java/com/chiller3/bcr/RecorderInCallService.kt b/app/src/main/java/com/chiller3/bcr/RecorderInCallService.kt
@@ -142,7 +142,11 @@ class RecorderInCallService : InCallService(), RecorderThread.OnRecordingComplet
                 }
                 ACTION_RESTORE, ACTION_DELETE -> {
                     notificationIdsToRecorders[notificationId]?.keepRecording =
-                        action == ACTION_RESTORE
+                        if (action == ACTION_RESTORE) {
+                            RecorderThread.KeepState.KEEP
+                        } else {
+                            RecorderThread.KeepState.DISCARD
+                        }
                 }
                 else -> throw IllegalArgumentException("Invalid action: $action")
             }
@@ -369,14 +373,29 @@ class RecorderInCallService : InCallService(), RecorderThread.OnRecordingComplet
 
                 if (canShowDelete) {
                     recorder.keepRecording?.let {
-                        if (it) {
-                            actionResIds.add(R.string.notification_action_delete)
-                            actionIntents.add(createActionIntent(notificationId, ACTION_DELETE))
-                        } else {
-                            message.append("\n\n")
-                            message.append(getString(R.string.notification_message_delete_at_end))
-                            actionResIds.add(R.string.notification_action_restore)
-                            actionIntents.add(createActionIntent(notificationId, ACTION_RESTORE))
+                        when (it) {
+                            RecorderThread.KeepState.KEEP -> {
+                                actionResIds.add(R.string.notification_action_delete)
+                                actionIntents.add(createActionIntent(notificationId, ACTION_DELETE))
+                            }
+                            RecorderThread.KeepState.DISCARD -> {
+                                message.append("\n\n")
+                                message.append(getString(R.string.notification_message_delete_at_end))
+                                actionResIds.add(R.string.notification_action_restore)
+                                actionIntents.add(createActionIntent(notificationId, ACTION_RESTORE))
+                            }
+                            RecorderThread.KeepState.DISCARD_TOO_SHORT -> {
+                                val minDuration = prefs.minDuration
+
+                                message.append("\n\n")
+                                message.append(resources.getQuantityString(
+                                    R.plurals.notification_message_delete_at_end_too_short,
+                                    minDuration,
+                                    minDuration,
+                                ))
+                                actionResIds.add(R.string.notification_action_restore)
+                                actionIntents.add(createActionIntent(notificationId, ACTION_RESTORE))
+                            }
                         }
                     }
                 }
diff --git a/app/src/main/java/com/chiller3/bcr/RecorderThread.kt b/app/src/main/java/com/chiller3/bcr/RecorderThread.kt
@@ -36,6 +36,7 @@ import org.json.JSONObject
 import java.lang.Process
 import java.nio.ByteBuffer
 import java.time.Duration
+import java.util.concurrent.atomic.AtomicReference
 import android.os.Process as AndroidProcess
 
 /**
@@ -72,22 +73,40 @@ class RecorderThread(
         private set
     @Volatile private var isCancelled = false
 
+    enum class KeepState {
+        KEEP,
+        DISCARD,
+        DISCARD_TOO_SHORT,
+    }
+
     /**
      * Whether to preserve the recording.
      *
      * This is initially set to null while the [RecordRule]s are being processed. Once computed,
      * this field is set to the computed value. The value can be changed, including from other
      * threads, in case the user wants to override the rules during the middle of the call.
      */
-    @Volatile var keepRecording: Boolean? = null
+    private val _keepRecording = AtomicReference<KeepState>()
+    var keepRecording: KeepState?
+        get() = _keepRecording.get()
         set(value) {
             require(value != null)
 
-            field = value
+            _keepRecording.set(value)
+            Log.d(tag, "Keep state updated: $value")
+
+            listener.onRecordingStateChanged(this)
+        }
+
+    private fun keepRecordingCompareAndSet(expected: KeepState?, value: KeepState?) {
+        require(value != null)
+
+        if (_keepRecording.compareAndSet(expected, value)) {
             Log.d(tag, "Keep state updated: $value")
 
             listener.onRecordingStateChanged(this)
         }
+    }
 
     /**
      * Whether the user paused the recording.
@@ -123,6 +142,8 @@ class RecorderThread(
     val outputPath: OutputPath
         get() = outputFilenameGenerator.generate(callMetadataCollector.callMetadata)
 
+    private val minDuration: Int
+
     // Format
     private val format: Format
     private val formatParam: UInt?
@@ -136,6 +157,8 @@ class RecorderThread(
     init {
         Log.i(tag, "Created thread for call: $parentCall")
 
+        minDuration = prefs.minDuration
+
         val savedFormat = Format.fromPreferences(prefs)
         format = savedFormat.first
         formatParam = savedFormat.second
@@ -165,14 +188,27 @@ class RecorderThread(
         Log.i(tag, "Evaluating record rules for ${numbers.size} phone number(s)")
 
         val rules = prefs.recordRules ?: Preferences.DEFAULT_RECORD_RULES
-        keepRecording = try {
+        val keep = try {
             RecordRule.evaluate(context, rules, numbers)
         } catch (e: Exception) {
             Log.w(tag, "Failed to evaluate record rules", e)
             // Err on the side of caution
             true
         }
 
+        keepRecordingCompareAndSet(
+            null,
+            if (keep) {
+                if (minDuration > 0) {
+                    KeepState.DISCARD_TOO_SHORT
+                } else {
+                    KeepState.KEEP
+                }
+            } else {
+                KeepState.DISCARD
+            },
+        )
+
         listener.onRecordingStateChanged(this)
     }
 
@@ -214,7 +250,7 @@ class RecorderThread(
                     callMetadataCollector.update(true)
                     val finalPath = outputPath
 
-                    if (keepRecording != false) {
+                    if (keepRecording == KeepState.KEEP) {
                         dirUtils.tryMoveToOutputDir(
                             outputDocFile,
                             finalPath.value,
@@ -646,6 +682,11 @@ class RecorderThread(
                         "record=${recordElapsed / 1_000_000.0}ms, " +
                         "encode=${encodeElapsed / 1_000_000.0}ms")
             }
+
+            val secondsEncoded = numFramesEncoded / audioRecord.sampleRate / audioRecord.channelCount
+            if (secondsEncoded >= minDuration) {
+                keepRecordingCompareAndSet(KeepState.DISCARD_TOO_SHORT, KeepState.KEEP)
+            }
         }
 
         if (wasReadSamplesError) {
diff --git a/app/src/main/java/com/chiller3/bcr/dialog/MinDurationDialogFragment.kt b/app/src/main/java/com/chiller3/bcr/dialog/MinDurationDialogFragment.kt
@@ -0,0 +1,101 @@
+package com.chiller3.bcr.dialog
+
+import android.app.Dialog
+import android.content.DialogInterface
+import android.os.Bundle
+import android.text.InputType
+import androidx.appcompat.app.AlertDialog
+import androidx.core.os.bundleOf
+import androidx.core.widget.addTextChangedListener
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.setFragmentResult
+import com.chiller3.bcr.Preferences
+import com.chiller3.bcr.R
+import com.chiller3.bcr.databinding.DialogTextInputBinding
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+
+class MinDurationDialogFragment : DialogFragment() {
+    companion object {
+        val TAG: String = MinDurationDialogFragment::class.java.simpleName
+
+        const val RESULT_SUCCESS = "success"
+    }
+
+    private lateinit var prefs: Preferences
+    private lateinit var binding: DialogTextInputBinding
+    private var minDuration: Int? = null
+    private var success: Boolean = false
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val context = requireContext()
+        prefs = Preferences(context)
+        minDuration = prefs.minDuration
+
+        binding = DialogTextInputBinding.inflate(layoutInflater)
+
+        binding.message.setText(R.string.min_duration_dialog_message)
+
+        binding.text.inputType = InputType.TYPE_CLASS_NUMBER
+        binding.text.addTextChangedListener {
+            minDuration = if (it!!.isEmpty()) {
+                0
+            } else {
+                try {
+                    val seconds = it.toString().toInt()
+                    if (seconds >= 0) {
+                        seconds
+                    } else {
+                        null
+                    }
+                } catch (e: NumberFormatException) {
+                    null
+                }
+            }
+
+            refreshHelperText()
+            refreshOkButtonEnabledState()
+        }
+        if (savedInstanceState == null) {
+            binding.text.setText(minDuration?.toString())
+        }
+
+        refreshHelperText()
+
+        return MaterialAlertDialogBuilder(requireContext())
+            .setTitle(R.string.min_duration_dialog_title)
+            .setView(binding.root)
+            .setPositiveButton(android.R.string.ok) { _, _ ->
+                prefs.minDuration = minDuration!!
+                success = true
+            }
+            .setNegativeButton(android.R.string.cancel, null)
+            .create()
+            .apply {
+                setCanceledOnTouchOutside(false)
+            }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        refreshOkButtonEnabledState()
+    }
+
+    override fun onDismiss(dialog: DialogInterface) {
+        super.onDismiss(dialog)
+
+        setFragmentResult(tag!!, bundleOf(RESULT_SUCCESS to success))
+    }
+
+    private fun refreshHelperText() {
+        val context = requireContext()
+
+        binding.textLayout.helperText = minDuration?.let {
+            context.resources.getQuantityString(R.plurals.min_duration_dialog_seconds, it, it)
+        }
+    }
+
+    private fun refreshOkButtonEnabledState() {
+        (dialog as AlertDialog?)?.getButton(AlertDialog.BUTTON_POSITIVE)?.isEnabled =
+            minDuration != null
+    }
+}
diff --git a/app/src/main/java/com/chiller3/bcr/settings/SettingsFragment.kt b/app/src/main/java/com/chiller3/bcr/settings/SettingsFragment.kt
@@ -21,6 +21,7 @@ import com.chiller3.bcr.DirectBootMigrationService
 import com.chiller3.bcr.Permissions
 import com.chiller3.bcr.Preferences
 import com.chiller3.bcr.R
+import com.chiller3.bcr.dialog.MinDurationDialogFragment
 import com.chiller3.bcr.extension.formattedString
 import com.chiller3.bcr.format.Format
 import com.chiller3.bcr.format.NoParamInfo
@@ -40,6 +41,7 @@ class SettingsFragment : PreferenceFragmentCompat(), Preference.OnPreferenceChan
     private lateinit var prefRecordRules: Preference
     private lateinit var prefOutputDir: LongClickablePreference
     private lateinit var prefOutputFormat: Preference
+    private lateinit var prefMinDuration: Preference
     private lateinit var prefInhibitBatteryOpt: SwitchPreferenceCompat
     private lateinit var prefVersion: LongClickablePreference
     private lateinit var prefMigrateDirectBoot: Preference
@@ -120,6 +122,10 @@ class SettingsFragment : PreferenceFragmentCompat(), Preference.OnPreferenceChan
         prefOutputFormat.onPreferenceClickListener = this
         refreshOutputFormat()
 
+        prefMinDuration = findPreference(Preferences.PREF_MIN_DURATION)!!
+        prefMinDuration.onPreferenceClickListener = this
+        refreshMinDuration()
+
         prefInhibitBatteryOpt = findPreference(Preferences.PREF_INHIBIT_BATT_OPT)!!
         prefInhibitBatteryOpt.onPreferenceChangeListener = this
 
@@ -173,6 +179,16 @@ class SettingsFragment : PreferenceFragmentCompat(), Preference.OnPreferenceChan
         prefOutputFormat.summary = "${summary}\n\n${format.name} (${prefix}${sampleRateText})"
     }
 
+    private fun refreshMinDuration() {
+        val minDuration = prefs.minDuration
+
+        prefMinDuration.summary = if (minDuration == 0) {
+            getString(R.string.pref_min_duration_desc_zero)
+        } else {
+            resources.getQuantityString(R.plurals.pref_min_duration_desc, minDuration, minDuration)
+        }
+    }
+
     private fun refreshVersion() {
         val suffix = if (prefs.isDebugMode) {
             "+debugmode"
@@ -232,6 +248,11 @@ class SettingsFragment : PreferenceFragmentCompat(), Preference.OnPreferenceChan
                 )
                 return true
             }
+            prefMinDuration -> {
+                MinDurationDialogFragment().show(
+                    parentFragmentManager.beginTransaction(), MinDurationDialogFragment.TAG)
+                return true
+            }
             prefVersion -> {
                 val uri = Uri.parse(BuildConfig.PROJECT_URL_AT_COMMIT)
                 startActivity(Intent(Intent.ACTION_VIEW, uri))
@@ -276,22 +297,26 @@ class SettingsFragment : PreferenceFragmentCompat(), Preference.OnPreferenceChan
         when {
             key == null -> return
             // Update the switch state if it was toggled outside of the preference (eg. from the
-            // quick settings toggle)
+            // quick settings toggle).
             key == prefCallRecording.key -> {
                 val current = prefCallRecording.isChecked
                 val expected = sharedPreferences.getBoolean(key, current)
                 if (current != expected) {
                     prefCallRecording.isChecked = expected
                 }
             }
-            // Update the output directory state when it's changed by the bottom sheet
+            // Update the output directory state when it's changed by the bottom sheet.
             key == Preferences.PREF_OUTPUT_DIR || key == Preferences.PREF_OUTPUT_RETENTION -> {
                 refreshOutputDir()
             }
-            // Update the output format state when it's changed by the bottom sheet
+            // Update the output format state when it's changed by the bottom sheet.
             Preferences.isFormatKey(key) || key == Preferences.PREF_SAMPLE_RATE -> {
                 refreshOutputFormat()
             }
+            // Update when it's changed by the dialog.
+            key == Preferences.PREF_MIN_DURATION -> {
+                refreshMinDuration()
+            }
         }
     }
 }
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
diff --git a/app/src/main/res/xml/root_preferences.xml b/app/src/main/res/xml/root_preferences.xml
