Downgrade Support for installer, Dhizuku Mode for whole app and performance improvements (#125)

* Bump version to 1.71.3 and enable BuildConfig in suCore

* Update `versionCode` to 1713 and `versionName` to 1.71.3 in `gradle.properties`.
* Enable `buildConfig` in the `suCore` module's `buildFeatures`.
* Remove a commented-out Kotlin Android plugin alias from `suCore/build.gradle.kts`.

* Add Logger utility classes to suCore and app modules

* Add `Logger` object to `suCore` module providing debug-only logging for D, I, W, V, and E levels.
* Add `Logger` object to `app` module with debug-only logging and a `koinLogLevel` configuration for Koin initialization.

* Replace custom logging with specialized Logger utility and refactor shell utilities

* Replace `android.util.Log` calls with project-specific `Logger` utility across the application and `suCore` modules.
* Update `ThorApplication` to use `Logger.koinLogLevel` for Koin initialization.
* Refactor `ShellUtils.isValidOutput` to use Kotlin's `isNullOrEmpty()` extension.
* Simplify GCD calculation in `ShellUtils` using augmented assignment (`-=`).
* Remove redundant file-written check in `InstallerRepositoryImpl` and improve error logging for bundle installation.
* Fix typo in `MainViewModel` documentation ("Logger Dialog" to "Logger DiaLogger").
* Remove unused import in `CallbackList.kt`.

* Optimized imports

* partial code cleanup

* Update `InstallState.ReadyToInstall` with versioning and downgrade support

* Enhance `ReadyToInstall` data class to include `isDowngrade` and `oldVersion` properties.
* Add helper methods to `ReadyToInstall` for generating dynamic UI content:
    * `getVersionInfo()`: Provides version comparison strings.
    * `getActionButtonText()`: Returns appropriate labels for install, update, or downgrade actions.
    * `getWarningMessage()` and `shouldShowWarning()`: Manage downgrade-specific warnings.
    * `getActionWord()`: Provides context-specific verbs for the installation process.

* Allow app downgrades in SystemGateway

* Update `SystemGateway.installApp` to include an optional `canDowngrade` parameter, defaulting to `false`.

* Add support for package downgrades in `ShizukuReflector`

* Update `installPackage` in `ShizukuReflector.kt` to accept an optional `canDowngrade` parameter.
* Include the `-d` flag in the `pm install` command when `canDowngrade` is set to true.

* Add support for app downgrades in system gateways

* Update `RootSystemGateway` to include the `-d` flag in the `pm install` command when `canDowngrade` is true.
* Update `ShizukuSystemGateway` to pass the `canDowngrade` parameter to the package installer.
* Update the `installApp` interface signature to support the new `canDowngrade` boolean flag.

* Add support for package downgrades and extend application metadata

* Update `InstallerRepository` to allow optional package downgrading during installation.
* Add `versionCode` and `permissions` fields to the `AppMetadata` domain model.

* Enhance APK analysis and add support for downgrade installations

*   **App Analysis**: Update `AppAnalyzerImpl` to extract `versionCode` and requested permissions.
*   **Install Logic**: Add a `canDowngrade` parameter to installation methods.
*   **Downgrade Support**: Implement downgrade requests using `HiddenApiBypass` to invoke `setRequestDowngrade` on `SessionParams`.
*   **Root Installation**: Pass the downgrade flag to `RootSystemGateway`.
*   **Compatibility**: Fix `PendingIntent` flag compatibility for Android versions below S (API 31).
*   **Cleanup**: Remove redundant comments and improve code clarity in `AppAnalyzerImpl`.

* Update `PortableInstaller` and `InstallerViewModel` to support app downgrades and enhanced package metadata display.

* **Installer UI**:
    * Display both `versionName` and `versionCode` in the package info header.
    * Add a warning message when an operation is a downgrade or an update.
    * Show the number of requested permissions and associated warnings.
    * Refactor action buttons into a `Row` layout, keeping them aligned with permission info.
    * Generalize "Install/Update" labels using new helper methods from the install state.

* **Installer Logic**:
    * Enhance package analysis to detect downgrades by comparing `versionCode`.
    * Track the previously installed version name for context.
    * Add validation to prevent downgrades using `InstallMode.NORMAL` (restricted to Root or Shizuku).
    * Pass the `canDowngrade` flag to the repository during the installation process.

* Refactor package installation logic and clean up codebase

* Add a conditional check to only show the package warning message in `PortableInstaller` if `shouldShowWarning()` is true.
* Simplify version code retrieval by using `longVersionCode` directly, removing legacy SDK version checks and deprecated `versionCode` usage in `InstallerViewModel` and `AppAnalyzerImpl`.
* Add `@Suppress("unused")` annotations to `getVersionInfo`, `setInstallMode`, and the `ShizukuReflector` file.
* Remove an unused `AppMetadata` import in `InstallerViewModel`.

* Add Dhizuku API dependency

* Add `dhizuku` version 2.5.4 to `gradle/libs.versions.toml`.
* Add `dhizuku-api` library definition to `gradle/libs.versions.toml`.
* Include `libs.dhizuku.api` as an implementation dependency in `app/build.gradle.kts`.

* dhizuku ICON

* Add Dhizuku support for system operations

* Implement `DhizukuHelper` to handle core Dhizuku API interactions, including service binding via `ShizukuBinderWrapper` and shell command execution.
* Add `DhizukuReflector` to provide a high-level interface for force-stopping apps, clearing cache, and managing app enabled/disabled states.
* Implement `DhizukuSystemGateway` to integrate Dhizuku as a `SystemGateway` provider, enabling app installation, uninstallation, and package management.
* Utilize `HiddenApiBypass` for accessing restricted system methods on Android P and above.

* Add Dhizuku support for privileged app operations

* Initialize Dhizuku API in `ThorApplication`.
* Add `DhizukuSystemGateway` and `DhizukuReflector` to support Dhizuku-based system actions.
* Update `SystemRepository` and `SystemGateway` interfaces to include Dhizuku availability checks and integration.
* Implement Dhizuku installation mode in `InstallerRepositoryImpl` using `DhizukuAPI` and binder wrapping.
* Update `InstallerViewModel` to detect Dhizuku availability and allow it as a privileged install mode (supporting downgrades).
* Add Dhizuku UI components, including icons and labels, to the `PortableInstaller` screen.
* Fix a compatibility issue in `InstallerViewModel` when retrieving version codes on devices below Android P.
* Register Dhizuku-related components in the Koin dependency injection `coreModule`.

* Add Dhizuku support for privileged app operations

* Initialize Dhizuku API in `ThorApplication`.
* Add `DhizukuSystemGateway` and `DhizukuReflector` to support Dhizuku-based system actions.
* Update `SystemRepository` and `SystemGateway` interfaces to include Dhizuku availability checks and integration.
* Implement Dhizuku installation mode in `InstallerRepositoryImpl` using `DhizukuAPI` and binder wrapping.
* Update `InstallerViewModel` to detect Dhizuku availability and allow it as a privileged install mode (supporting downgrades).
* Add Dhizuku UI components, including icons and labels, to the `PortableInstaller` screen.
* Fix a compatibility issue in `InstallerViewModel` when retrieving version codes on devices below Android P.
* Register Dhizuku-related components in the Koin dependency injection `coreModule`.

* Update app/src/main/java/com/valhalla/thor/data/source/local/dhizuku/Dhizuku.kt

Author: trinadhthatakula

README.md

@@ -64,7 +64,8 @@
 ## Credits
 
 - Portions of this app use code from [`libsu`](https://github.com/topjohnwu/libsu)
-  by [topjohnwu](https://github.com/topjohnwu/), adapted and integrated as the [`suCore`](https://github.com/trinadhthatakula/Thor/tree/master/suCore) module.
+  by [topjohnwu](https://github.com/topjohnwu/), adapted and integrated as the [
+  `suCore`](https://github.com/trinadhthatakula/Thor/tree/master/suCore) module.
 
 ### Modifications to libsu
 

app/build.gradle.kts

@@ -1,7 +1,7 @@
+import com.android.build.api.artifact.SingleArtifact
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import java.io.FileInputStream
 import java.util.Properties
-import com.android.build.api.artifact.SingleArtifact
 
 plugins {
     alias(libs.plugins.android.application)
@@ -208,6 +208,7 @@ dependencies {
     implementation(libs.lottie.compose)
     implementation(libs.shizuku.api)
     implementation(libs.shizuku.provider)
+    implementation(libs.dhizuku.api)
     implementation(libs.hiddenapibypass)
     implementation(libs.bundles.coil)
     implementation(libs.bundles.koin)

app/src/main/AndroidManifest.xml

@@ -51,17 +51,21 @@
 
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
+
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
+
                 <data android:scheme="content" />
                 <data android:scheme="file" />
                 <data android:mimeType="application/vnd.android.package-archive" />
             </intent-filter>
 
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
+
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
+
                 <data android:scheme="content" />
                 <data android:scheme="file" />
                 <data android:mimeType="application/octet-stream" />
@@ -74,6 +78,7 @@
 
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
+
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
 

app/src/main/java/com/valhalla/thor/HomeActivity.kt

@@ -1,7 +1,6 @@
 package com.valhalla.thor
 
 import android.os.Bundle
-import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
@@ -12,6 +11,7 @@ import com.valhalla.thor.presentation.common.ShizukuPermissionHandler
 import com.valhalla.thor.presentation.home.HomeViewModel
 import com.valhalla.thor.presentation.main.MainScreen
 import com.valhalla.thor.presentation.theme.ThorTheme
+import com.valhalla.thor.util.Logger
 import kotlinx.coroutines.launch
 import org.koin.android.ext.android.inject
 import org.koin.androidx.viewmodel.ext.android.viewModel
@@ -26,15 +26,15 @@ class HomeActivity : ComponentActivity() {
 
     private val shizukuHandler = ShizukuPermissionHandler(
         onPermissionGranted = {
-            Log.d("HomeActivity", "Shizuku Ready")
+            Logger.d("HomeActivity", "Shizuku Ready")
             homeViewModel.loadDashboardData()
         },
         onPermissionDenied = {
-            Log.d("HomeActivity", "Shizuku Denied")
+            Logger.d("HomeActivity", "Shizuku Denied")
             // We stop asking automatically. User must click "Refresh" in dashboard manually now.
         },
         onBinderDead = {
-            Log.w("HomeActivity", "Shizuku Binder Died")
+            Logger.w("HomeActivity", "Shizuku Binder Died")
         }
     )
 

app/src/main/java/com/valhalla/thor/ThorApplication.kt

@@ -7,16 +7,18 @@ import com.valhalla.thor.di.coreModule
 import com.valhalla.thor.di.installerModule
 import com.valhalla.thor.di.preferenceModule
 import com.valhalla.thor.di.presentationModule
+import com.valhalla.thor.util.Logger
 import org.koin.android.ext.koin.androidContext
 import org.koin.android.ext.koin.androidLogger
 import org.koin.androix.startup.KoinStartup
 import org.koin.dsl.koinConfiguration
+import com.rosan.dhizuku.api.Dhizuku
 
 class ThorApplication : Application(), KoinStartup {
 
     override fun onKoinStartup() = koinConfiguration {
         androidContext(this@ThorApplication)
-        androidLogger()
+        androidLogger(Logger.koinLogLevel)
         modules(
             coreModule,
             installerModule,
@@ -29,6 +31,12 @@ class ThorApplication : Application(), KoinStartup {
     override fun onCreate() {
         super.onCreate()
         ThorShellConfig.init()
+        
+        try {
+            Dhizuku.init(this)
+        } catch (e: Exception) {
+            Logger.e("ThorApp", "Dhizuku init failed", e)
+        }
     }
 
-}
+}

app/src/main/java/com/valhalla/thor/data/gateway/DhizukuSystemGateway.kt

@@ -0,0 +1,70 @@
+package com.valhalla.thor.data.gateway
+
+import com.valhalla.thor.domain.gateway.SystemGateway
+import com.valhalla.thor.data.source.local.dhizuku.DhizukuReflector
+import com.valhalla.thor.data.source.local.dhizuku.DhizukuHelper
+
+class DhizukuSystemGateway(
+    private val reflector: DhizukuReflector
+) : SystemGateway {
+
+    override suspend fun isRootAvailable() = false
+
+    override fun isShizukuAvailable(): Boolean = false
+
+    override fun isDhizukuAvailable(): Boolean {
+        return DhizukuHelper.isDhizukuAvailable()
+    }
+
+    override suspend fun forceStopApp(packageName: String): Result<Unit> {
+        return try {
+            reflector.forceStop(packageName)
+            Result.success(Unit)
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+    override suspend fun clearCache(packageName: String): Result<Unit> {
+        return try {
+            reflector.clearCache(packageName)
+            Result.success(Unit)
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+    override suspend fun setAppDisabled(packageName: String, isDisabled: Boolean): Result<Unit> {
+        return try {
+            reflector.setAppEnabled(packageName, !isDisabled)
+            Result.success(Unit)
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+    override suspend fun rebootDevice(reason: String): Result<Unit> {
+        return Result.failure(Exception("Reboot requires Root. Dhizuku cannot perform this action easily."))
+    }
+
+    override suspend fun uninstallApp(packageName: String): Result<Unit> {
+        return if (reflector.uninstallApp(packageName)) {
+            Result.success(Unit)
+        } else {
+            Result.failure(Exception("Uninstall failed"))
+        }
+    }
+
+    override suspend fun installApp(apkPath: String, canDowngrade: Boolean): Result<Unit> {
+        val result = DhizukuHelper.execute("pm install -r -g${if (canDowngrade) " -d" else ""} ${com.valhalla.superuser.ShellUtils.escapedString(apkPath)}")
+        return if (result.first == 0) {
+            Result.success(Unit)
+        } else {
+            Result.failure(Exception("Dhizuku install failed: ${result.second}"))
+        }
+    }
+
+    override suspend fun getAppCacheSize(packageName: String): Long {
+        return 0L
+    }
+}

app/src/main/java/com/valhalla/thor/data/gateway/RootSystemGateway.kt

@@ -20,6 +20,7 @@ class RootSystemGateway(
     }
 
     override fun isShizukuAvailable(): Boolean = false
+    override fun isDhizukuAvailable(): Boolean = false
 
     override suspend fun forceStopApp(packageName: String): Result<Unit> {
         return runCommand("am force-stop $packageName")
@@ -44,9 +45,9 @@ class RootSystemGateway(
         return runCommand("pm uninstall --user 0 $packageName")
     }
 
-    override suspend fun installApp(apkPath: String): Result<Unit> {
-        // Use quotes to prevent path injection/splitting issues
-        return runCommand("pm install -r -g '$apkPath'")
+    override suspend fun installApp(apkPath: String, canDowngrade: Boolean): Result<Unit> {
+        val command = "pm install -r -g${if (canDowngrade) " -d" else ""} ${com.valhalla.superuser.ShellUtils.escapedString(apkPath)}"
+        return runCommand(command)
     }
 
     override suspend fun getAppCacheSize(packageName: String): Long {

app/src/main/java/com/valhalla/thor/data/gateway/ShizukuSystemGateway.kt

@@ -20,6 +20,8 @@ class ShizukuSystemGateway(
         }
     }
 
+    override fun isDhizukuAvailable(): Boolean = false
+
     override suspend fun forceStopApp(packageName: String): Result<Unit> {
         return runReflectiveAction { reflector.forceStop(packageName) }
     }
@@ -37,15 +39,15 @@ class ShizukuSystemGateway(
     }
 
     override suspend fun uninstallApp(packageName: String): Result<Unit> {
-        return if(reflector.uninstallApp(packageName)){
+        return if (reflector.uninstallApp(packageName)) {
             Result.success(Unit)
         } else {
             Result.failure(Exception("Uninstall failed"))
         }
     }
 
-    override suspend fun installApp(apkPath: String): Result<Unit> {
-        return if (reflector.installPackage(apkPath)) {
+    override suspend fun installApp(apkPath: String, canDowngrade: Boolean): Result<Unit> {
+        return if (reflector.installPackage(apkPath, canDowngrade)) {
             Result.success(Unit)
         } else {
             Result.failure(Exception("Shizuku install failed. Ensure the file path is readable by Shell/ADB."))
@@ -72,4 +74,4 @@ class ShizukuSystemGateway(
             Result.failure(e)
         }
     }
-}
+}

app/src/main/java/com/valhalla/thor/data/receivers/InstallReceiver.kt

@@ -6,8 +6,8 @@ import android.content.Intent
 import android.content.pm.PackageInstaller
 import android.os.Build
 import com.valhalla.thor.data.ACTION_INSTALL_STATUS
-import com.valhalla.thor.domain.InstallerEventBus
 import com.valhalla.thor.domain.InstallState
+import com.valhalla.thor.domain.InstallerEventBus
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -33,19 +33,26 @@ class InstallReceiver : BroadcastReceiver(), KoinComponent {
                     PackageInstaller.STATUS_SUCCESS -> {
                         eventBus.emit(InstallState.Success)
                     }
+
                     PackageInstaller.STATUS_PENDING_USER_ACTION -> {
-                        val confirmIntent: Intent? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                            intent.getParcelableExtra<Intent>(Intent.EXTRA_INTENT, Intent::class.java)
-                        } else {
-                            @Suppress("DEPRECATION")
-                            intent.getParcelableExtra<Intent>(Intent.EXTRA_INTENT)
-                        }
+                        val confirmIntent: Intent? =
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                                intent.getParcelableExtra<Intent>(
+                                    Intent.EXTRA_INTENT,
+                                    Intent::class.java
+                                )
+                            } else {
+                                @Suppress("DEPRECATION")
+                                intent.getParcelableExtra<Intent>(Intent.EXTRA_INTENT)
+                            }
                         if (confirmIntent != null) {
                             eventBus.emit(InstallState.UserConfirmationRequired(confirmIntent))
                         }
                     }
+
                     else -> {
-                        val msg = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE) ?: "Unknown Error"
+                        val msg = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE)
+                            ?: "Unknown Error"
                         eventBus.emit(InstallState.Error("Install Failed ($status): $msg"))
                     }
                 }

app/src/main/java/com/valhalla/thor/data/repository/AppAnalyzerImpl.kt

@@ -8,14 +8,14 @@ import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
 import android.net.Uri
 import android.os.Build
+import androidx.core.graphics.createBitmap
 import com.valhalla.thor.domain.model.AppMetadata
 import com.valhalla.thor.domain.repository.AppAnalyzer
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.io.File
 import java.io.FileOutputStream
 import java.util.zip.ZipInputStream
-import androidx.core.graphics.createBitmap
 
 class AppAnalyzerImpl(private val context: Context) : AppAnalyzer {
 
@@ -26,7 +26,6 @@ class AppAnalyzerImpl(private val context: Context) : AppAnalyzer {
             val contentResolver = context.contentResolver
 
             // Phase 1: Try to extract a nested APK (for XAPK/APKS)
-            // We open a fresh stream for the Zip check
             var isNestedBundle = false
 
             try {
@@ -35,8 +34,6 @@ class AppAnalyzerImpl(private val context: Context) : AppAnalyzer {
                         var entry = zipStream.nextEntry
                         while (entry != null) {
                             val name = entry.name
-                            // If we find a nested APK, we extract it and stop.
-                            // We prioritize 'base.apk' but accept any .apk if base isn't found first.
                             if (name.endsWith(".apk", ignoreCase = true)) {
                                 FileOutputStream(tempFile).use { fos ->
                                     zipStream.copyTo(fos)
@@ -49,13 +46,11 @@ class AppAnalyzerImpl(private val context: Context) : AppAnalyzer {
                         }
                     }
                 }
-            } catch (e: Exception) {
-                // Not a zip or read error, proceed to fallback
+            } catch (_: Exception) {
                 isNestedBundle = false
             }
 
             // Phase 2: Fallback (Standard APK)
-            // If we didn't find any nested APKs inside, the file ITSELF is the APK.
             if (!isNestedBundle) {
                 contentResolver.openInputStream(uri)?.use { input ->
                     FileOutputStream(tempFile).use { output ->
@@ -65,12 +60,14 @@ class AppAnalyzerImpl(private val context: Context) : AppAnalyzer {
             }
 
             // Phase 3: Parsing
-            // Now tempFile is either the extracted base.apk OR the copy of the original APK.
             val pm = context.packageManager
-            val flags = PackageManager.GET_META_DATA
+            val flags = PackageManager.GET_META_DATA or PackageManager.GET_PERMISSIONS
 
             val archiveInfo = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                pm.getPackageArchiveInfo(tempFile.absolutePath, PackageManager.PackageInfoFlags.of(flags.toLong()))
+                pm.getPackageArchiveInfo(
+                    tempFile.absolutePath,
+                    PackageManager.PackageInfoFlags.of(flags.toLong())
+                )
             } else {
                 @Suppress("DEPRECATION")
                 pm.getPackageArchiveInfo(tempFile.absolutePath, flags)
@@ -87,21 +84,24 @@ class AppAnalyzerImpl(private val context: Context) : AppAnalyzer {
             val label = archiveInfo.applicationInfo?.loadLabel(pm).toString()
             val drawable = archiveInfo.applicationInfo?.loadIcon(pm)
             val version = archiveInfo.versionName ?: "Unknown"
+            val versionCode = archiveInfo.longVersionCode
             val pkgName = archiveInfo.packageName
+            val permissions = archiveInfo.requestedPermissions?.toList() ?: emptyList()
 
             Result.success(
                 AppMetadata(
                     label = label,
                     packageName = pkgName,
                     version = version,
-                    icon = drawable?.toBitmap()
+                    versionCode = versionCode,
+                    icon = drawable?.toBitmap(),
+                    permissions = permissions
                 )
             )
 
         } catch (e: Exception) {
             Result.failure(e)
         } finally {
-            // Cleanup: Delete the temp file to save space
             if (tempFile.exists()) {
                 tempFile.delete()
             }