Refactor package structure (#1233)

* idea: default test runner to Gradle

* Kick off package structure revamp

* Reparent all classes under dev.msfjarvis.aps

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

1 files changed, 0 insertions, 265 deletions

diff --git a/app/src/main/java/com/zeapo/pwdstore/git/GitServerConfigActivity.kt b/app/src/main/java/com/zeapo/pwdstore/git/GitServerConfigActivity.kt
deleted file mode 100644
index af6540a4..00000000
--- a/app/src/main/java/com/zeapo/pwdstore/git/GitServerConfigActivity.kt
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- * Copyright © 2014-2020 The Android Password Store Authors. All Rights Reserved.
- * SPDX-License-Identifier: GPL-3.0-only
- */
-package com.zeapo.pwdstore.git
-
-import android.content.Context
-import android.content.Intent
-import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
-import android.view.MenuItem
-import android.view.View
-import androidx.core.os.postDelayed
-import androidx.core.view.isVisible
-import androidx.core.widget.doOnTextChanged
-import androidx.lifecycle.lifecycleScope
-import com.github.ajalt.timberkt.e
-import com.github.michaelbull.result.fold
-import com.github.michaelbull.result.onFailure
-import com.github.michaelbull.result.runCatching
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import com.google.android.material.snackbar.Snackbar
-import com.zeapo.pwdstore.R
-import com.zeapo.pwdstore.databinding.ActivityGitCloneBinding
-import com.zeapo.pwdstore.git.config.AuthMode
-import com.zeapo.pwdstore.git.config.GitSettings
-import com.zeapo.pwdstore.git.config.Protocol
-import com.zeapo.pwdstore.ui.dialogs.BasicBottomSheet
-import com.zeapo.pwdstore.utils.PasswordRepository
-import com.zeapo.pwdstore.utils.snackbar
-import com.zeapo.pwdstore.utils.viewBinding
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-
-/**
- * Activity that encompasses both the initial clone as well as editing the server config for future
- * changes.
- */
-class GitServerConfigActivity : BaseGitActivity() {
-
-    private val binding by viewBinding(ActivityGitCloneBinding::inflate)
-
-    private lateinit var newAuthMode: AuthMode
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        val isClone = intent?.extras?.getBoolean("cloning") ?: false
-        if (isClone) {
-            binding.saveButton.text = getString(R.string.clone_button)
-        }
-        setContentView(binding.root)
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-
-        newAuthMode = GitSettings.authMode
-
-        binding.authModeGroup.apply {
-            when (newAuthMode) {
-                AuthMode.SshKey -> check(binding.authModeSshKey.id)
-                AuthMode.Password -> check(binding.authModePassword.id)
-                AuthMode.OpenKeychain -> check(binding.authModeOpenKeychain.id)
-                AuthMode.None -> check(View.NO_ID)
-            }
-            addOnButtonCheckedListener { _, _, _ ->
-                when (checkedButtonId) {
-                    binding.authModeSshKey.id -> newAuthMode = AuthMode.SshKey
-                    binding.authModeOpenKeychain.id -> newAuthMode = AuthMode.OpenKeychain
-                    binding.authModePassword.id -> newAuthMode = AuthMode.Password
-                    View.NO_ID -> newAuthMode = AuthMode.None
-                }
-            }
-        }
-
-        binding.serverUrl.setText(GitSettings.url.also {
-            if (it.isNullOrEmpty()) return@also
-            setAuthModes(it.startsWith("http://") || it.startsWith("https://"))
-        })
-        binding.serverBranch.setText(GitSettings.branch)
-
-        binding.serverUrl.doOnTextChanged { text, _, _, _ ->
-            if (text.isNullOrEmpty()) return@doOnTextChanged
-            setAuthModes(text.startsWith("http://") || text.startsWith("https://"))
-        }
-
-        binding.saveButton.setOnClickListener {
-            val newUrl = binding.serverUrl.text.toString().trim()
-            // If url is of type john_doe@example.org:12435/path/to/repo, then not adding `ssh://`
-            // in the beginning will cause the port to be seen as part of the path. Let users know
-            // about it and offer a quickfix.
-            if (newUrl.contains(PORT_REGEX)) {
-                if (newUrl.startsWith("https://")) {
-                    BasicBottomSheet.Builder(this)
-                        .setTitleRes(R.string.https_scheme_with_port_title)
-                        .setMessageRes(R.string.https_scheme_with_port_message)
-                        .setPositiveButtonClickListener {
-                            binding.serverUrl.setText(newUrl.replace(PORT_REGEX, "/"))
-                        }
-                        .build()
-                        .show(supportFragmentManager, "SSH_SCHEME_WARNING")
-                    return@setOnClickListener
-                } else if (!newUrl.startsWith("ssh://")) {
-                    BasicBottomSheet.Builder(this)
-                        .setTitleRes(R.string.ssh_scheme_needed_title)
-                        .setMessageRes(R.string.ssh_scheme_needed_message)
-                        .setPositiveButtonClickListener {
-                            @Suppress("SetTextI18n")
-                            binding.serverUrl.setText("ssh://$newUrl")
-                        }
-                        .build()
-                        .show(supportFragmentManager, "SSH_SCHEME_WARNING")
-                    return@setOnClickListener
-                }
-            }
-            when (val updateResult = GitSettings.updateConnectionSettingsIfValid(
-                newAuthMode = newAuthMode,
-                newUrl = binding.serverUrl.text.toString().trim(),
-                newBranch = binding.serverBranch.text.toString().trim())) {
-                GitSettings.UpdateConnectionSettingsResult.FailedToParseUrl -> {
-                    Snackbar.make(binding.root, getString(R.string.git_server_config_save_error), Snackbar.LENGTH_LONG).show()
-                }
-
-                is GitSettings.UpdateConnectionSettingsResult.MissingUsername -> {
-                    when (updateResult.newProtocol) {
-                        Protocol.Https ->
-                            BasicBottomSheet.Builder(this)
-                                .setTitleRes(R.string.ssh_scheme_needed_title)
-                                .setMessageRes(R.string.git_server_config_save_missing_username_https)
-                                .setPositiveButtonClickListener {
-                                }
-                                .build()
-                                .show(supportFragmentManager, "HTTPS_MISSING_USERNAME")
-                        Protocol.Ssh ->
-                            BasicBottomSheet.Builder(this)
-                                .setTitleRes(R.string.ssh_scheme_needed_title)
-                                .setMessageRes(R.string.git_server_config_save_missing_username_ssh)
-                                .setPositiveButtonClickListener {
-                                }
-                                .build()
-                                .show(supportFragmentManager, "SSH_MISSING_USERNAME")
-                    }
-                }
-                GitSettings.UpdateConnectionSettingsResult.Valid -> {
-                    if (isClone && PasswordRepository.getRepository(null) == null)
-                        PasswordRepository.initialize()
-                    if (!isClone) {
-                        Snackbar.make(binding.root, getString(R.string.git_server_config_save_success), Snackbar.LENGTH_SHORT).show()
-                        Handler(Looper.getMainLooper()).postDelayed(500) { finish() }
-                    } else {
-                        cloneRepository()
-                    }
-                }
-                is GitSettings.UpdateConnectionSettingsResult.AuthModeMismatch -> {
-                    val message = getString(
-                        R.string.git_server_config_save_auth_mode_mismatch,
-                        updateResult.newProtocol,
-                        updateResult.validModes.joinToString(", "),
-                    )
-                    Snackbar.make(binding.root, message, Snackbar.LENGTH_LONG).show()
-                }
-            }
-        }
-    }
-
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        return when (item.itemId) {
-            android.R.id.home -> {
-                finish()
-                true
-            }
-            else -> super.onOptionsItemSelected(item)
-        }
-    }
-
-    private fun setAuthModes(isHttps: Boolean) = with(binding) {
-        if (isHttps) {
-            authModeSshKey.isVisible = false
-            authModeOpenKeychain.isVisible = false
-            authModePassword.isVisible = true
-            if (authModeGroup.checkedButtonId != authModePassword.id)
-                authModeGroup.check(View.NO_ID)
-        } else {
-            authModeSshKey.isVisible = true
-            authModeOpenKeychain.isVisible = true
-            authModePassword.isVisible = true
-            if (authModeGroup.checkedButtonId == View.NO_ID)
-                authModeGroup.check(authModeSshKey.id)
-        }
-    }
-
-    /**
-     * Clones the repository, the directory exists, deletes it
-     */
-    private fun cloneRepository() {
-        val localDir = requireNotNull(PasswordRepository.getRepositoryDirectory())
-        val localDirFiles = localDir.listFiles() ?: emptyArray()
-        // Warn if non-empty folder unless it's a just-initialized store that has just a .git folder
-        if (localDir.exists() && localDirFiles.isNotEmpty() &&
-            !(localDirFiles.size == 1 && localDirFiles[0].name == ".git")) {
-            MaterialAlertDialogBuilder(this)
-                .setTitle(R.string.dialog_delete_title)
-                .setMessage(resources.getString(R.string.dialog_delete_msg, localDir.toString()))
-                .setCancelable(false)
-                .setPositiveButton(R.string.dialog_delete) { dialog, _ ->
-                    runCatching {
-                        lifecycleScope.launch {
-                            val snackbar = snackbar(message = getString(R.string.delete_directory_progress_text), length = Snackbar.LENGTH_INDEFINITE)
-                            withContext(Dispatchers.IO) {
-                                localDir.deleteRecursively()
-                            }
-                            snackbar.dismiss()
-                            launchGitOperation(GitOp.CLONE).fold(
-                                success = {
-                                    setResult(RESULT_OK)
-                                    finish()
-                                },
-                                failure = { err ->
-                                    promptOnErrorHandler(err) {
-                                        finish()
-                                    }
-                                }
-                            )
-                        }
-                    }.onFailure { e ->
-                        e.printStackTrace()
-                        MaterialAlertDialogBuilder(this).setMessage(e.message).show()
-                    }
-                    dialog.cancel()
-                }
-                .setNegativeButton(R.string.dialog_do_not_delete) { dialog, _ ->
-                    dialog.cancel()
-                }
-                .show()
-        } else {
-            runCatching {
-                // Silently delete & replace the lone .git folder if it exists
-                if (localDir.exists() && localDirFiles.size == 1 && localDirFiles[0].name == ".git") {
-                    localDir.deleteRecursively()
-                }
-            }.onFailure { e ->
-                e(e)
-                MaterialAlertDialogBuilder(this).setMessage(e.message).show()
-            }
-            lifecycleScope.launch {
-                launchGitOperation(GitOp.CLONE).fold(
-                    success = {
-                        setResult(RESULT_OK)
-                        finish()
-                    },
-                    failure = { promptOnErrorHandler(it) },
-                )
-            }
-        }
-    }
-
-    companion object {
-        private val PORT_REGEX = ":[0-9]{1,5}/".toRegex()
-
-        fun createCloneIntent(context: Context): Intent {
-            return Intent(context, GitServerConfigActivity::class.java).apply {
-                putExtra("cloning", true)
-            }
-        }
-    }
-}