all: reformat with ktfmt

Signed-off-by: Harsh Shandilya <me@msfjarvis.dev>

8 files changed, 532 insertions, 524 deletions

diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/AutofillSettings.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/AutofillSettings.kt
index 20ca403c..ee6b468b 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/AutofillSettings.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/AutofillSettings.kt
@@ -33,94 +33,94 @@ import dev.msfjarvis.aps.util.settings.PreferenceKeys
 
 class AutofillSettings(private val activity: FragmentActivity) : SettingsProvider {
 
-    private val isAutofillServiceEnabled: Boolean
-        get() {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false
-            return activity.autofillManager?.hasEnabledAutofillServices() == true
-        }
+  private val isAutofillServiceEnabled: Boolean
+    get() {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false
+      return activity.autofillManager?.hasEnabledAutofillServices() == true
+    }
 
-    @RequiresApi(Build.VERSION_CODES.O)
-    private fun showAutofillDialog(pref: SwitchPreference) {
-        val observer = LifecycleEventObserver { _, event ->
-            when (event) {
-                Lifecycle.Event.ON_RESUME -> {
-                    pref.checked = isAutofillServiceEnabled
-                }
-                else -> {
-                }
-            }
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun showAutofillDialog(pref: SwitchPreference) {
+    val observer = LifecycleEventObserver { _, event ->
+      when (event) {
+        Lifecycle.Event.ON_RESUME -> {
+          pref.checked = isAutofillServiceEnabled
         }
-        MaterialAlertDialogBuilder(activity).run {
-            setTitle(R.string.pref_autofill_enable_title)
-            @SuppressLint("InflateParams")
-            val layout =
-                activity.layoutInflater.inflate(R.layout.oreo_autofill_instructions, null)
-            val supportedBrowsersTextView =
-                layout.findViewById<AppCompatTextView>(R.id.supportedBrowsers)
-            supportedBrowsersTextView.text =
-                getInstalledBrowsersWithAutofillSupportLevel(context).joinToString(
-                    separator = "\n"
-                ) {
-                    val appLabel = it.first
-                    val supportDescription = when (it.second) {
-                        BrowserAutofillSupportLevel.None -> activity.getString(R.string.oreo_autofill_no_support)
-                        BrowserAutofillSupportLevel.FlakyFill -> activity.getString(R.string.oreo_autofill_flaky_fill_support)
-                        BrowserAutofillSupportLevel.PasswordFill -> activity.getString(R.string.oreo_autofill_password_fill_support)
-                        BrowserAutofillSupportLevel.PasswordFillAndSaveIfNoAccessibility -> activity.getString(R.string.oreo_autofill_password_fill_and_conditional_save_support)
-                        BrowserAutofillSupportLevel.GeneralFill -> activity.getString(R.string.oreo_autofill_general_fill_support)
-                        BrowserAutofillSupportLevel.GeneralFillAndSave -> activity.getString(R.string.oreo_autofill_general_fill_and_save_support)
-                    }
-                    "$appLabel: $supportDescription"
-                }
-            setView(layout)
-            setPositiveButton(R.string.dialog_ok) { _, _ ->
-                val intent = Intent(Settings.ACTION_REQUEST_SET_AUTOFILL_SERVICE).apply {
-                    data = Uri.parse("package:${BuildConfig.APPLICATION_ID}")
-                }
-                activity.startActivity(intent)
+        else -> {}
+      }
+    }
+    MaterialAlertDialogBuilder(activity).run {
+      setTitle(R.string.pref_autofill_enable_title)
+      @SuppressLint("InflateParams")
+      val layout = activity.layoutInflater.inflate(R.layout.oreo_autofill_instructions, null)
+      val supportedBrowsersTextView = layout.findViewById<AppCompatTextView>(R.id.supportedBrowsers)
+      supportedBrowsersTextView.text =
+        getInstalledBrowsersWithAutofillSupportLevel(context).joinToString(separator = "\n") {
+          val appLabel = it.first
+          val supportDescription =
+            when (it.second) {
+              BrowserAutofillSupportLevel.None -> activity.getString(R.string.oreo_autofill_no_support)
+              BrowserAutofillSupportLevel.FlakyFill -> activity.getString(R.string.oreo_autofill_flaky_fill_support)
+              BrowserAutofillSupportLevel.PasswordFill ->
+                activity.getString(R.string.oreo_autofill_password_fill_support)
+              BrowserAutofillSupportLevel.PasswordFillAndSaveIfNoAccessibility ->
+                activity.getString(R.string.oreo_autofill_password_fill_and_conditional_save_support)
+              BrowserAutofillSupportLevel.GeneralFill -> activity.getString(R.string.oreo_autofill_general_fill_support)
+              BrowserAutofillSupportLevel.GeneralFillAndSave ->
+                activity.getString(R.string.oreo_autofill_general_fill_and_save_support)
             }
-            setNegativeButton(R.string.dialog_cancel, null)
-            setOnDismissListener { pref.checked = isAutofillServiceEnabled }
-            activity.lifecycle.addObserver(observer)
-            show()
+          "$appLabel: $supportDescription"
         }
+      setView(layout)
+      setPositiveButton(R.string.dialog_ok) { _, _ ->
+        val intent =
+          Intent(Settings.ACTION_REQUEST_SET_AUTOFILL_SERVICE).apply {
+            data = Uri.parse("package:${BuildConfig.APPLICATION_ID}")
+          }
+        activity.startActivity(intent)
+      }
+      setNegativeButton(R.string.dialog_cancel, null)
+      setOnDismissListener { pref.checked = isAutofillServiceEnabled }
+      activity.lifecycle.addObserver(observer)
+      show()
     }
+  }
 
-    override fun provideSettings(builder: PreferenceScreen.Builder) {
-        builder.apply {
-            switch(PreferenceKeys.AUTOFILL_ENABLE) {
-                titleRes = R.string.pref_autofill_enable_title
-                visible = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
-                defaultValue = isAutofillServiceEnabled
-                onClick {
-                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return@onClick true
-                    if (isAutofillServiceEnabled) {
-                        activity.autofillManager?.disableAutofillServices()
-                    } else {
-                        showAutofillDialog(this)
-                    }
-                    false
-                }
-            }
-            val values = activity.resources.getStringArray(R.array.oreo_autofill_directory_structure_values)
-            val titles = activity.resources.getStringArray(R.array.oreo_autofill_directory_structure_entries)
-            val items = values.zip(titles).map { SelectionItem(it.first, it.second, null) }
-            singleChoice(PreferenceKeys.OREO_AUTOFILL_DIRECTORY_STRUCTURE, items) {
-                initialSelection = DirectoryStructure.DEFAULT.value
-                dependency = PreferenceKeys.AUTOFILL_ENABLE
-                titleRes = R.string.oreo_autofill_preference_directory_structure
-            }
-            editText(PreferenceKeys.OREO_AUTOFILL_DEFAULT_USERNAME) {
-                dependency = PreferenceKeys.AUTOFILL_ENABLE
-                titleRes = R.string.preference_default_username_title
-                summaryProvider = { activity.getString(R.string.preference_default_username_summary) }
-            }
-            editText(PreferenceKeys.OREO_AUTOFILL_CUSTOM_PUBLIC_SUFFIXES) {
-                dependency = PreferenceKeys.AUTOFILL_ENABLE
-                titleRes = R.string.preference_custom_public_suffixes_title
-                summaryProvider = { activity.getString(R.string.preference_custom_public_suffixes_summary) }
-                textInputHintRes = R.string.preference_custom_public_suffixes_hint
-            }
+  override fun provideSettings(builder: PreferenceScreen.Builder) {
+    builder.apply {
+      switch(PreferenceKeys.AUTOFILL_ENABLE) {
+        titleRes = R.string.pref_autofill_enable_title
+        visible = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
+        defaultValue = isAutofillServiceEnabled
+        onClick {
+          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return@onClick true
+          if (isAutofillServiceEnabled) {
+            activity.autofillManager?.disableAutofillServices()
+          } else {
+            showAutofillDialog(this)
+          }
+          false
         }
+      }
+      val values = activity.resources.getStringArray(R.array.oreo_autofill_directory_structure_values)
+      val titles = activity.resources.getStringArray(R.array.oreo_autofill_directory_structure_entries)
+      val items = values.zip(titles).map { SelectionItem(it.first, it.second, null) }
+      singleChoice(PreferenceKeys.OREO_AUTOFILL_DIRECTORY_STRUCTURE, items) {
+        initialSelection = DirectoryStructure.DEFAULT.value
+        dependency = PreferenceKeys.AUTOFILL_ENABLE
+        titleRes = R.string.oreo_autofill_preference_directory_structure
+      }
+      editText(PreferenceKeys.OREO_AUTOFILL_DEFAULT_USERNAME) {
+        dependency = PreferenceKeys.AUTOFILL_ENABLE
+        titleRes = R.string.preference_default_username_title
+        summaryProvider = { activity.getString(R.string.preference_default_username_summary) }
+      }
+      editText(PreferenceKeys.OREO_AUTOFILL_CUSTOM_PUBLIC_SUFFIXES) {
+        dependency = PreferenceKeys.AUTOFILL_ENABLE
+        titleRes = R.string.preference_custom_public_suffixes_title
+        summaryProvider = { activity.getString(R.string.preference_custom_public_suffixes_summary) }
+        textInputHintRes = R.string.preference_custom_public_suffixes_hint
+      }
     }
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/DirectorySelectionActivity.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/DirectorySelectionActivity.kt
index a2d246f1..475d3b5e 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/DirectorySelectionActivity.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/DirectorySelectionActivity.kt
@@ -20,37 +20,38 @@ import dev.msfjarvis.aps.util.settings.PreferenceKeys
 
 class DirectorySelectionActivity : AppCompatActivity() {
 
-    @Suppress("DEPRECATION")
-    private val directorySelectAction = registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) { uri: Uri? ->
-        if (uri == null) return@registerForActivityResult
-
-        d { "Selected repository URI is $uri" }
-        // TODO: This is fragile. Workaround until PasswordItem is backed by DocumentFile
-        val docId = DocumentsContract.getTreeDocumentId(uri)
-        val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
-        val path = if (split.size > 1) split[1] else split[0]
-        val repoPath = "${Environment.getExternalStorageDirectory()}/$path"
-        val prefs = sharedPrefs
-
-        d { "Selected repository path is $repoPath" }
-
-        if (Environment.getExternalStorageDirectory().path == repoPath) {
-            MaterialAlertDialogBuilder(this)
-                .setTitle(resources.getString(R.string.sdcard_root_warning_title))
-                .setMessage(resources.getString(R.string.sdcard_root_warning_message))
-                .setPositiveButton(resources.getString(R.string.sdcard_root_warning_remove_everything)) { _, _ ->
-                    prefs.edit { putString(PreferenceKeys.GIT_EXTERNAL_REPO, uri.path) }
-                }
-                .setNegativeButton(R.string.dialog_cancel, null)
-                .show()
-        }
-        prefs.edit { putString(PreferenceKeys.GIT_EXTERNAL_REPO, repoPath) }
-        setResult(RESULT_OK)
-        finish()
+  @Suppress("DEPRECATION")
+  private val directorySelectAction =
+    registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) { uri: Uri? ->
+      if (uri == null) return@registerForActivityResult
+
+      d { "Selected repository URI is $uri" }
+      // TODO: This is fragile. Workaround until PasswordItem is backed by DocumentFile
+      val docId = DocumentsContract.getTreeDocumentId(uri)
+      val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+      val path = if (split.size > 1) split[1] else split[0]
+      val repoPath = "${Environment.getExternalStorageDirectory()}/$path"
+      val prefs = sharedPrefs
+
+      d { "Selected repository path is $repoPath" }
+
+      if (Environment.getExternalStorageDirectory().path == repoPath) {
+        MaterialAlertDialogBuilder(this)
+          .setTitle(resources.getString(R.string.sdcard_root_warning_title))
+          .setMessage(resources.getString(R.string.sdcard_root_warning_message))
+          .setPositiveButton(resources.getString(R.string.sdcard_root_warning_remove_everything)) { _, _ ->
+            prefs.edit { putString(PreferenceKeys.GIT_EXTERNAL_REPO, uri.path) }
+          }
+          .setNegativeButton(R.string.dialog_cancel, null)
+          .show()
+      }
+      prefs.edit { putString(PreferenceKeys.GIT_EXTERNAL_REPO, repoPath) }
+      setResult(RESULT_OK)
+      finish()
     }
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        directorySelectAction.launch(null)
-    }
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    directorySelectAction.launch(null)
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/GeneralSettings.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/GeneralSettings.kt
index 64b9c3f1..39501d52 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/GeneralSettings.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/GeneralSettings.kt
@@ -22,83 +22,85 @@ import dev.msfjarvis.aps.util.settings.PreferenceKeys
 
 class GeneralSettings(private val activity: FragmentActivity) : SettingsProvider {
 
-    override fun provideSettings(builder: PreferenceScreen.Builder) {
-        builder.apply {
-            val themeValues = activity.resources.getStringArray(R.array.app_theme_values)
-            val themeOptions = activity.resources.getStringArray(R.array.app_theme_options)
-            val themeItems = themeValues.zip(themeOptions).map { SelectionItem(it.first, it.second, null) }
-            singleChoice(PreferenceKeys.APP_THEME, themeItems) {
-                initialSelection = activity.resources.getString(R.string.app_theme_def)
-                titleRes = R.string.pref_app_theme_title
-            }
+  override fun provideSettings(builder: PreferenceScreen.Builder) {
+    builder.apply {
+      val themeValues = activity.resources.getStringArray(R.array.app_theme_values)
+      val themeOptions = activity.resources.getStringArray(R.array.app_theme_options)
+      val themeItems = themeValues.zip(themeOptions).map { SelectionItem(it.first, it.second, null) }
+      singleChoice(PreferenceKeys.APP_THEME, themeItems) {
+        initialSelection = activity.resources.getString(R.string.app_theme_def)
+        titleRes = R.string.pref_app_theme_title
+      }
 
-            val sortValues = activity.resources.getStringArray(R.array.sort_order_values)
-            val sortOptions = activity.resources.getStringArray(R.array.sort_order_entries)
-            val sortItems = sortValues.zip(sortOptions).map { SelectionItem(it.first, it.second, null) }
-            singleChoice(PreferenceKeys.SORT_ORDER, sortItems) {
-                initialSelection = sortValues[0]
-                titleRes = R.string.pref_sort_order_title
-            }
+      val sortValues = activity.resources.getStringArray(R.array.sort_order_values)
+      val sortOptions = activity.resources.getStringArray(R.array.sort_order_entries)
+      val sortItems = sortValues.zip(sortOptions).map { SelectionItem(it.first, it.second, null) }
+      singleChoice(PreferenceKeys.SORT_ORDER, sortItems) {
+        initialSelection = sortValues[0]
+        titleRes = R.string.pref_sort_order_title
+      }
 
-            checkBox(PreferenceKeys.FILTER_RECURSIVELY) {
-                titleRes = R.string.pref_recursive_filter_title
-                summaryRes = R.string.pref_recursive_filter_summary
-                defaultValue = true
-            }
+      checkBox(PreferenceKeys.FILTER_RECURSIVELY) {
+        titleRes = R.string.pref_recursive_filter_title
+        summaryRes = R.string.pref_recursive_filter_summary
+        defaultValue = true
+      }
 
-            checkBox(PreferenceKeys.SEARCH_ON_START) {
-                titleRes = R.string.pref_search_on_start_title
-                summaryRes = R.string.pref_search_on_start_summary
-                defaultValue = false
-            }
+      checkBox(PreferenceKeys.SEARCH_ON_START) {
+        titleRes = R.string.pref_search_on_start_title
+        summaryRes = R.string.pref_search_on_start_summary
+        defaultValue = false
+      }
 
-            checkBox(PreferenceKeys.SHOW_HIDDEN_CONTENTS) {
-                titleRes = R.string.pref_show_hidden_title
-                summaryRes = R.string.pref_show_hidden_summary
-                defaultValue = false
-            }
+      checkBox(PreferenceKeys.SHOW_HIDDEN_CONTENTS) {
+        titleRes = R.string.pref_show_hidden_title
+        summaryRes = R.string.pref_show_hidden_summary
+        defaultValue = false
+      }
 
-            checkBox(PreferenceKeys.BIOMETRIC_AUTH) {
-                titleRes = R.string.pref_biometric_auth_title
-                defaultValue = false
-            }.apply {
-                val canAuthenticate = BiometricAuthenticator.canAuthenticate(activity)
-                if (!canAuthenticate) {
-                    enabled = false
-                    checked = false
-                    summaryRes = R.string.pref_biometric_auth_summary_error
-                } else {
-                    summaryRes = R.string.pref_biometric_auth_summary
-                    onClick {
-                        enabled = false
-                        val isChecked = checked
-                        activity.sharedPrefs.edit {
-                            BiometricAuthenticator.authenticate(activity) { result ->
-                                when (result) {
-                                    is BiometricAuthenticator.Result.Success -> {
-                                        // Apply the changes
-                                        putBoolean(PreferenceKeys.BIOMETRIC_AUTH, checked)
-                                        enabled = true
-                                    }
-                                    else -> {
-                                        // If any error occurs, revert back to the previous state. This
-                                        // catch-all clause includes the cancellation case.
-                                        putBoolean(PreferenceKeys.BIOMETRIC_AUTH, !checked)
-                                        checked = !isChecked
-                                        enabled = true
-                                    }
-                                }
-                            }
-                        }
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
-                            activity.getSystemService<ShortcutManager>()?.apply {
-                                removeDynamicShortcuts(dynamicShortcuts.map { it.id }.toMutableList())
-                            }
-                        }
-                        false
+      checkBox(PreferenceKeys.BIOMETRIC_AUTH) {
+        titleRes = R.string.pref_biometric_auth_title
+        defaultValue = false
+      }
+        .apply {
+          val canAuthenticate = BiometricAuthenticator.canAuthenticate(activity)
+          if (!canAuthenticate) {
+            enabled = false
+            checked = false
+            summaryRes = R.string.pref_biometric_auth_summary_error
+          } else {
+            summaryRes = R.string.pref_biometric_auth_summary
+            onClick {
+              enabled = false
+              val isChecked = checked
+              activity.sharedPrefs.edit {
+                BiometricAuthenticator.authenticate(activity) { result ->
+                  when (result) {
+                    is BiometricAuthenticator.Result.Success -> {
+                      // Apply the changes
+                      putBoolean(PreferenceKeys.BIOMETRIC_AUTH, checked)
+                      enabled = true
+                    }
+                    else -> {
+                      // If any error occurs, revert back to the previous
+                      // state. This
+                      // catch-all clause includes the cancellation case.
+                      putBoolean(PreferenceKeys.BIOMETRIC_AUTH, !checked)
+                      checked = !isChecked
+                      enabled = true
                     }
+                  }
+                }
+              }
+              if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
+                activity.getSystemService<ShortcutManager>()?.apply {
+                  removeDynamicShortcuts(dynamicShortcuts.map { it.id }.toMutableList())
                 }
+              }
+              false
             }
+          }
         }
     }
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/MiscSettings.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/MiscSettings.kt
index faed1c3c..8921317b 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/MiscSettings.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/MiscSettings.kt
@@ -23,54 +23,59 @@ import dev.msfjarvis.aps.util.settings.PreferenceKeys
 
 class MiscSettings(activity: FragmentActivity) : SettingsProvider {
 
-    private val storeExportAction = activity.registerForActivityResult(object : ActivityResultContracts.OpenDocumentTree() {
+  private val storeExportAction =
+    activity.registerForActivityResult(
+      object : ActivityResultContracts.OpenDocumentTree() {
         override fun createIntent(context: Context, input: Uri?): Intent {
-            return super.createIntent(context, input).apply {
-                flags = Intent.FLAG_GRANT_READ_URI_PERMISSION or
-                    Intent.FLAG_GRANT_WRITE_URI_PERMISSION or
-                    Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION or
-                    Intent.FLAG_GRANT_PREFIX_URI_PERMISSION
-            }
+          return super.createIntent(context, input).apply {
+            flags =
+              Intent.FLAG_GRANT_READ_URI_PERMISSION or
+                Intent.FLAG_GRANT_WRITE_URI_PERMISSION or
+                Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION or
+                Intent.FLAG_GRANT_PREFIX_URI_PERMISSION
+          }
         }
-    }) { uri: Uri? ->
-        if (uri == null) return@registerForActivityResult
-        val targetDirectory = DocumentFile.fromTreeUri(activity.applicationContext, uri)
+      }
+    ) { uri: Uri? ->
+      if (uri == null) return@registerForActivityResult
+      val targetDirectory = DocumentFile.fromTreeUri(activity.applicationContext, uri)
 
-        if (targetDirectory != null) {
-            val service = Intent(activity.applicationContext, PasswordExportService::class.java).apply {
-                action = PasswordExportService.ACTION_EXPORT_PASSWORD
-                putExtra("uri", uri)
-            }
+      if (targetDirectory != null) {
+        val service =
+          Intent(activity.applicationContext, PasswordExportService::class.java).apply {
+            action = PasswordExportService.ACTION_EXPORT_PASSWORD
+            putExtra("uri", uri)
+          }
 
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                activity.startForegroundService(service)
-            } else {
-                activity.startService(service)
-            }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          activity.startForegroundService(service)
+        } else {
+          activity.startService(service)
         }
+      }
     }
 
-    override fun provideSettings(builder: PreferenceScreen.Builder) {
-        builder.apply {
-            pref(PreferenceKeys.EXPORT_PASSWORDS) {
-                titleRes = R.string.prefs_export_passwords_title
-                summaryRes = R.string.prefs_export_passwords_summary
-                onClick {
-                    storeExportAction.launch(null)
-                    true
-                }
-            }
-            checkBox(PreferenceKeys.CLEAR_CLIPBOARD_HISTORY) {
-                defaultValue = false
-                titleRes = R.string.pref_clear_clipboard_title
-                summaryRes = R.string.pref_clear_clipboard_summary
-            }
-            checkBox(PreferenceKeys.ENABLE_DEBUG_LOGGING) {
-                defaultValue = false
-                titleRes = R.string.pref_debug_logging_title
-                summaryRes = R.string.pref_debug_logging_summary
-                visible = !BuildConfig.DEBUG
-            }
+  override fun provideSettings(builder: PreferenceScreen.Builder) {
+    builder.apply {
+      pref(PreferenceKeys.EXPORT_PASSWORDS) {
+        titleRes = R.string.prefs_export_passwords_title
+        summaryRes = R.string.prefs_export_passwords_summary
+        onClick {
+          storeExportAction.launch(null)
+          true
         }
+      }
+      checkBox(PreferenceKeys.CLEAR_CLIPBOARD_HISTORY) {
+        defaultValue = false
+        titleRes = R.string.pref_clear_clipboard_title
+        summaryRes = R.string.pref_clear_clipboard_summary
+      }
+      checkBox(PreferenceKeys.ENABLE_DEBUG_LOGGING) {
+        defaultValue = false
+        titleRes = R.string.pref_debug_logging_title
+        summaryRes = R.string.pref_debug_logging_summary
+        visible = !BuildConfig.DEBUG
+      }
     }
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/PasswordSettings.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/PasswordSettings.kt
index 98748584..ca72e4b1 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/PasswordSettings.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/PasswordSettings.kt
@@ -29,85 +29,90 @@ import java.io.File
 
 class PasswordSettings(private val activity: FragmentActivity) : SettingsProvider {
 
-    private val sharedPrefs by lazy(LazyThreadSafetyMode.NONE) { activity.sharedPrefs }
-    private val storeCustomXkpwdDictionaryAction = activity.registerForActivityResult(ActivityResultContracts.OpenDocument()) { uri ->
-        if (uri == null) return@registerForActivityResult
+  private val sharedPrefs by lazy(LazyThreadSafetyMode.NONE) { activity.sharedPrefs }
+  private val storeCustomXkpwdDictionaryAction =
+    activity.registerForActivityResult(ActivityResultContracts.OpenDocument()) { uri ->
+      if (uri == null) return@registerForActivityResult
 
-        Toast.makeText(
-            activity,
-            activity.resources.getString(R.string.xkpwgen_custom_dict_imported, uri.path),
-            Toast.LENGTH_SHORT
-        ).show()
+      Toast.makeText(
+          activity,
+          activity.resources.getString(R.string.xkpwgen_custom_dict_imported, uri.path),
+          Toast.LENGTH_SHORT
+        )
+        .show()
 
-        sharedPrefs.edit { putString(PreferenceKeys.PREF_KEY_CUSTOM_DICT, uri.toString()) }
+      sharedPrefs.edit { putString(PreferenceKeys.PREF_KEY_CUSTOM_DICT, uri.toString()) }
 
-        val inputStream = activity.contentResolver.openInputStream(uri)
-        val customDictFile = File(activity.filesDir.toString(), XkpwdDictionary.XKPWD_CUSTOM_DICT_FILE).outputStream()
-        inputStream?.copyTo(customDictFile, 1024)
-        inputStream?.close()
-        customDictFile.close()
+      val inputStream = activity.contentResolver.openInputStream(uri)
+      val customDictFile = File(activity.filesDir.toString(), XkpwdDictionary.XKPWD_CUSTOM_DICT_FILE).outputStream()
+      inputStream?.copyTo(customDictFile, 1024)
+      inputStream?.close()
+      customDictFile.close()
     }
 
-    override fun provideSettings(builder: PreferenceScreen.Builder) {
-        builder.apply {
-            val customDictPref = CheckBoxPreference(PreferenceKeys.PREF_KEY_IS_CUSTOM_DICT).apply {
-                titleRes = R.string.pref_xkpwgen_custom_wordlist_enabled_title
-                summaryRes = R.string.pref_xkpwgen_custom_dict_summary_off
-                summaryOnRes = R.string.pref_xkpwgen_custom_dict_summary_on
-                visible = sharedPrefs.getString(PreferenceKeys.PREF_KEY_PWGEN_TYPE) == "xkpasswd"
-                onCheckedChange {
-                    requestRebind()
-                    true
-                }
-            }
-            val customDictPathPref = Preference(PreferenceKeys.PREF_KEY_CUSTOM_DICT).apply {
-                dependency = PreferenceKeys.PREF_KEY_IS_CUSTOM_DICT
-                titleRes = R.string.pref_xkpwgen_custom_dict_picker_title
-                summary = sharedPrefs.getString(PreferenceKeys.PREF_KEY_CUSTOM_DICT)
-                    ?: activity.resources.getString(R.string.pref_xkpwgen_custom_dict_picker_summary)
-                visible = sharedPrefs.getString(PreferenceKeys.PREF_KEY_PWGEN_TYPE) == "xkpasswd"
-                onClick {
-                    storeCustomXkpwdDictionaryAction.launch(arrayOf("*/*"))
-                    true
-                }
-            }
-            val values = activity.resources.getStringArray(R.array.pwgen_provider_values)
-            val labels = activity.resources.getStringArray(R.array.pwgen_provider_labels)
-            val items = values.zip(labels).map { SelectionItem(it.first, it.second, null) }
-            singleChoice(
-                PreferenceKeys.PREF_KEY_PWGEN_TYPE,
-                items,
-            ) {
-                initialSelection = "classic"
-                titleRes = R.string.pref_password_generator_type_title
-                onSelectionChange { selection ->
-                    val xkpasswdEnabled = selection == "xkpasswd"
-                    customDictPathPref.visible = xkpasswdEnabled
-                    customDictPref.visible = xkpasswdEnabled
-                    customDictPref.requestRebind()
-                    customDictPathPref.requestRebind()
-                    true
-                }
-            }
-            // We initialize them early and add them manually to be able to manually force a rebind
-            // when the password generator type is changed.
-            addPreferenceItem(customDictPref)
-            addPreferenceItem(customDictPathPref)
-            editText(PreferenceKeys.GENERAL_SHOW_TIME) {
-                titleRes = R.string.pref_clipboard_timeout_title
-                summaryProvider = { activity.getString(R.string.pref_clipboard_timeout_summary) }
-                textInputType = InputType.TYPE_CLASS_NUMBER
-            }
-            checkBox(PreferenceKeys.SHOW_PASSWORD) {
-                titleRes = R.string.show_password_pref_title
-                summaryRes = R.string.show_password_pref_summary
-                defaultValue = true
-            }
-            checkBox(PreferenceKeys.COPY_ON_DECRYPT) {
-                titleRes = R.string.pref_copy_title
-                summaryRes = R.string.pref_copy_summary
-                defaultValue = false
-            }
+  override fun provideSettings(builder: PreferenceScreen.Builder) {
+    builder.apply {
+      val customDictPref =
+        CheckBoxPreference(PreferenceKeys.PREF_KEY_IS_CUSTOM_DICT).apply {
+          titleRes = R.string.pref_xkpwgen_custom_wordlist_enabled_title
+          summaryRes = R.string.pref_xkpwgen_custom_dict_summary_off
+          summaryOnRes = R.string.pref_xkpwgen_custom_dict_summary_on
+          visible = sharedPrefs.getString(PreferenceKeys.PREF_KEY_PWGEN_TYPE) == "xkpasswd"
+          onCheckedChange {
+            requestRebind()
+            true
+          }
         }
+      val customDictPathPref =
+        Preference(PreferenceKeys.PREF_KEY_CUSTOM_DICT).apply {
+          dependency = PreferenceKeys.PREF_KEY_IS_CUSTOM_DICT
+          titleRes = R.string.pref_xkpwgen_custom_dict_picker_title
+          summary =
+            sharedPrefs.getString(PreferenceKeys.PREF_KEY_CUSTOM_DICT)
+              ?: activity.resources.getString(R.string.pref_xkpwgen_custom_dict_picker_summary)
+          visible = sharedPrefs.getString(PreferenceKeys.PREF_KEY_PWGEN_TYPE) == "xkpasswd"
+          onClick {
+            storeCustomXkpwdDictionaryAction.launch(arrayOf("*/*"))
+            true
+          }
+        }
+      val values = activity.resources.getStringArray(R.array.pwgen_provider_values)
+      val labels = activity.resources.getStringArray(R.array.pwgen_provider_labels)
+      val items = values.zip(labels).map { SelectionItem(it.first, it.second, null) }
+      singleChoice(
+        PreferenceKeys.PREF_KEY_PWGEN_TYPE,
+        items,
+      ) {
+        initialSelection = "classic"
+        titleRes = R.string.pref_password_generator_type_title
+        onSelectionChange { selection ->
+          val xkpasswdEnabled = selection == "xkpasswd"
+          customDictPathPref.visible = xkpasswdEnabled
+          customDictPref.visible = xkpasswdEnabled
+          customDictPref.requestRebind()
+          customDictPathPref.requestRebind()
+          true
+        }
+      }
+      // We initialize them early and add them manually to be able to manually force a rebind
+      // when the password generator type is changed.
+      addPreferenceItem(customDictPref)
+      addPreferenceItem(customDictPathPref)
+      editText(PreferenceKeys.GENERAL_SHOW_TIME) {
+        titleRes = R.string.pref_clipboard_timeout_title
+        summaryProvider = { activity.getString(R.string.pref_clipboard_timeout_summary) }
+        textInputType = InputType.TYPE_CLASS_NUMBER
+      }
+      checkBox(PreferenceKeys.SHOW_PASSWORD) {
+        titleRes = R.string.show_password_pref_title
+        summaryRes = R.string.show_password_pref_summary
+        defaultValue = true
+      }
+      checkBox(PreferenceKeys.COPY_ON_DECRYPT) {
+        titleRes = R.string.pref_copy_title
+        summaryRes = R.string.pref_copy_summary
+        defaultValue = false
+      }
     }
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/RepositorySettings.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/RepositorySettings.kt
index afd54298..3e99c890 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/RepositorySettings.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/RepositorySettings.kt
@@ -37,168 +37,165 @@ import dev.msfjarvis.aps.util.settings.PreferenceKeys
 
 class RepositorySettings(private val activity: FragmentActivity) : SettingsProvider {
 
-    private val encryptedPreferences by lazy(LazyThreadSafetyMode.NONE) { activity.getEncryptedGitPrefs() }
+  private val encryptedPreferences by lazy(LazyThreadSafetyMode.NONE) { activity.getEncryptedGitPrefs() }
 
-    private fun <T : FragmentActivity> launchActivity(clazz: Class<T>) {
-        activity.startActivity(Intent(activity, clazz))
-    }
+  private fun <T : FragmentActivity> launchActivity(clazz: Class<T>) {
+    activity.startActivity(Intent(activity, clazz))
+  }
 
-    private fun selectExternalGitRepository() {
-        MaterialAlertDialogBuilder(activity)
-            .setTitle(activity.resources.getString(R.string.external_repository_dialog_title))
-            .setMessage(activity.resources.getString(R.string.external_repository_dialog_text))
-            .setPositiveButton(R.string.dialog_ok) { _, _ ->
-                launchActivity(DirectorySelectionActivity::class.java)
-            }
-            .setNegativeButton(R.string.dialog_cancel, null)
-            .show()
-    }
+  private fun selectExternalGitRepository() {
+    MaterialAlertDialogBuilder(activity)
+      .setTitle(activity.resources.getString(R.string.external_repository_dialog_title))
+      .setMessage(activity.resources.getString(R.string.external_repository_dialog_text))
+      .setPositiveButton(R.string.dialog_ok) { _, _ -> launchActivity(DirectorySelectionActivity::class.java) }
+      .setNegativeButton(R.string.dialog_cancel, null)
+      .show()
+  }
 
-    override fun provideSettings(builder: PreferenceScreen.Builder) {
-        builder.apply {
-            checkBox(PreferenceKeys.REBASE_ON_PULL) {
-                titleRes = R.string.pref_rebase_on_pull_title
-                summaryRes = R.string.pref_rebase_on_pull_summary
-                summaryOnRes = R.string.pref_rebase_on_pull_summary_on
-                defaultValue = true
-            }
-            pref(PreferenceKeys.GIT_SERVER_INFO) {
-                titleRes = R.string.pref_edit_git_server_settings
-                visible = PasswordRepository.isGitRepo()
-                onClick {
-                    launchActivity(GitServerConfigActivity::class.java)
-                    true
-                }
-            }
-            pref(PreferenceKeys.PROXY_SETTINGS) {
-                titleRes = R.string.pref_edit_proxy_settings
-                visible = GitSettings.url?.startsWith("https") == true && PasswordRepository.isGitRepo()
-                onClick {
-                    launchActivity(ProxySelectorActivity::class.java)
-                    true
-                }
-            }
-            pref(PreferenceKeys.GIT_CONFIG) {
-                titleRes = R.string.pref_edit_git_config
-                visible = PasswordRepository.isGitRepo()
-                onClick {
-                    launchActivity(GitConfigActivity::class.java)
-                    true
-                }
-            }
-            pref(PreferenceKeys.SSH_KEY) {
-                titleRes = R.string.pref_import_ssh_key_title
-                visible = PasswordRepository.isGitRepo()
-                onClick {
-                    launchActivity(SshKeyImportActivity::class.java)
-                    true
-                }
-            }
-            pref(PreferenceKeys.SSH_KEYGEN) {
-                titleRes = R.string.pref_ssh_keygen_title
-                onClick {
-                    launchActivity(SshKeyGenActivity::class.java)
-                    true
-                }
-            }
-            pref(PreferenceKeys.SSH_SEE_KEY) {
-                titleRes = R.string.pref_ssh_see_key_title
-                visible = PasswordRepository.isGitRepo()
-                onClick {
-                    ShowSshKeyFragment().show(activity.supportFragmentManager, "public_key")
-                    true
-                }
-            }
-            pref(PreferenceKeys.CLEAR_SAVED_PASS) {
-                fun Preference.updatePref() {
-                    val sshPass = encryptedPreferences.getString(PreferenceKeys.SSH_KEY_LOCAL_PASSPHRASE)
-                    val httpsPass = encryptedPreferences.getString(PreferenceKeys.HTTPS_PASSWORD)
-                    if (sshPass == null && httpsPass == null) {
-                        visible = false
-                        return
-                    }
-                    when {
-                        httpsPass != null -> titleRes = R.string.clear_saved_passphrase_https
-                        sshPass != null -> titleRes = R.string.clear_saved_passphrase_ssh
-                    }
-                    visible = true
-                    requestRebind()
-                }
-                onClick {
-                    updatePref()
-                    true
-                }
-                updatePref()
-            }
-            pref(PreferenceKeys.SSH_OPENKEYSTORE_CLEAR_KEY_ID) {
-                titleRes = R.string.pref_title_openkeystore_clear_keyid
-                visible = activity.sharedPrefs.getString(PreferenceKeys.SSH_OPENKEYSTORE_KEYID)?.isNotEmpty()
-                    ?: false
-                onClick {
-                    activity.sharedPrefs.edit { putString(PreferenceKeys.SSH_OPENKEYSTORE_KEYID, null) }
-                    visible = false
-                    true
+  override fun provideSettings(builder: PreferenceScreen.Builder) {
+    builder.apply {
+      checkBox(PreferenceKeys.REBASE_ON_PULL) {
+        titleRes = R.string.pref_rebase_on_pull_title
+        summaryRes = R.string.pref_rebase_on_pull_summary
+        summaryOnRes = R.string.pref_rebase_on_pull_summary_on
+        defaultValue = true
+      }
+      pref(PreferenceKeys.GIT_SERVER_INFO) {
+        titleRes = R.string.pref_edit_git_server_settings
+        visible = PasswordRepository.isGitRepo()
+        onClick {
+          launchActivity(GitServerConfigActivity::class.java)
+          true
+        }
+      }
+      pref(PreferenceKeys.PROXY_SETTINGS) {
+        titleRes = R.string.pref_edit_proxy_settings
+        visible = GitSettings.url?.startsWith("https") == true && PasswordRepository.isGitRepo()
+        onClick {
+          launchActivity(ProxySelectorActivity::class.java)
+          true
+        }
+      }
+      pref(PreferenceKeys.GIT_CONFIG) {
+        titleRes = R.string.pref_edit_git_config
+        visible = PasswordRepository.isGitRepo()
+        onClick {
+          launchActivity(GitConfigActivity::class.java)
+          true
+        }
+      }
+      pref(PreferenceKeys.SSH_KEY) {
+        titleRes = R.string.pref_import_ssh_key_title
+        visible = PasswordRepository.isGitRepo()
+        onClick {
+          launchActivity(SshKeyImportActivity::class.java)
+          true
+        }
+      }
+      pref(PreferenceKeys.SSH_KEYGEN) {
+        titleRes = R.string.pref_ssh_keygen_title
+        onClick {
+          launchActivity(SshKeyGenActivity::class.java)
+          true
+        }
+      }
+      pref(PreferenceKeys.SSH_SEE_KEY) {
+        titleRes = R.string.pref_ssh_see_key_title
+        visible = PasswordRepository.isGitRepo()
+        onClick {
+          ShowSshKeyFragment().show(activity.supportFragmentManager, "public_key")
+          true
+        }
+      }
+      pref(PreferenceKeys.CLEAR_SAVED_PASS) {
+        fun Preference.updatePref() {
+          val sshPass = encryptedPreferences.getString(PreferenceKeys.SSH_KEY_LOCAL_PASSPHRASE)
+          val httpsPass = encryptedPreferences.getString(PreferenceKeys.HTTPS_PASSWORD)
+          if (sshPass == null && httpsPass == null) {
+            visible = false
+            return
+          }
+          when {
+            httpsPass != null -> titleRes = R.string.clear_saved_passphrase_https
+            sshPass != null -> titleRes = R.string.clear_saved_passphrase_ssh
+          }
+          visible = true
+          requestRebind()
+        }
+        onClick {
+          updatePref()
+          true
+        }
+        updatePref()
+      }
+      pref(PreferenceKeys.SSH_OPENKEYSTORE_CLEAR_KEY_ID) {
+        titleRes = R.string.pref_title_openkeystore_clear_keyid
+        visible = activity.sharedPrefs.getString(PreferenceKeys.SSH_OPENKEYSTORE_KEYID)?.isNotEmpty() ?: false
+        onClick {
+          activity.sharedPrefs.edit { putString(PreferenceKeys.SSH_OPENKEYSTORE_KEYID, null) }
+          visible = false
+          true
+        }
+      }
+      val deleteRepoPref =
+        pref(PreferenceKeys.GIT_DELETE_REPO) {
+          titleRes = R.string.pref_git_delete_repo_title
+          summaryRes = R.string.pref_git_delete_repo_summary
+          visible = !activity.sharedPrefs.getBoolean(PreferenceKeys.GIT_EXTERNAL, false)
+          onClick {
+            val repoDir = PasswordRepository.getRepositoryDirectory()
+            MaterialAlertDialogBuilder(activity)
+              .setTitle(R.string.pref_dialog_delete_title)
+              .setMessage(activity.getString(R.string.dialog_delete_msg, repoDir))
+              .setCancelable(false)
+              .setPositiveButton(R.string.dialog_delete) { dialogInterface, _ ->
+                runCatching {
+                  PasswordRepository.getRepositoryDirectory().deleteRecursively()
+                  PasswordRepository.closeRepository()
                 }
-            }
-            val deleteRepoPref = pref(PreferenceKeys.GIT_DELETE_REPO) {
-                titleRes = R.string.pref_git_delete_repo_title
-                summaryRes = R.string.pref_git_delete_repo_summary
-                visible = !activity.sharedPrefs.getBoolean(PreferenceKeys.GIT_EXTERNAL, false)
-                onClick {
-                    val repoDir = PasswordRepository.getRepositoryDirectory()
-                    MaterialAlertDialogBuilder(activity)
-                        .setTitle(R.string.pref_dialog_delete_title)
-                        .setMessage(activity.getString(R.string.dialog_delete_msg, repoDir))
-                        .setCancelable(false)
-                        .setPositiveButton(R.string.dialog_delete) { dialogInterface, _ ->
-                            runCatching {
-                                PasswordRepository.getRepositoryDirectory().deleteRecursively()
-                                PasswordRepository.closeRepository()
-                            }.onFailure {
-                                it.message?.let { message ->
-                                    activity.snackbar(message = message)
-                                }
-                            }
+                  .onFailure { it.message?.let { message -> activity.snackbar(message = message) } }
 
-                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
-                                activity.getSystemService<ShortcutManager>()?.apply {
-                                    removeDynamicShortcuts(dynamicShortcuts.map { it.id }.toMutableList())
-                                }
-                            }
-                            activity.sharedPrefs.edit { putBoolean(PreferenceKeys.REPOSITORY_INITIALIZED, false) }
-                            dialogInterface.cancel()
-                            activity.finish()
-                        }
-                        .setNegativeButton(R.string.dialog_do_not_delete) { dialogInterface, _ -> run { dialogInterface.cancel() } }
-                        .show()
-                    true
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
+                  activity.getSystemService<ShortcutManager>()?.apply {
+                    removeDynamicShortcuts(dynamicShortcuts.map { it.id }.toMutableList())
+                  }
                 }
-            }
-            checkBox(PreferenceKeys.GIT_EXTERNAL) {
-                titleRes = R.string.pref_external_repository_title
-                summaryRes = R.string.pref_external_repository_summary
-                onCheckedChange { checked ->
-                    deleteRepoPref.visible = !checked
-                    deleteRepoPref.requestRebind()
-                    PasswordRepository.closeRepository()
-                    activity.sharedPrefs.edit { putBoolean(PreferenceKeys.REPO_CHANGED, true) }
-                    true
-                }
-            }
-            pref(PreferenceKeys.GIT_EXTERNAL_REPO) {
-                val externalRepo = activity.sharedPrefs.getString(PreferenceKeys.GIT_EXTERNAL_REPO)
-                if (externalRepo != null) {
-                    summary = externalRepo
-                } else {
-                    summaryRes = R.string.pref_select_external_repository_summary_no_repo_selected
-                }
-                titleRes = R.string.pref_select_external_repository_title
-                dependency = PreferenceKeys.GIT_EXTERNAL
-                onClick {
-                    selectExternalGitRepository()
-                    true
-                }
-            }
+                activity.sharedPrefs.edit { putBoolean(PreferenceKeys.REPOSITORY_INITIALIZED, false) }
+                dialogInterface.cancel()
+                activity.finish()
+              }
+              .setNegativeButton(R.string.dialog_do_not_delete) { dialogInterface, _ ->
+                run { dialogInterface.cancel() }
+              }
+              .show()
+            true
+          }
+        }
+      checkBox(PreferenceKeys.GIT_EXTERNAL) {
+        titleRes = R.string.pref_external_repository_title
+        summaryRes = R.string.pref_external_repository_summary
+        onCheckedChange { checked ->
+          deleteRepoPref.visible = !checked
+          deleteRepoPref.requestRebind()
+          PasswordRepository.closeRepository()
+          activity.sharedPrefs.edit { putBoolean(PreferenceKeys.REPO_CHANGED, true) }
+          true
+        }
+      }
+      pref(PreferenceKeys.GIT_EXTERNAL_REPO) {
+        val externalRepo = activity.sharedPrefs.getString(PreferenceKeys.GIT_EXTERNAL_REPO)
+        if (externalRepo != null) {
+          summary = externalRepo
+        } else {
+          summaryRes = R.string.pref_select_external_repository_summary_no_repo_selected
+        }
+        titleRes = R.string.pref_select_external_repository_title
+        dependency = PreferenceKeys.GIT_EXTERNAL
+        onClick {
+          selectExternalGitRepository()
+          true
         }
+      }
     }
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsActivity.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsActivity.kt
index d593bd21..ceb6599b 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsActivity.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsActivity.kt
@@ -17,77 +17,79 @@ import dev.msfjarvis.aps.util.extensions.viewBinding
 
 class SettingsActivity : AppCompatActivity() {
 
-    private val miscSettings = MiscSettings(this)
-    private val autofillSettings = AutofillSettings(this)
-    private val passwordSettings = PasswordSettings(this)
-    private val repositorySettings = RepositorySettings(this)
-    private val generalSettings = GeneralSettings(this)
+  private val miscSettings = MiscSettings(this)
+  private val autofillSettings = AutofillSettings(this)
+  private val passwordSettings = PasswordSettings(this)
+  private val repositorySettings = RepositorySettings(this)
+  private val generalSettings = GeneralSettings(this)
 
-    private val binding by viewBinding(ActivityPreferenceRecyclerviewBinding::inflate)
-    private val preferencesAdapter: PreferencesAdapter
-        get() = binding.preferenceRecyclerView.adapter as PreferencesAdapter
+  private val binding by viewBinding(ActivityPreferenceRecyclerviewBinding::inflate)
+  private val preferencesAdapter: PreferencesAdapter
+    get() = binding.preferenceRecyclerView.adapter as PreferencesAdapter
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(binding.root)
-        val screen = screen(this) {
-            subScreen {
-                titleRes = R.string.pref_category_general_title
-                iconRes = R.drawable.app_settings_alt_24px
-                generalSettings.provideSettings(this)
-            }
-            subScreen {
-                titleRes = R.string.pref_category_autofill_title
-                iconRes = R.drawable.ic_wysiwyg_24px
-                autofillSettings.provideSettings(this)
-            }
-            subScreen {
-                titleRes = R.string.pref_category_passwords_title
-                iconRes = R.drawable.ic_lock_open_24px
-                passwordSettings.provideSettings(this)
-            }
-            subScreen {
-                titleRes = R.string.pref_category_repository_title
-                iconRes = R.drawable.ic_call_merge_24px
-                repositorySettings.provideSettings(this)
-            }
-            subScreen {
-                titleRes = R.string.pref_category_misc_title
-                iconRes = R.drawable.ic_miscellaneous_services_24px
-                miscSettings.provideSettings(this)
-            }
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(binding.root)
+    val screen =
+      screen(this) {
+        subScreen {
+          titleRes = R.string.pref_category_general_title
+          iconRes = R.drawable.app_settings_alt_24px
+          generalSettings.provideSettings(this)
         }
-        val adapter = PreferencesAdapter(screen)
-        adapter.onScreenChangeListener = PreferencesAdapter.OnScreenChangeListener { subScreen, entering ->
-            supportActionBar?.title = if (!entering) {
-                getString(R.string.action_settings)
-            } else {
-                getString(subScreen.titleRes)
-            }
+        subScreen {
+          titleRes = R.string.pref_category_autofill_title
+          iconRes = R.drawable.ic_wysiwyg_24px
+          autofillSettings.provideSettings(this)
         }
-        savedInstanceState?.getParcelable<PreferencesAdapter.SavedState>("adapter")
-            ?.let(adapter::loadSavedState)
-        binding.preferenceRecyclerView.adapter = adapter
-    }
+        subScreen {
+          titleRes = R.string.pref_category_passwords_title
+          iconRes = R.drawable.ic_lock_open_24px
+          passwordSettings.provideSettings(this)
+        }
+        subScreen {
+          titleRes = R.string.pref_category_repository_title
+          iconRes = R.drawable.ic_call_merge_24px
+          repositorySettings.provideSettings(this)
+        }
+        subScreen {
+          titleRes = R.string.pref_category_misc_title
+          iconRes = R.drawable.ic_miscellaneous_services_24px
+          miscSettings.provideSettings(this)
+        }
+      }
+    val adapter = PreferencesAdapter(screen)
+    adapter.onScreenChangeListener =
+      PreferencesAdapter.OnScreenChangeListener { subScreen, entering ->
+        supportActionBar?.title =
+          if (!entering) {
+            getString(R.string.action_settings)
+          } else {
+            getString(subScreen.titleRes)
+          }
+      }
+    savedInstanceState?.getParcelable<PreferencesAdapter.SavedState>("adapter")?.let(adapter::loadSavedState)
+    binding.preferenceRecyclerView.adapter = adapter
+  }
 
-    override fun onSaveInstanceState(outState: Bundle) {
-        super.onSaveInstanceState(outState)
-        outState.putParcelable("adapter", preferencesAdapter.getSavedState())
-    }
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+    outState.putParcelable("adapter", preferencesAdapter.getSavedState())
+  }
 
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        return when (item.itemId) {
-            android.R.id.home -> if (!preferencesAdapter.goBack()) {
-                super.onOptionsItemSelected(item)
-            } else {
-                true
-            }
-            else -> super.onOptionsItemSelected(item)
+  override fun onOptionsItemSelected(item: MenuItem): Boolean {
+    return when (item.itemId) {
+      android.R.id.home ->
+        if (!preferencesAdapter.goBack()) {
+          super.onOptionsItemSelected(item)
+        } else {
+          true
         }
+      else -> super.onOptionsItemSelected(item)
     }
+  }
 
-    override fun onBackPressed() {
-        if (!preferencesAdapter.goBack())
-            super.onBackPressed()
-    }
+  override fun onBackPressed() {
+    if (!preferencesAdapter.goBack()) super.onBackPressed()
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsProvider.kt b/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsProvider.kt
index 3599703e..61b11064 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsProvider.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/settings/SettingsProvider.kt
@@ -7,13 +7,9 @@ package dev.msfjarvis.aps.ui.settings
 
 import de.Maxr1998.modernpreferences.PreferenceScreen
 
-/**
- * Used to generate a uniform API for all settings UI classes.
- */
+/** Used to generate a uniform API for all settings UI classes. */
 interface SettingsProvider {
 
-    /**
-     * Inserts the settings items for the class into the given [builder].
-     */
-    fun provideSettings(builder: PreferenceScreen.Builder)
+  /** Inserts the settings items for the class into the given [builder]. */
+  fun provideSettings(builder: PreferenceScreen.Builder)
 }