feat(details): Implement open, uninstall, and downgrade functionality

composeApp/src/androidMain/AndroidManifest.xml

@@ -1,18 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:tools="http://schemas.android.com/tools"
+    xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.INTERNET" />
-    <!-- Needed to prompt install of APKs from our app -->
-    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
-    <uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
-    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />
-
-    <queries>
-        <package android:name="zed.rainxch.githubstore" />
-        <intent>
-            <action android:name="android.intent.action.MAIN" />
-        </intent>
-    </queries>
+
+    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"
+        tools:ignore="PackageVisibilityPolicy,QueryAllPackagesPermission" />
+
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"
+        tools:ignore="RequestInstallPackagesPolicy" />
+    <uses-permission android:name="android.permission.REQUEST_DELETE_PACKAGES" />
+
     <application
         android:name=".app.GithubStoreApp"
         android:allowBackup="true"
@@ -24,7 +22,6 @@
         android:theme="@android:style/Theme.Material.Light.NoActionBar"
         android:usesCleartextTraffic="false">
 
-        <!-- Expose cache files via FileProvider for APK install -->
         <activity
             android:name=".MainActivity"
             android:exported="true"
@@ -35,7 +32,6 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
 
-            <!-- Auth callback (existing) -->
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 
@@ -47,7 +43,6 @@
                     android:scheme="githubstore" />
             </intent-filter>
 
-            <!-- Custom scheme: githubstore://repo/{owner}/{repo} -->
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 
@@ -72,8 +67,7 @@
                     android:scheme="https" />
             </intent-filter>
 
-            <!-- App website links: https://github-store.org/app/?repo={owner}/{repo} -->
-            <intent-filter>
+            <intent-filter android:autoVerify="true">
                 <action android:name="android.intent.action.VIEW" />
 
                 <category android:name="android.intent.category.DEFAULT" />

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.kt

@@ -50,7 +50,6 @@ class AndroidDownloader(
         val request = DownloadManager.Request(url.toUri()).apply {
             setTitle(safeName)
             setDescription("Downloading asset")
-            setNotificationVisibility(DownloadManager.Request.VISIBILITY_HIDDEN)
 
             setDestinationInExternalFilesDir(context, null, "ghs_downloads/$safeName")
 

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidInstaller.kt

@@ -24,6 +24,7 @@ class AndroidInstaller(
     override fun getApkInfoExtractor(): InstallerInfoExtractor {
         return installerInfoExtractor
     }
+
     override fun detectSystemArchitecture(): SystemArchitecture {
         val arch = Build.SUPPORTED_ABIS.firstOrNull() ?: return SystemArchitecture.UNKNOWN
         return when {
@@ -42,7 +43,10 @@ class AndroidInstaller(
         return isArchitectureCompatible(name, systemArch)
     }
 
-    private fun isArchitectureCompatible(assetName: String, systemArch: SystemArchitecture): Boolean {
+    private fun isArchitectureCompatible(
+        assetName: String,
+        systemArch: SystemArchitecture
+    ): Boolean {
         return AssetArchitectureMatcher.isCompatible(assetName, systemArch)
     }
 
@@ -57,17 +61,37 @@ class AndroidInstaller(
             val name = asset.name.lowercase()
             val archBoost = when (systemArch) {
                 SystemArchitecture.X86_64 -> {
-                    if (AssetArchitectureMatcher.isExactMatch(name, SystemArchitecture.X86_64)) 10000 else 0
+                    if (AssetArchitectureMatcher.isExactMatch(
+                            name,
+                            SystemArchitecture.X86_64
+                        )
+                    ) 10000 else 0
                 }
+
                 SystemArchitecture.AARCH64 -> {
-                    if (AssetArchitectureMatcher.isExactMatch(name, SystemArchitecture.AARCH64)) 10000 else 0
+                    if (AssetArchitectureMatcher.isExactMatch(
+                            name,
+                            SystemArchitecture.AARCH64
+                        )
+                    ) 10000 else 0
                 }
+
                 SystemArchitecture.X86 -> {
-                    if (AssetArchitectureMatcher.isExactMatch(name, SystemArchitecture.X86)) 10000 else 0
+                    if (AssetArchitectureMatcher.isExactMatch(
+                            name,
+                            SystemArchitecture.X86
+                        )
+                    ) 10000 else 0
                 }
+
                 SystemArchitecture.ARM -> {
-                    if (AssetArchitectureMatcher.isExactMatch(name, SystemArchitecture.ARM)) 10000 else 0
+                    if (AssetArchitectureMatcher.isExactMatch(
+                            name,
+                            SystemArchitecture.ARM
+                        )
+                    ) 10000 else 0
                 }
+
                 SystemArchitecture.UNKNOWN -> 0
             }
             archBoost + asset.size
@@ -80,16 +104,14 @@ class AndroidInstaller(
     }
 
     override suspend fun ensurePermissionsOrThrow(extOrMime: String) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val pm = context.packageManager
-            if (!pm.canRequestPackageInstalls()) {
-                val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
-                    data = "package:${context.packageName}".toUri()
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                }
-                context.startActivity(intent)
-                throw IllegalStateException("Please enable 'Install unknown apps' for this app in Settings and try again.")
+        val pm = context.packageManager
+        if (!pm.canRequestPackageInstalls()) {
+            val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
+                data = "package:${context.packageName}".toUri()
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
             }
+            context.startActivity(intent)
+            throw IllegalStateException("Please enable 'Install unknown apps' for this app in Settings and try again.")
         }
     }
 
@@ -158,6 +180,38 @@ class AndroidInstaller(
         }
     }
 
+    override fun uninstall(packageName: String) {
+        Logger.d { "Requesting uninstall for: $packageName" }
+        val intent = Intent(Intent.ACTION_DELETE).apply {
+            data = "package:$packageName".toUri()
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        try {
+            context.startActivity(intent)
+        } catch (e: Exception) {
+            Logger.w { "Failed to start uninstall for $packageName: ${e.message}" }
+        }
+
+    }
+
+    override fun openApp(packageName: String): Boolean {
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
+        return if (launchIntent != null) {
+            try {
+                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                context.startActivity(launchIntent)
+                true
+            } catch (e: ActivityNotFoundException) {
+                Logger.w { "Failed to launch $packageName: ${e.message}" }
+                false
+            }
+
+        } else {
+            Logger.w { "No launch intent found for $packageName" }
+            false
+        }
+    }
+
     override fun openInAppManager(
         filePath: String,
         onOpenInstaller: () -> Unit

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/PackageEventReceiver.kt

@@ -0,0 +1,104 @@
+package zed.rainxch.core.data.services
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import zed.rainxch.core.domain.repository.InstalledAppsRepository
+import zed.rainxch.core.domain.system.PackageMonitor
+
+/**
+ * Listens to system package install/uninstall/replace broadcasts.
+ * When a tracked package is installed or updated, it resolves the pending
+ * install flag and updates version info from the system PackageManager.
+ * When a tracked package is removed, it deletes the record from the database.
+ */
+class PackageEventReceiver(
+    private val installedAppsRepository: InstalledAppsRepository,
+    private val packageMonitor: PackageMonitor
+) : BroadcastReceiver() {
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    override fun onReceive(context: Context?, intent: Intent?) {
+        val packageName = intent?.data?.schemeSpecificPart ?: return
+
+        Logger.d { "PackageEventReceiver: ${intent.action} for $packageName" }
+
+        when (intent.action) {
+            Intent.ACTION_PACKAGE_ADDED,
+            Intent.ACTION_PACKAGE_REPLACED -> {
+                scope.launch { onPackageInstalled(packageName) }
+            }
+
+            Intent.ACTION_PACKAGE_FULLY_REMOVED -> {
+                scope.launch { onPackageRemoved(packageName) }
+            }
+        }
+    }
+
+    private suspend fun onPackageInstalled(packageName: String) {
+        try {
+            val app = installedAppsRepository.getAppByPackage(packageName) ?: return
+
+            if (app.isPendingInstall) {
+                val systemInfo = packageMonitor.getInstalledPackageInfo(packageName)
+                if (systemInfo != null) {
+                    installedAppsRepository.updateApp(
+                        app.copy(
+                            isPendingInstall = false,
+                            isUpdateAvailable = false,
+                            installedVersionName = systemInfo.versionName,
+                            installedVersionCode = systemInfo.versionCode,
+                            latestVersionName = systemInfo.versionName,
+                            latestVersionCode = systemInfo.versionCode
+                        )
+                    )
+                    Logger.i { "Resolved pending install via broadcast: $packageName (v${systemInfo.versionName})" }
+                } else {
+                    installedAppsRepository.updatePendingStatus(packageName, false)
+                    Logger.i { "Resolved pending install via broadcast (no system info): $packageName" }
+                }
+            } else {
+                val systemInfo = packageMonitor.getInstalledPackageInfo(packageName)
+                if (systemInfo != null) {
+                    installedAppsRepository.updateApp(
+                        app.copy(
+                            installedVersionName = systemInfo.versionName,
+                            installedVersionCode = systemInfo.versionCode
+                        )
+                    )
+                    Logger.d { "Updated version info via broadcast: $packageName (v${systemInfo.versionName})" }
+                }
+            }
+        } catch (e: Exception) {
+            Logger.e { "PackageEventReceiver error for $packageName: ${e.message}" }
+        }
+    }
+
+    private suspend fun onPackageRemoved(packageName: String) {
+        try {
+            val app = installedAppsRepository.getAppByPackage(packageName) ?: return
+            installedAppsRepository.deleteInstalledApp(packageName)
+            Logger.i { "Removed uninstalled app via broadcast: $packageName" }
+        } catch (e: Exception) {
+            Logger.e { "PackageEventReceiver remove error for $packageName: ${e.message}" }
+        }
+    }
+
+    companion object {
+        fun createIntentFilter(): IntentFilter {
+            return IntentFilter().apply {
+                addAction(Intent.ACTION_PACKAGE_ADDED)
+                addAction(Intent.ACTION_PACKAGE_REPLACED)
+                addAction(Intent.ACTION_PACKAGE_FULLY_REMOVED)
+                addDataScheme("package")
+            }
+        }
+    }
+}

core/data/src/commonMain/kotlin/zed/rainxch/core/data/local/db/dao/InstalledAppDao.kt

@@ -23,6 +23,9 @@ interface InstalledAppDao {
     @Query("SELECT * FROM installed_apps WHERE repoId = :repoId")
     suspend fun getAppByRepoId(repoId: Long): InstalledAppEntity?
 
+    @Query("SELECT * FROM installed_apps WHERE repoId = :repoId")
+    fun getAppByRepoIdAsFlow(repoId: Long): Flow<InstalledAppEntity?>
+
     @Query("SELECT COUNT(*) FROM installed_apps WHERE isUpdateAvailable = 1")
     fun getUpdateCount(): Flow<Int>
 

core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/InstalledAppsRepositoryImpl.kt

@@ -65,6 +65,9 @@ class InstalledAppsRepositoryImpl(
     override suspend fun getAppByRepoId(repoId: Long): InstalledApp? =
         installedAppsDao.getAppByRepoId(repoId)?.toDomain()
 
+    override fun getAppByRepoIdAsFlow(repoId: Long): Flow<InstalledApp?> =
+        installedAppsDao.getAppByRepoIdAsFlow(repoId).map { it?.toDomain() }
+
     override suspend fun isAppInstalled(repoId: Long): Boolean =
         installedAppsDao.getAppByRepoId(repoId) != null
 

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/DesktopInstaller.kt

@@ -56,6 +56,17 @@ class DesktopInstaller(
 
     }
 
+    override fun uninstall(packageName: String) {
+        // Desktop doesn't have a unified uninstall mechanism
+        Logger.d { "Uninstall not supported on desktop for: $packageName" }
+    }
+
+    override fun openApp(packageName: String): Boolean {
+        // Desktop apps are launched differently per platform
+        Logger.d { "Open app not supported on desktop for: $packageName" }
+        return false
+    }
+
     override fun isAssetInstallable(assetName: String): Boolean {
         val name = assetName.lowercase()
 

core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/repository/InstalledAppsRepository.kt

@@ -9,6 +9,7 @@ interface InstalledAppsRepository {
     fun getUpdateCount(): Flow<Int>
     suspend fun getAppByPackage(packageName: String): InstalledApp?
     suspend fun getAppByRepoId(repoId: Long): InstalledApp?
+    fun getAppByRepoIdAsFlow(repoId: Long): Flow<InstalledApp?>
     suspend fun isAppInstalled(repoId: Long): Boolean
 
     suspend fun saveInstalledApp(app: InstalledApp)

core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/system/Installer.kt

@@ -27,4 +27,8 @@ interface Installer {
     )
 
     fun getApkInfoExtractor(): InstallerInfoExtractor
+
+    fun uninstall(packageName: String)
+
+    fun openApp(packageName: String): Boolean
 }

core/presentation/src/commonMain/composeResources/values/strings.xml

@@ -171,6 +171,16 @@
     <string name="installing">Installing</string>
     <string name="pending_install">Pending install</string>
 
+    <!-- Uninstall / Open -->
+    <string name="uninstall">Uninstall</string>
+    <string name="open_app">Open</string>
+    <string name="downgrade_requires_uninstall">Downgrade requires uninstall</string>
+    <string name="downgrade_warning_message">Installing version %1$s requires uninstalling the current version (%2$s) first. Your app data will be lost.</string>
+    <string name="uninstall_first">Uninstall first</string>
+    <string name="install_version">Install %1$s</string>
+    <string name="failed_to_open_app">Failed to open %1$s</string>
+    <string name="failed_to_uninstall">Failed to uninstall %1$s</string>
+
     <!-- Install helpers -->
     <string name="open_in_obtainium">Open in Obtainium</string>
     <string name="obtainium_description">Manage updates automatically</string>

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsAction.kt

@@ -12,5 +12,6 @@ sealed interface AppsAction {
     data object OnCancelUpdateAll : AppsAction
     data object OnCheckAllForUpdates : AppsAction
     data object OnRefresh : AppsAction
+    data class OnUninstallApp(val app: InstalledApp) : AppsAction
     data class OnNavigateToRepo(val repoId: Long) : AppsAction
 }