all: reformat with ktfmt

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

1 files changed, 154 insertions, 165 deletions

diff --git a/app/src/main/java/dev/msfjarvis/aps/ui/autofill/AutofillDecryptActivity.kt b/app/src/main/java/dev/msfjarvis/aps/ui/autofill/AutofillDecryptActivity.kt
index 94274c37..ab1f402d 100644
--- a/app/src/main/java/dev/msfjarvis/aps/ui/autofill/AutofillDecryptActivity.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/ui/autofill/AutofillDecryptActivity.kt
@@ -51,195 +51,184 @@ import org.openintents.openpgp.OpenPgpError
 @RequiresApi(Build.VERSION_CODES.O)
 class AutofillDecryptActivity : AppCompatActivity(), CoroutineScope {
 
-    companion object {
+  companion object {
 
-        private const val EXTRA_FILE_PATH = "dev.msfjarvis.aps.autofill.oreo.EXTRA_FILE_PATH"
-        private const val EXTRA_SEARCH_ACTION =
-            "dev.msfjarvis.aps.autofill.oreo.EXTRA_SEARCH_ACTION"
+    private const val EXTRA_FILE_PATH = "dev.msfjarvis.aps.autofill.oreo.EXTRA_FILE_PATH"
+    private const val EXTRA_SEARCH_ACTION = "dev.msfjarvis.aps.autofill.oreo.EXTRA_SEARCH_ACTION"
 
-        private var decryptFileRequestCode = 1
+    private var decryptFileRequestCode = 1
 
-        fun makeDecryptFileIntent(file: File, forwardedExtras: Bundle, context: Context): Intent {
-            return Intent(context, AutofillDecryptActivity::class.java).apply {
-                putExtras(forwardedExtras)
-                putExtra(EXTRA_SEARCH_ACTION, true)
-                putExtra(EXTRA_FILE_PATH, file.absolutePath)
-            }
-        }
+    fun makeDecryptFileIntent(file: File, forwardedExtras: Bundle, context: Context): Intent {
+      return Intent(context, AutofillDecryptActivity::class.java).apply {
+        putExtras(forwardedExtras)
+        putExtra(EXTRA_SEARCH_ACTION, true)
+        putExtra(EXTRA_FILE_PATH, file.absolutePath)
+      }
+    }
 
-        fun makeDecryptFileIntentSender(file: File, context: Context): IntentSender {
-            val intent = Intent(context, AutofillDecryptActivity::class.java).apply {
-                putExtra(EXTRA_SEARCH_ACTION, false)
-                putExtra(EXTRA_FILE_PATH, file.absolutePath)
-            }
-            return PendingIntent.getActivity(
-                context,
-                decryptFileRequestCode++,
-                intent,
-                PendingIntent.FLAG_CANCEL_CURRENT
-            ).intentSender
+    fun makeDecryptFileIntentSender(file: File, context: Context): IntentSender {
+      val intent =
+        Intent(context, AutofillDecryptActivity::class.java).apply {
+          putExtra(EXTRA_SEARCH_ACTION, false)
+          putExtra(EXTRA_FILE_PATH, file.absolutePath)
         }
+      return PendingIntent.getActivity(context, decryptFileRequestCode++, intent, PendingIntent.FLAG_CANCEL_CURRENT)
+        .intentSender
     }
+  }
 
-    private val decryptInteractionRequiredAction = registerForActivityResult(StartIntentSenderForResult()) { result ->
-        if (continueAfterUserInteraction != null) {
-            val data = result.data
-            if (result.resultCode == RESULT_OK && data != null) {
-                continueAfterUserInteraction?.resume(data)
-            } else {
-                continueAfterUserInteraction?.resumeWithException(Exception("OpenPgpApi ACTION_DECRYPT_VERIFY failed to continue after user interaction"))
-            }
-            continueAfterUserInteraction = null
+  private val decryptInteractionRequiredAction =
+    registerForActivityResult(StartIntentSenderForResult()) { result ->
+      if (continueAfterUserInteraction != null) {
+        val data = result.data
+        if (result.resultCode == RESULT_OK && data != null) {
+          continueAfterUserInteraction?.resume(data)
+        } else {
+          continueAfterUserInteraction?.resumeWithException(
+            Exception("OpenPgpApi ACTION_DECRYPT_VERIFY failed to continue after user interaction")
+          )
         }
+        continueAfterUserInteraction = null
+      }
     }
 
-    private var continueAfterUserInteraction: Continuation<Intent>? = null
-    private lateinit var directoryStructure: DirectoryStructure
+  private var continueAfterUserInteraction: Continuation<Intent>? = null
+  private lateinit var directoryStructure: DirectoryStructure
 
-    override val coroutineContext
-        get() = Dispatchers.IO + SupervisorJob()
+  override val coroutineContext
+    get() = Dispatchers.IO + SupervisorJob()
 
-    override fun onStart() {
-        super.onStart()
-        val filePath = intent?.getStringExtra(EXTRA_FILE_PATH) ?: run {
-            e { "AutofillDecryptActivity started without EXTRA_FILE_PATH" }
-            finish()
-            return
+  override fun onStart() {
+    super.onStart()
+    val filePath =
+      intent?.getStringExtra(EXTRA_FILE_PATH)
+        ?: run {
+          e { "AutofillDecryptActivity started without EXTRA_FILE_PATH" }
+          finish()
+          return
         }
-        val clientState = intent?.getBundleExtra(AutofillManager.EXTRA_CLIENT_STATE) ?: run {
-            e { "AutofillDecryptActivity started without EXTRA_CLIENT_STATE" }
-            finish()
-            return
+    val clientState =
+      intent?.getBundleExtra(AutofillManager.EXTRA_CLIENT_STATE)
+        ?: run {
+          e { "AutofillDecryptActivity started without EXTRA_CLIENT_STATE" }
+          finish()
+          return
         }
-        val isSearchAction = intent?.getBooleanExtra(EXTRA_SEARCH_ACTION, true)!!
-        val action = if (isSearchAction) AutofillAction.Search else AutofillAction.Match
-        directoryStructure = AutofillPreferences.directoryStructure(this)
-        d { action.toString() }
-        launch {
-            val credentials = decryptCredential(File(filePath))
-            if (credentials == null) {
-                setResult(RESULT_CANCELED)
-            } else {
-                val fillInDataset =
-                    AutofillResponseBuilder.makeFillInDataset(
-                        this@AutofillDecryptActivity,
-                        credentials,
-                        clientState,
-                        action
-                    )
-                withContext(Dispatchers.Main) {
-                    setResult(RESULT_OK, Intent().apply {
-                        putExtra(AutofillManager.EXTRA_AUTHENTICATION_RESULT, fillInDataset)
-                    })
-                }
-            }
-            withContext(Dispatchers.Main) {
-                finish()
-            }
+    val isSearchAction = intent?.getBooleanExtra(EXTRA_SEARCH_ACTION, true)!!
+    val action = if (isSearchAction) AutofillAction.Search else AutofillAction.Match
+    directoryStructure = AutofillPreferences.directoryStructure(this)
+    d { action.toString() }
+    launch {
+      val credentials = decryptCredential(File(filePath))
+      if (credentials == null) {
+        setResult(RESULT_CANCELED)
+      } else {
+        val fillInDataset =
+          AutofillResponseBuilder.makeFillInDataset(this@AutofillDecryptActivity, credentials, clientState, action)
+        withContext(Dispatchers.Main) {
+          setResult(RESULT_OK, Intent().apply { putExtra(AutofillManager.EXTRA_AUTHENTICATION_RESULT, fillInDataset) })
         }
+      }
+      withContext(Dispatchers.Main) { finish() }
     }
+  }
 
-    override fun onDestroy() {
-        super.onDestroy()
-        coroutineContext.cancelChildren()
-    }
+  override fun onDestroy() {
+    super.onDestroy()
+    coroutineContext.cancelChildren()
+  }
 
-    private suspend fun executeOpenPgpApi(
-        data: Intent,
-        input: InputStream,
-        output: OutputStream
-    ): Intent? {
-        var openPgpServiceConnection: OpenPgpServiceConnection? = null
-        val openPgpService = suspendCoroutine<IOpenPgpService2> { cont ->
-            openPgpServiceConnection = OpenPgpServiceConnection(
-                this,
-                OPENPGP_PROVIDER,
-                object : OpenPgpServiceConnection.OnBound {
-                    override fun onBound(service: IOpenPgpService2) {
-                        cont.resume(service)
-                    }
+  private suspend fun executeOpenPgpApi(data: Intent, input: InputStream, output: OutputStream): Intent? {
+    var openPgpServiceConnection: OpenPgpServiceConnection? = null
+    val openPgpService =
+      suspendCoroutine<IOpenPgpService2> { cont ->
+        openPgpServiceConnection =
+          OpenPgpServiceConnection(
+              this,
+              OPENPGP_PROVIDER,
+              object : OpenPgpServiceConnection.OnBound {
+                override fun onBound(service: IOpenPgpService2) {
+                  cont.resume(service)
+                }
 
-                    override fun onError(e: Exception) {
-                        cont.resumeWithException(e)
-                    }
-                }).also { it.bindToService() }
-        }
-        return OpenPgpApi(this, openPgpService).executeApi(data, input, output).also {
-            openPgpServiceConnection?.unbindFromService()
-        }
+                override fun onError(e: Exception) {
+                  cont.resumeWithException(e)
+                }
+              }
+            )
+            .also { it.bindToService() }
+      }
+    return OpenPgpApi(this, openPgpService).executeApi(data, input, output).also {
+      openPgpServiceConnection?.unbindFromService()
     }
+  }
 
-    private suspend fun decryptCredential(
-        file: File,
-        resumeIntent: Intent? = null
-    ): Credentials? {
-        val command = resumeIntent ?: Intent().apply {
-            action = OpenPgpApi.ACTION_DECRYPT_VERIFY
-        }
-        runCatching {
-            file.inputStream()
-        }.onFailure { e ->
-            e(e) { "File to decrypt not found" }
+  private suspend fun decryptCredential(file: File, resumeIntent: Intent? = null): Credentials? {
+    val command = resumeIntent ?: Intent().apply { action = OpenPgpApi.ACTION_DECRYPT_VERIFY }
+    runCatching { file.inputStream() }
+      .onFailure { e ->
+        e(e) { "File to decrypt not found" }
+        return null
+      }
+      .onSuccess { encryptedInput ->
+        val decryptedOutput = ByteArrayOutputStream()
+        runCatching { executeOpenPgpApi(command, encryptedInput, decryptedOutput) }
+          .onFailure { e ->
+            e(e) { "OpenPgpApi ACTION_DECRYPT_VERIFY failed" }
             return null
-        }.onSuccess { encryptedInput ->
-            val decryptedOutput = ByteArrayOutputStream()
-            runCatching {
-                executeOpenPgpApi(command, encryptedInput, decryptedOutput)
-            }.onFailure { e ->
-                e(e) { "OpenPgpApi ACTION_DECRYPT_VERIFY failed" }
-                return null
-            }.onSuccess { result ->
-                return when (val resultCode =
-                    result?.getIntExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR)) {
-                    OpenPgpApi.RESULT_CODE_SUCCESS -> {
-                        runCatching {
-                            val entry = withContext(Dispatchers.IO) {
-                                @Suppress("BlockingMethodInNonBlockingContext")
-                                (PasswordEntry(decryptedOutput))
-                            }
-                            AutofillPreferences.credentialsFromStoreEntry(this, file, entry, directoryStructure)
-                        }.getOrElse { e ->
-                            e(e) { "Failed to parse password entry" }
-                            return null
-                        }
-                    }
-                    OpenPgpApi.RESULT_CODE_USER_INTERACTION_REQUIRED -> {
-                        val pendingIntent: PendingIntent =
-                            result.getParcelableExtra(OpenPgpApi.RESULT_INTENT)!!
-                        runCatching {
-                            val intentToResume = withContext(Dispatchers.Main) {
-                                suspendCoroutine<Intent> { cont ->
-                                    continueAfterUserInteraction = cont
-                                    decryptInteractionRequiredAction.launch(IntentSenderRequest.Builder(pendingIntent.intentSender).build())
-                                }
-                            }
-                            decryptCredential(file, intentToResume)
-                        }.getOrElse { e ->
-                            e(e) { "OpenPgpApi ACTION_DECRYPT_VERIFY failed with user interaction" }
-                            return null
-                        }
+          }
+          .onSuccess { result ->
+            return when (val resultCode = result?.getIntExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR)) {
+              OpenPgpApi.RESULT_CODE_SUCCESS -> {
+                runCatching {
+                  val entry =
+                    withContext(Dispatchers.IO) {
+                      @Suppress("BlockingMethodInNonBlockingContext") (PasswordEntry(decryptedOutput))
                     }
-                    OpenPgpApi.RESULT_CODE_ERROR -> {
-                        val error = result.getParcelableExtra<OpenPgpError>(OpenPgpApi.RESULT_ERROR)
-                        if (error != null) {
-                            withContext(Dispatchers.Main) {
-                                Toast.makeText(
-                                    applicationContext,
-                                    "Error from OpenKeyChain: ${error.message}",
-                                    Toast.LENGTH_LONG
-                                ).show()
-                            }
-                            e { "OpenPgpApi ACTION_DECRYPT_VERIFY failed (${error.errorId}): ${error.message}" }
-                        }
-                        null
-                    }
-                    else -> {
-                        e { "Unrecognized OpenPgpApi result: $resultCode" }
-                        null
+                  AutofillPreferences.credentialsFromStoreEntry(this, file, entry, directoryStructure)
+                }
+                  .getOrElse { e ->
+                    e(e) { "Failed to parse password entry" }
+                    return null
+                  }
+              }
+              OpenPgpApi.RESULT_CODE_USER_INTERACTION_REQUIRED -> {
+                val pendingIntent: PendingIntent = result.getParcelableExtra(OpenPgpApi.RESULT_INTENT)!!
+                runCatching {
+                  val intentToResume =
+                    withContext(Dispatchers.Main) {
+                      suspendCoroutine<Intent> { cont ->
+                        continueAfterUserInteraction = cont
+                        decryptInteractionRequiredAction.launch(
+                          IntentSenderRequest.Builder(pendingIntent.intentSender).build()
+                        )
+                      }
                     }
+                  decryptCredential(file, intentToResume)
+                }
+                  .getOrElse { e ->
+                    e(e) { "OpenPgpApi ACTION_DECRYPT_VERIFY failed with user interaction" }
+                    return null
+                  }
+              }
+              OpenPgpApi.RESULT_CODE_ERROR -> {
+                val error = result.getParcelableExtra<OpenPgpError>(OpenPgpApi.RESULT_ERROR)
+                if (error != null) {
+                  withContext(Dispatchers.Main) {
+                    Toast.makeText(applicationContext, "Error from OpenKeyChain: ${error.message}", Toast.LENGTH_LONG)
+                      .show()
+                  }
+                  e { "OpenPgpApi ACTION_DECRYPT_VERIFY failed (${error.errorId}): ${error.message}" }
                 }
+                null
+              }
+              else -> {
+                e { "Unrecognized OpenPgpApi result: $resultCode" }
+                null
+              }
             }
-        }
-        return null
-    }
+          }
+      }
+    return null
+  }
 }