all: reformat with ktfmt

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

3 files changed, 155 insertions, 169 deletions

diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/ShowSshKeyFragment.kt b/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/ShowSshKeyFragment.kt
index 42346ccc..ee54febe 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/ShowSshKeyFragment.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/ShowSshKeyFragment.kt
@@ -14,25 +14,24 @@ import dev.msfjarvis.aps.util.git.sshj.SshKey
 
 class ShowSshKeyFragment : DialogFragment() {
 
-    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
-        val activity = requireActivity()
-        val publicKey = SshKey.sshPublicKey
-        return MaterialAlertDialogBuilder(requireActivity()).run {
-            setMessage(getString(R.string.ssh_keygen_message, publicKey))
-            setTitle(R.string.your_public_key)
-            setNegativeButton(R.string.ssh_keygen_later) { _, _ ->
-                (activity as? SshKeyGenActivity)?.finish()
-            }
-            setPositiveButton(R.string.ssh_keygen_share) { _, _ ->
-                val sendIntent = Intent().apply {
-                    action = Intent.ACTION_SEND
-                    type = "text/plain"
-                    putExtra(Intent.EXTRA_TEXT, publicKey)
-                }
-                startActivity(Intent.createChooser(sendIntent, null))
-                (activity as? SshKeyGenActivity)?.finish()
-            }
-            create()
-        }
+  override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+    val activity = requireActivity()
+    val publicKey = SshKey.sshPublicKey
+    return MaterialAlertDialogBuilder(requireActivity()).run {
+      setMessage(getString(R.string.ssh_keygen_message, publicKey))
+      setTitle(R.string.your_public_key)
+      setNegativeButton(R.string.ssh_keygen_later) { _, _ -> (activity as? SshKeyGenActivity)?.finish() }
+      setPositiveButton(R.string.ssh_keygen_share) { _, _ ->
+        val sendIntent =
+          Intent().apply {
+            action = Intent.ACTION_SEND
+            type = "text/plain"
+            putExtra(Intent.EXTRA_TEXT, publicKey)
+          }
+        startActivity(Intent.createChooser(sendIntent, null))
+        (activity as? SshKeyGenActivity)?.finish()
+      }
+      create()
     }
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyGenActivity.kt b/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyGenActivity.kt
index fb977cd1..c2025538 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyGenActivity.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyGenActivity.kt
@@ -30,135 +30,122 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
 private enum class KeyGenType(val generateKey: suspend (requireAuthentication: Boolean) -> Unit) {
-    Rsa({ requireAuthentication ->
-        SshKey.generateKeystoreNativeKey(SshKey.Algorithm.Rsa, requireAuthentication)
-    }),
-    Ecdsa({ requireAuthentication ->
-        SshKey.generateKeystoreNativeKey(SshKey.Algorithm.Ecdsa, requireAuthentication)
-    }),
-    Ed25519({ requireAuthentication ->
-        SshKey.generateKeystoreWrappedEd25519Key(requireAuthentication)
-    }),
+  Rsa({ requireAuthentication -> SshKey.generateKeystoreNativeKey(SshKey.Algorithm.Rsa, requireAuthentication) }),
+  Ecdsa({ requireAuthentication -> SshKey.generateKeystoreNativeKey(SshKey.Algorithm.Ecdsa, requireAuthentication) }),
+  Ed25519({ requireAuthentication -> SshKey.generateKeystoreWrappedEd25519Key(requireAuthentication) }),
 }
 
 class SshKeyGenActivity : AppCompatActivity() {
 
-    private var keyGenType = KeyGenType.Ecdsa
-    private val binding by viewBinding(ActivitySshKeygenBinding::inflate)
+  private var keyGenType = KeyGenType.Ecdsa
+  private val binding by viewBinding(ActivitySshKeygenBinding::inflate)
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(binding.root)
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-        with(binding) {
-            generate.setOnClickListener {
-                if (SshKey.exists) {
-                    MaterialAlertDialogBuilder(this@SshKeyGenActivity).run {
-                        setTitle(R.string.ssh_keygen_existing_title)
-                        setMessage(R.string.ssh_keygen_existing_message)
-                        setPositiveButton(R.string.ssh_keygen_existing_replace) { _, _ ->
-                            lifecycleScope.launch {
-                                generate()
-                            }
-                        }
-                        setNegativeButton(R.string.ssh_keygen_existing_keep) { _, _ ->
-                            finish()
-                        }
-                        show()
-                    }
-                } else {
-                    lifecycleScope.launch {
-                        generate()
-                    }
-                }
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(binding.root)
+    supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    with(binding) {
+      generate.setOnClickListener {
+        if (SshKey.exists) {
+          MaterialAlertDialogBuilder(this@SshKeyGenActivity).run {
+            setTitle(R.string.ssh_keygen_existing_title)
+            setMessage(R.string.ssh_keygen_existing_message)
+            setPositiveButton(R.string.ssh_keygen_existing_replace) { _, _ -> lifecycleScope.launch { generate() } }
+            setNegativeButton(R.string.ssh_keygen_existing_keep) { _, _ -> finish() }
+            show()
+          }
+        } else {
+          lifecycleScope.launch { generate() }
+        }
+      }
+      keyTypeGroup.check(R.id.key_type_ecdsa)
+      keyTypeExplanation.setText(R.string.ssh_keygen_explanation_ecdsa)
+      keyTypeGroup.addOnButtonCheckedListener { _, checkedId, isChecked ->
+        if (isChecked) {
+          keyGenType =
+            when (checkedId) {
+              R.id.key_type_ed25519 -> KeyGenType.Ed25519
+              R.id.key_type_ecdsa -> KeyGenType.Ecdsa
+              R.id.key_type_rsa -> KeyGenType.Rsa
+              else -> throw IllegalStateException("Impossible key type selection")
             }
-            keyTypeGroup.check(R.id.key_type_ecdsa)
-            keyTypeExplanation.setText(R.string.ssh_keygen_explanation_ecdsa)
-            keyTypeGroup.addOnButtonCheckedListener { _, checkedId, isChecked ->
-                if (isChecked) {
-                    keyGenType = when (checkedId) {
-                        R.id.key_type_ed25519 -> KeyGenType.Ed25519
-                        R.id.key_type_ecdsa -> KeyGenType.Ecdsa
-                        R.id.key_type_rsa -> KeyGenType.Rsa
-                        else -> throw IllegalStateException("Impossible key type selection")
-                    }
-                    keyTypeExplanation.setText(when (keyGenType) {
-                        KeyGenType.Ed25519 -> R.string.ssh_keygen_explanation_ed25519
-                        KeyGenType.Ecdsa -> R.string.ssh_keygen_explanation_ecdsa
-                        KeyGenType.Rsa -> R.string.ssh_keygen_explanation_rsa
-                    })
-                }
+          keyTypeExplanation.setText(
+            when (keyGenType) {
+              KeyGenType.Ed25519 -> R.string.ssh_keygen_explanation_ed25519
+              KeyGenType.Ecdsa -> R.string.ssh_keygen_explanation_ecdsa
+              KeyGenType.Rsa -> R.string.ssh_keygen_explanation_rsa
             }
-            keyRequireAuthentication.isEnabled = keyguardManager.isDeviceSecure
-            keyRequireAuthentication.isChecked = keyRequireAuthentication.isEnabled
+          )
         }
+      }
+      keyRequireAuthentication.isEnabled = keyguardManager.isDeviceSecure
+      keyRequireAuthentication.isChecked = keyRequireAuthentication.isEnabled
     }
+  }
 
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        return when (item.itemId) {
-            android.R.id.home -> {
-                onBackPressed()
-                true
-            }
-            else -> super.onOptionsItemSelected(item)
-        }
+  override fun onOptionsItemSelected(item: MenuItem): Boolean {
+    return when (item.itemId) {
+      android.R.id.home -> {
+        onBackPressed()
+        true
+      }
+      else -> super.onOptionsItemSelected(item)
     }
+  }
 
-    private suspend fun generate() {
-        binding.generate.apply {
-            text = getString(R.string.ssh_key_gen_generating_progress)
-            isEnabled = false
-        }
-        binding.generate.text = getString(R.string.ssh_key_gen_generating_progress)
-        val result = runCatching {
-            withContext(Dispatchers.IO) {
-                val requireAuthentication = binding.keyRequireAuthentication.isChecked
-                if (requireAuthentication) {
-                    val result = withContext(Dispatchers.Main) {
-                        suspendCoroutine<BiometricAuthenticator.Result> { cont ->
-                            BiometricAuthenticator.authenticate(this@SshKeyGenActivity, R.string.biometric_prompt_title_ssh_keygen) {
-                                cont.resume(it)
-                            }
-                        }
-                    }
-                    if (result !is BiometricAuthenticator.Result.Success)
-                        throw UserNotAuthenticatedException(getString(R.string.biometric_auth_generic_failure))
-                }
-                keyGenType.generateKey(requireAuthentication)
+  private suspend fun generate() {
+    binding.generate.apply {
+      text = getString(R.string.ssh_key_gen_generating_progress)
+      isEnabled = false
+    }
+    binding.generate.text = getString(R.string.ssh_key_gen_generating_progress)
+    val result = runCatching {
+      withContext(Dispatchers.IO) {
+        val requireAuthentication = binding.keyRequireAuthentication.isChecked
+        if (requireAuthentication) {
+          val result =
+            withContext(Dispatchers.Main) {
+              suspendCoroutine<BiometricAuthenticator.Result> { cont ->
+                BiometricAuthenticator.authenticate(
+                  this@SshKeyGenActivity,
+                  R.string.biometric_prompt_title_ssh_keygen
+                ) { cont.resume(it) }
+              }
             }
+          if (result !is BiometricAuthenticator.Result.Success)
+            throw UserNotAuthenticatedException(getString(R.string.biometric_auth_generic_failure))
         }
-        getEncryptedGitPrefs().edit {
-            remove("ssh_key_local_passphrase")
-        }
-        binding.generate.apply {
-            text = getString(R.string.ssh_keygen_generate)
-            isEnabled = true
-        }
-        result.fold(
-            success = {
-                ShowSshKeyFragment().show(supportFragmentManager, "public_key")
-            },
-            failure = { e ->
-                e.printStackTrace()
-                MaterialAlertDialogBuilder(this)
-                    .setTitle(getString(R.string.error_generate_ssh_key))
-                    .setMessage(getString(R.string.ssh_key_error_dialog_text) + e.message)
-                    .setPositiveButton(getString(R.string.dialog_ok)) { _, _ ->
-                        setResult(RESULT_OK)
-                        finish()
-                    }
-                    .show()
-            },
-        )
-        hideKeyboard()
+        keyGenType.generateKey(requireAuthentication)
+      }
     }
+    getEncryptedGitPrefs().edit { remove("ssh_key_local_passphrase") }
+    binding.generate.apply {
+      text = getString(R.string.ssh_keygen_generate)
+      isEnabled = true
+    }
+    result.fold(
+      success = { ShowSshKeyFragment().show(supportFragmentManager, "public_key") },
+      failure = { e ->
+        e.printStackTrace()
+        MaterialAlertDialogBuilder(this)
+          .setTitle(getString(R.string.error_generate_ssh_key))
+          .setMessage(getString(R.string.ssh_key_error_dialog_text) + e.message)
+          .setPositiveButton(getString(R.string.dialog_ok)) { _, _ ->
+            setResult(RESULT_OK)
+            finish()
+          }
+          .show()
+      },
+    )
+    hideKeyboard()
+  }
 
-    private fun hideKeyboard() {
-        val imm = getSystemService<InputMethodManager>() ?: return
-        var view = currentFocus
-        if (view == null) {
-            view = View(this)
-        }
-        imm.hideSoftInputFromWindow(view.windowToken, 0)
+  private fun hideKeyboard() {
+    val imm = getSystemService<InputMethodManager>() ?: return
+    var view = currentFocus
+    if (view == null) {
+      view = View(this)
     }
+    imm.hideSoftInputFromWindow(view.windowToken, 0)
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyImportActivity.kt b/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyImportActivity.kt
index 2d482d3c..bf9f6eda 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyImportActivity.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/sshkeygen/SshKeyImportActivity.kt
@@ -18,44 +18,44 @@ import dev.msfjarvis.aps.util.git.sshj.SshKey
 
 class SshKeyImportActivity : AppCompatActivity() {
 
-    private val sshKeyImportAction = registerForActivityResult(ActivityResultContracts.OpenDocument()) { uri: Uri? ->
-        if (uri == null)  {
-            finish()
-            return@registerForActivityResult
-        }
-        runCatching {
-            SshKey.import(uri)
-            Toast.makeText(this, resources.getString(R.string.ssh_key_success_dialog_title), Toast.LENGTH_LONG).show()
-            setResult(RESULT_OK)
-            finish()
-        }.onFailure { e ->
-            MaterialAlertDialogBuilder(this)
-                .setTitle(resources.getString(R.string.ssh_key_error_dialog_title))
-                .setMessage(e.message)
-                .setPositiveButton(resources.getString(R.string.dialog_ok)) { _, _ -> finish() }
-                .show()
+  private val sshKeyImportAction =
+    registerForActivityResult(ActivityResultContracts.OpenDocument()) { uri: Uri? ->
+      if (uri == null) {
+        finish()
+        return@registerForActivityResult
+      }
+      runCatching {
+        SshKey.import(uri)
+        Toast.makeText(this, resources.getString(R.string.ssh_key_success_dialog_title), Toast.LENGTH_LONG).show()
+        setResult(RESULT_OK)
+        finish()
+      }
+        .onFailure { e ->
+          MaterialAlertDialogBuilder(this)
+            .setTitle(resources.getString(R.string.ssh_key_error_dialog_title))
+            .setMessage(e.message)
+            .setPositiveButton(resources.getString(R.string.dialog_ok)) { _, _ -> finish() }
+            .show()
         }
     }
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        if (SshKey.exists) {
-            MaterialAlertDialogBuilder(this).run {
-                setTitle(R.string.ssh_keygen_existing_title)
-                setMessage(R.string.ssh_keygen_existing_message)
-                setPositiveButton(R.string.ssh_keygen_existing_replace) { _, _ ->
-                    importSshKey()
-                }
-                setNegativeButton(R.string.ssh_keygen_existing_keep) { _, _ -> finish() }
-                setOnCancelListener { finish() }
-                show()
-            }
-        } else {
-            importSshKey()
-        }
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    if (SshKey.exists) {
+      MaterialAlertDialogBuilder(this).run {
+        setTitle(R.string.ssh_keygen_existing_title)
+        setMessage(R.string.ssh_keygen_existing_message)
+        setPositiveButton(R.string.ssh_keygen_existing_replace) { _, _ -> importSshKey() }
+        setNegativeButton(R.string.ssh_keygen_existing_keep) { _, _ -> finish() }
+        setOnCancelListener { finish() }
+        show()
+      }
+    } else {
+      importSshKey()
     }
+  }
 
-    private fun importSshKey() {
-        sshKeyImportAction.launch(arrayOf("*/*"))
-    }
+  private fun importSshKey() {
+    sshKeyImportAction.launch(arrayOf("*/*"))
+  }
 }