app: refactor GitSettings and ProxyUtils and inject them using hilt

Signed-off-by: Aditya Wasan <adityawasan55@gmail.com>

5 files changed, 73 insertions, 54 deletions

diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/GitCommandExecutor.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/GitCommandExecutor.kt
index 7be06385..5d507dc8 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/GitCommandExecutor.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/GitCommandExecutor.kt
@@ -10,6 +10,10 @@ import androidx.fragment.app.FragmentActivity
 import com.github.michaelbull.result.Result
 import com.github.michaelbull.result.runCatching
 import com.google.android.material.snackbar.Snackbar
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
 import dev.msfjarvis.aps.R
 import dev.msfjarvis.aps.util.extensions.snackbar
 import dev.msfjarvis.aps.util.git.GitException.PullException
@@ -30,6 +34,9 @@ class GitCommandExecutor(
   private val operation: GitOperation,
 ) {
 
+  private val hiltEntryPoint = EntryPointAccessors.fromApplication(activity.applicationContext, GitCommandExecutorEntryPoint::class.java)
+  private val gitSettings = hiltEntryPoint.gitSettings()
+
   suspend fun execute(): Result<Unit, Throwable> {
     val snackbar =
       activity.snackbar(
@@ -49,8 +56,8 @@ class GitCommandExecutor(
             // the previous status will eventually be used to avoid a commit
             if (nbChanges > 0) {
               withContext(Dispatchers.IO) {
-                val name = GitSettings.authorName.ifEmpty { "root" }
-                val email = GitSettings.authorEmail.ifEmpty { "localhost" }
+                val name = gitSettings.authorName.ifEmpty { "root" }
+                val email = gitSettings.authorEmail.ifEmpty { "localhost" }
                 val identity = PersonIdent(name, email)
                 command.setAuthor(identity).setCommitter(identity).call()
               }
@@ -111,4 +118,10 @@ class GitCommandExecutor(
     }
       .also { snackbar.dismiss() }
   }
+
+  @EntryPoint
+  @InstallIn(SingletonComponent::class)
+  interface GitCommandExecutorEntryPoint {
+    fun gitSettings(): GitSettings
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt
index dbea37e8..5a9da290 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt
@@ -14,6 +14,11 @@ import com.github.michaelbull.result.Result
 import com.github.michaelbull.result.onFailure
 import com.github.michaelbull.result.runCatching
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
 import dev.msfjarvis.aps.R
 import dev.msfjarvis.aps.data.repo.PasswordRepository
 import dev.msfjarvis.aps.ui.sshkeygen.SshKeyGenActivity
@@ -26,6 +31,8 @@ import dev.msfjarvis.aps.util.git.sshj.SshKey
 import dev.msfjarvis.aps.util.git.sshj.SshjSessionFactory
 import dev.msfjarvis.aps.util.settings.AuthMode
 import dev.msfjarvis.aps.util.settings.GitSettings
+import javax.inject.Inject
+import javax.inject.Singleton
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.Dispatchers
@@ -53,10 +60,11 @@ abstract class GitOperation(protected val callingActivity: FragmentActivity) {
   abstract val commands: Array<GitCommand<out Any>>
   private val hostKeyFile = callingActivity.filesDir.resolve(".host_key")
   private var sshSessionFactory: SshjSessionFactory? = null
+  private val hiltEntryPoint = EntryPointAccessors.fromApplication(callingActivity.applicationContext, GitOperationEntryPoint::class.java)
 
   protected val repository = PasswordRepository.getRepository(null)!!
   protected val git = Git(repository)
-  protected val remoteBranch = GitSettings.branch
+  protected val remoteBranch = hiltEntryPoint.gitSettings().branch
   private val authActivity
     get() = callingActivity as ContinuationContainerActivity
 
@@ -220,4 +228,11 @@ abstract class GitOperation(protected val callingActivity: FragmentActivity) {
     /** Timeout in seconds before [TransportCommand] will abort a stalled IO operation. */
     private const val CONNECT_TIMEOUT = 10
   }
+
+  // Using @EntryPoint seems to be our best option here, changing this to constructor injection would require a larger refactor.
+  @EntryPoint
+  @InstallIn(SingletonComponent::class)
+  interface GitOperationEntryPoint {
+    fun gitSettings(): GitSettings
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/proxy/ProxyUtils.kt b/app/src/main/java/dev/msfjarvis/aps/util/proxy/ProxyUtils.kt
index e6eb7e43..d21ee24d 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/proxy/ProxyUtils.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/proxy/ProxyUtils.kt
@@ -14,20 +14,20 @@ import java.net.Proxy
 import java.net.ProxySelector
 import java.net.SocketAddress
 import java.net.URI
+import javax.inject.Inject
+import javax.inject.Singleton
 
 /** Utility class for [Proxy] handling. */
-object ProxyUtils {
-
-  private const val HTTP_PROXY_USER_PROPERTY = "http.proxyUser"
-  private const val HTTP_PROXY_PASSWORD_PROPERTY = "http.proxyPassword"
+@Singleton
+class ProxyUtils @Inject constructor(private val gitSettings: GitSettings) {
 
   /** Set the default [Proxy] and [Authenticator] for the app based on user provided settings. */
   fun setDefaultProxy() {
     ProxySelector.setDefault(
       object : ProxySelector() {
         override fun select(uri: URI?): MutableList<Proxy> {
-          val host = GitSettings.proxyHost
-          val port = GitSettings.proxyPort
+          val host = gitSettings.proxyHost
+          val port = gitSettings.proxyPort
           return if (host == null || port == -1) {
             mutableListOf(Proxy.NO_PROXY)
           } else {
@@ -42,8 +42,8 @@ object ProxyUtils {
         }
       }
     )
-    val user = GitSettings.proxyUsername ?: ""
-    val password = GitSettings.proxyPassword ?: ""
+    val user = gitSettings.proxyUsername ?: ""
+    val password = gitSettings.proxyPassword ?: ""
     if (user.isEmpty() || password.isEmpty()) {
       System.clearProperty(HTTP_PROXY_USER_PROPERTY)
       System.clearProperty(HTTP_PROXY_PASSWORD_PROPERTY)
@@ -63,4 +63,9 @@ object ProxyUtils {
       }
     )
   }
+
+  companion object {
+    private const val HTTP_PROXY_USER_PROPERTY = "http.proxyUser"
+    private const val HTTP_PROXY_PASSWORD_PROPERTY = "http.proxyPassword"
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt b/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt
index d3c85fa7..0d580142 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt
@@ -4,16 +4,19 @@
  */
 package dev.msfjarvis.aps.util.settings
 
+import android.content.SharedPreferences
 import androidx.core.content.edit
 import com.github.michaelbull.result.getOrElse
 import com.github.michaelbull.result.runCatching
-import dev.msfjarvis.aps.Application
 import dev.msfjarvis.aps.data.repo.PasswordRepository
-import dev.msfjarvis.aps.util.extensions.getEncryptedGitPrefs
-import dev.msfjarvis.aps.util.extensions.getEncryptedProxyPrefs
+import dev.msfjarvis.aps.injection.context.FilesDirPath
+import dev.msfjarvis.aps.injection.prefs.GitPreferences
+import dev.msfjarvis.aps.injection.prefs.ProxyPreferences
+import dev.msfjarvis.aps.injection.prefs.SettingsPreferences
 import dev.msfjarvis.aps.util.extensions.getString
-import dev.msfjarvis.aps.util.extensions.sharedPrefs
 import java.io.File
+import javax.inject.Inject
+import javax.inject.Singleton
 import org.eclipse.jgit.transport.URIish
 
 enum class Protocol(val pref: String) {
@@ -48,29 +51,22 @@ enum class AuthMode(val pref: String) {
   }
 }
 
-object GitSettings {
+@Singleton
+class GitSettings @Inject constructor(
+  @SettingsPreferences private val settings: SharedPreferences,
+  @GitPreferences private val encryptedSettings: SharedPreferences,
+  @ProxyPreferences private val proxySettings: SharedPreferences,
+  @FilesDirPath private val filesDirPath: String,
+) {
 
-  private const val DEFAULT_BRANCH = "master"
-
-  private val settings by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    Application.instance.sharedPrefs
-  }
-  private val encryptedSettings by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    Application.instance.getEncryptedGitPrefs()
-  }
-  private val proxySettings by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    Application.instance.getEncryptedProxyPrefs()
-  }
   private val hostKeyPath by lazy(LazyThreadSafetyMode.NONE) {
-    "${Application.instance.filesDir}/.host_key"
+    "$filesDirPath/.host_key"
   }
-
   var authMode
     get() = AuthMode.fromString(settings.getString(PreferenceKeys.GIT_REMOTE_AUTH))
     private set(value) {
       settings.edit { putString(PreferenceKeys.GIT_REMOTE_AUTH, value.pref) }
     }
-
   var url
     get() = settings.getString(PreferenceKeys.GIT_REMOTE_URL)
     private set(value) {
@@ -84,55 +80,46 @@ object GitSettings {
       encryptedSettings.edit { remove(PreferenceKeys.HTTPS_PASSWORD) }
       clearSavedHostKey()
     }
-
   var authorName
     get() = settings.getString(PreferenceKeys.GIT_CONFIG_AUTHOR_NAME) ?: ""
     set(value) {
       settings.edit { putString(PreferenceKeys.GIT_CONFIG_AUTHOR_NAME, value) }
     }
-
   var authorEmail
     get() = settings.getString(PreferenceKeys.GIT_CONFIG_AUTHOR_EMAIL) ?: ""
     set(value) {
       settings.edit { putString(PreferenceKeys.GIT_CONFIG_AUTHOR_EMAIL, value) }
     }
-
   var branch
     get() = settings.getString(PreferenceKeys.GIT_BRANCH_NAME) ?: DEFAULT_BRANCH
     private set(value) {
       settings.edit { putString(PreferenceKeys.GIT_BRANCH_NAME, value) }
     }
-
   var useMultiplexing
     get() = settings.getBoolean(PreferenceKeys.GIT_REMOTE_USE_MULTIPLEXING, true)
     set(value) {
       settings.edit { putBoolean(PreferenceKeys.GIT_REMOTE_USE_MULTIPLEXING, value) }
     }
-
   var proxyHost
     get() = proxySettings.getString(PreferenceKeys.PROXY_HOST)
     set(value) {
       proxySettings.edit { putString(PreferenceKeys.PROXY_HOST, value) }
     }
-
   var proxyPort
     get() = proxySettings.getInt(PreferenceKeys.PROXY_PORT, -1)
     set(value) {
       proxySettings.edit { putInt(PreferenceKeys.PROXY_PORT, value) }
     }
-
   var proxyUsername
     get() = settings.getString(PreferenceKeys.PROXY_USERNAME)
     set(value) {
       proxySettings.edit { putString(PreferenceKeys.PROXY_USERNAME, value) }
     }
-
   var proxyPassword
     get() = proxySettings.getString(PreferenceKeys.PROXY_PASSWORD)
     set(value) {
       proxySettings.edit { putString(PreferenceKeys.PROXY_PASSWORD, value) }
     }
-
   var rebaseOnPull
     get() = settings.getBoolean(PreferenceKeys.REBASE_ON_PULL, true)
     set(value) {
@@ -141,8 +128,7 @@ object GitSettings {
 
   sealed class UpdateConnectionSettingsResult {
     class MissingUsername(val newProtocol: Protocol) : UpdateConnectionSettingsResult()
-    class AuthModeMismatch(val newProtocol: Protocol, val validModes: List<AuthMode>) :
-      UpdateConnectionSettingsResult()
+    class AuthModeMismatch(val newProtocol: Protocol, val validModes: List<AuthMode>) : UpdateConnectionSettingsResult()
     object Valid : UpdateConnectionSettingsResult()
     object FailedToParseUrl : UpdateConnectionSettingsResult()
   }
@@ -164,7 +150,6 @@ object GitSettings {
       }
     if (newAuthMode != AuthMode.None && parsedUrl.user.isNullOrBlank())
       return UpdateConnectionSettingsResult.MissingUsername(newProtocol)
-
     val validHttpsAuth = listOf(AuthMode.None, AuthMode.Password)
     val validSshAuth = listOf(AuthMode.OpenKeychain, AuthMode.Password, AuthMode.SshKey)
     when {
@@ -189,4 +174,8 @@ object GitSettings {
 
   /** Returns true if a host key was previously saved */
   fun hasSavedHostKey(): Boolean = File(hostKeyPath).exists()
+
+  companion object {
+    private const val DEFAULT_BRANCH = "master"
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/settings/Migrations.kt b/app/src/main/java/dev/msfjarvis/aps/util/settings/Migrations.kt
index b9333617..b24914d0 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/settings/Migrations.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/settings/Migrations.kt
@@ -6,7 +6,6 @@
 
 package dev.msfjarvis.aps.util.settings
 
-import android.content.Context
 import android.content.SharedPreferences
 import androidx.core.content.edit
 import com.github.ajalt.timberkt.e
@@ -14,20 +13,18 @@ import com.github.ajalt.timberkt.i
 import com.github.michaelbull.result.get
 import com.github.michaelbull.result.runCatching
 import dev.msfjarvis.aps.util.extensions.getString
-import dev.msfjarvis.aps.util.extensions.sharedPrefs
 import dev.msfjarvis.aps.util.git.sshj.SshKey
 import java.io.File
 import java.net.URI
 
-fun runMigrations(context: Context) {
-  val sharedPrefs = context.sharedPrefs
-  migrateToGitUrlBasedConfig(sharedPrefs)
+fun runMigrations(filesDirPath: String, sharedPrefs: SharedPreferences, gitSettings: GitSettings) {
+  migrateToGitUrlBasedConfig(sharedPrefs, gitSettings)
   migrateToHideAll(sharedPrefs)
-  migrateToSshKey(context, sharedPrefs)
+  migrateToSshKey(filesDirPath, sharedPrefs)
   migrateToClipboardHistory(sharedPrefs)
 }
 
-private fun migrateToGitUrlBasedConfig(sharedPrefs: SharedPreferences) {
+private fun migrateToGitUrlBasedConfig(sharedPrefs: SharedPreferences, gitSettings: GitSettings) {
   val serverHostname = sharedPrefs.getString(PreferenceKeys.GIT_REMOTE_SERVER) ?: return
   i { "Migrating to URL-based Git config" }
   val serverPort = sharedPrefs.getString(PreferenceKeys.GIT_REMOTE_PORT) ?: ""
@@ -76,10 +73,10 @@ private fun migrateToGitUrlBasedConfig(sharedPrefs: SharedPreferences) {
     remove(PreferenceKeys.GIT_REMOTE_PROTOCOL)
   }
   if (url == null ||
-      GitSettings.updateConnectionSettingsIfValid(
-        newAuthMode = GitSettings.authMode,
+      gitSettings.updateConnectionSettingsIfValid(
+        newAuthMode = gitSettings.authMode,
         newUrl = url,
-        newBranch = GitSettings.branch
+        newBranch = gitSettings.branch
       ) != GitSettings.UpdateConnectionSettingsResult.Valid
   ) {
     e { "Failed to migrate to URL-based Git config, generated URL is invalid" }
@@ -95,8 +92,8 @@ private fun migrateToHideAll(sharedPrefs: SharedPreferences) {
   }
 }
 
-private fun migrateToSshKey(context: Context, sharedPrefs: SharedPreferences) {
-  val privateKeyFile = File(context.filesDir, ".ssh_key")
+private fun migrateToSshKey(filesDirPath: String, sharedPrefs: SharedPreferences) {
+  val privateKeyFile = File(filesDirPath, ".ssh_key")
   if (sharedPrefs.contains(PreferenceKeys.USE_GENERATED_KEY) &&
       !SshKey.exists &&
       privateKeyFile.exists()