refactor(architecture): move business logic from frontend to backend

BREAKING: Activity filtering and launch behavior now handled by backend

## Backend Changes
- Add ActivityInfo fields: canLaunchWithoutRoot, hasLauncherIntent
- Add AppActivityFilter model for server-side filtering
- Implement isHiddenActivity() to filter test/debug/internal activities
- Update scanAppActivities() to accept filter parameters
- Implement mode-aware launchActivity() (Intent vs shell am start)

## Frontend Changes
- Remove all filtering logic from ActivityLauncher component
- Delegate filtering to backend via bridge.getActivities(filter)
- Add warning badges for non-exported activities in NONE mode
- Update TypeScript types to match new backend models

## Benefits
- Reduced JSON payload (filtered at source)
- No heavy frontend computations
- Better separation of concerns (backend = logic, frontend = presentation)
- Mode-aware launch behavior (NONE vs ROOT/SHIZUKU)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: risunCode

app/src/main/java/com/appcontrolx/bridge/NativeBridge.kt

@@ -15,6 +15,7 @@ import com.appcontrolx.domain.AppScanner
 import com.appcontrolx.domain.SafetyValidator
 import com.appcontrolx.domain.SystemMonitor
 import com.appcontrolx.model.AppAction
+import com.appcontrolx.model.AppActivityFilter
 import com.appcontrolx.model.BatchComplete
 import com.appcontrolx.model.BatchProgress
 import com.appcontrolx.model.RealtimeStatus
@@ -75,9 +76,11 @@ class NativeBridge @Inject constructor(
     }
 
     @JavascriptInterface
-    fun getAppList(@Suppress("UNUSED_PARAMETER") filterJson: String): String {
+    fun getAppList(filterJson: String): String {
         return runBlocking {
-            val apps = appScanner.scanAllApps(includeIcons = false) // Fast load without icons
+            // TODO: Implement AppFilter parsing and filtering in AppScanner
+            // For now, just return all apps
+            val apps = appScanner.scanAllApps(includeIcons = false)
             json.encodeToString(apps)
         }
     }
@@ -259,15 +262,38 @@ class NativeBridge @Inject constructor(
     }
 
     @JavascriptInterface
-    fun getActivities(): String {
+    fun getActivities(filterJson: String): String {
         return runBlocking {
-            val activities = appScanner.scanAppActivities()
+            val filter = try {
+                json.decodeFromString<AppActivityFilter>(filterJson)
+            } catch (e: Exception) {
+                AppActivityFilter()
+            }
+
+            val activities = appScanner.scanAppActivities(filter)
             json.encodeToString(activities)
         }
     }
 
     @JavascriptInterface
     fun launchActivity(packageName: String, activityName: String): Boolean {
+        val mode = shellManager.getMode()
+
+        return try {
+            if (mode == com.appcontrolx.model.ExecutionMode.NONE) {
+                // Standard Intent launch (only works if exported)
+                launchViaIntent(packageName, activityName)
+            } else {
+                // Shell launch (can launch non-exported activities)
+                val result = shellManager.execute("am start -n $packageName/$activityName")
+                result.isSuccess
+            }
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private fun launchViaIntent(packageName: String, activityName: String): Boolean {
         return try {
             val intent = Intent().apply {
                 component = ComponentName(packageName, activityName)
@@ -310,6 +336,28 @@ class NativeBridge @Inject constructor(
         }
     }
 
+    @JavascriptInterface
+    fun clearCache(packageName: String): String {
+        return runBlocking {
+            val result = appManager.executeAction(packageName, AppAction.CLEAR_CACHE)
+            if (result.success) {
+                appScanner.invalidateCache()
+            }
+            json.encodeToString(result)
+        }
+    }
+
+    @JavascriptInterface
+    fun clearData(packageName: String): String {
+        return runBlocking {
+            val result = appManager.executeAction(packageName, AppAction.CLEAR_DATA)
+            if (result.success) {
+                appScanner.invalidateCache()
+            }
+            json.encodeToString(result)
+        }
+    }
+
     private fun sendCallback(callbackId: String, data: String) {
         val escapedData = data.replace("'", "\\'")
         mainHandler.post {

app/src/main/java/com/appcontrolx/domain/AppScanner.kt

@@ -11,6 +11,7 @@ import android.os.Build
 import android.util.Base64
 import com.appcontrolx.core.ShellManager
 import com.appcontrolx.model.AppActivities
+import com.appcontrolx.model.AppActivityFilter
 import com.appcontrolx.model.AppInfo
 import com.appcontrolx.model.ExecutionMode
 import kotlinx.coroutines.Dispatchers
@@ -61,7 +62,11 @@ class AppScanner @Inject constructor(
                     isBackgroundRestricted = false,
                     size = getAppSize(appInfo),
                     uid = appInfo.uid,
-                    safetyLevel = safetyValidator.getSafetyLevel(pkg.packageName)
+                    safetyLevel = safetyValidator.getSafetyLevel(pkg.packageName),
+                    installPath = appInfo.sourceDir,
+                    targetSdk = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) appInfo.targetSdkVersion else null,
+                    minSdk = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) appInfo.minSdkVersion else null,
+                    permissions = pkg.requestedPermissions?.size
                 )
             } catch (e: Exception) {
                 null
@@ -82,29 +87,78 @@ class AppScanner @Inject constructor(
         }
     }
 
-    suspend fun scanAppActivities(): List<AppActivities> = withContext(Dispatchers.IO) {
+    suspend fun scanAppActivities(filter: AppActivityFilter = AppActivityFilter()): List<AppActivities> = withContext(Dispatchers.IO) {
         val packages = packageManager.getInstalledPackages(PackageManager.GET_ACTIVITIES)
         packages.mapNotNull { pkg ->
             try {
-                val activities = pkg.activities?.map { it.name } ?: return@mapNotNull null
-                if (activities.isEmpty()) return@mapNotNull null
-
+                // Filter by app type first
                 val appInfo = pkg.applicationInfo
                 val isSystemApp = (appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0
 
+                when (filter.type) {
+                    "user" -> if (isSystemApp) return@mapNotNull null
+                    "system" -> if (!isSystemApp) return@mapNotNull null
+                    else -> {} // "all" - include everything
+                }
+
+                // Filter by search query (app name or package name)
+                if (filter.search.isNotEmpty()) {
+                    val appName = appInfo.loadLabel(packageManager).toString()
+                    val searchLower = filter.search.lowercase()
+                    val matchesApp = appName.lowercase().contains(searchLower) ||
+                                    pkg.packageName.lowercase().contains(searchLower)
+
+                    if (!matchesApp) {
+                        // Check if any activity matches
+                        val matchesActivity = pkg.activities?.any { activityInfo ->
+                            activityInfo.name.lowercase().contains(searchLower)
+                        } ?: false
+
+                        if (!matchesActivity) return@mapNotNull null
+                    }
+                }
+
+                val activities = pkg.activities?.mapNotNull { activityInfo ->
+                    try {
+                        // Filter hidden/test activities
+                        if (isHiddenActivity(activityInfo.name)) return@mapNotNull null
+
+                        com.appcontrolx.model.ActivityInfo(
+                            activityName = activityInfo.name,
+                            isExported = activityInfo.exported,
+                            canLaunchWithoutRoot = activityInfo.exported,
+                            hasLauncherIntent = activityInfo.labelRes != 0
+                        )
+                    } catch (e: Exception) {
+                        null
+                    }
+                } ?: return@mapNotNull null
+
+                if (activities.isEmpty()) return@mapNotNull null
+
                 AppActivities(
                     packageName = pkg.packageName,
                     appName = appInfo.loadLabel(packageManager).toString(),
                     iconBase64 = getIconBase64(appInfo),
                     isSystem = isSystemApp,
-                    activities = activities.sorted()
+                    activities = activities.sortedBy { it.activityName }
                 )
             } catch (e: Exception) {
                 null
             }
         }.sortedBy { it.appName.lowercase() }
     }
 
+    private fun isHiddenActivity(name: String): Boolean {
+        val lowerName = name.lowercase()
+        return lowerName.contains("test") ||
+               lowerName.contains("debug") ||
+               lowerName.contains("internal") ||
+               lowerName.endsWith("receiver") ||
+               lowerName.endsWith("service") ||
+               lowerName.endsWith("provider")
+    }
+
     fun invalidateCache() {
         cachedApps = null
         cacheTimestamp = 0

app/src/main/java/com/appcontrolx/model/AppModels.kt

@@ -45,7 +45,15 @@ data class AppActivities(
     val appName: String,
     val iconBase64: String?,
     val isSystem: Boolean,
-    val activities: List<String>
+    val activities: List<ActivityInfo>
+)
+
+@Serializable
+data class ActivityInfo(
+    val activityName: String,
+    val isExported: Boolean,
+    val canLaunchWithoutRoot: Boolean, // true if exported
+    val hasLauncherIntent: Boolean // true if has label resource
 )
 
 @Serializable
@@ -61,7 +69,11 @@ data class AppInfo(
     val isBackgroundRestricted: Boolean,
     val size: Long,
     val uid: Int,
-    val safetyLevel: SafetyLevel
+    val safetyLevel: SafetyLevel,
+    val installPath: String? = null,
+    val targetSdk: Int? = null,
+    val minSdk: Int? = null,
+    val permissions: Int? = null
 )
 
 @Serializable
@@ -87,3 +99,9 @@ data class BatchComplete(
     val successCount: Int,
     val failureCount: Int
 )
+
+@Serializable
+data class AppActivityFilter(
+    val type: String = "all", // "all"|"user"|"system"
+    val search: String = ""
+)

web/src/api/bridge.ts

@@ -7,7 +7,9 @@ import type {
   RealtimeStatus,
   ActionLog,
   AppFilter,
-  DeviceInfo
+  DeviceInfo,
+  AppActivityFilter,
+  AppActivities
 } from './types'
 
 // Check if running in development mode (browser)
@@ -243,9 +245,10 @@ export const bridge = {
   },
 
   // Get all activities from installed apps
-  getActivities: (): { packageName: string; appName: string; isSystem: boolean; activities: string[] }[] => {
+  getActivities: (filter?: AppActivityFilter): AppActivities[] => {
     if (!isNativeBridgeAvailable()) return []
-    return callNative(() => window.NativeBridge.getActivities())
+    const filterJson = filter ? JSON.stringify(filter) : '{}'
+    return callNative(() => window.NativeBridge.getActivities(filterJson))
   },
 
   // Launch a specific activity
@@ -276,5 +279,35 @@ export const bridge = {
     } catch {
       return false
     }
+  },
+
+  // Clear app cache
+  clearCache: (packageName: string): ActionResult => {
+    if (!isNativeBridgeAvailable()) {
+      return {
+        success: false,
+        message: 'Native bridge not available',
+        packageName,
+        action: 'CLEAR_CACHE'
+      }
+    }
+    return callNative<ActionResult>(() =>
+      window.NativeBridge.clearCache(packageName)
+    )
+  },
+
+  // Clear app data
+  clearData: (packageName: string): ActionResult => {
+    if (!isNativeBridgeAvailable()) {
+      return {
+        success: false,
+        message: 'Native bridge not available',
+        packageName,
+        action: 'CLEAR_DATA'
+      }
+    }
+    return callNative<ActionResult>(() =>
+      window.NativeBridge.clearData(packageName)
+    )
   }
 }

web/src/api/types.ts

@@ -24,6 +24,14 @@ export interface AppInfo {
   size: number
   uid: number
   safetyLevel: SafetyLevel
+  installPath?: string
+  targetSdk?: number
+  minSdk?: number
+  permissions?: number
+  backgroundOps?: {
+    runInBackground: string
+    runAnyInBackground: string
+  }
 }
 
 export interface SystemStats {
@@ -150,3 +158,23 @@ export interface AppFilter {
   showDisabledOnly: boolean
   searchQuery: string
 }
+
+export interface AppActivityFilter {
+  type: 'all' | 'user' | 'system'
+  search: string
+}
+
+export interface ActivityInfo {
+  activityName: string
+  isExported: boolean
+  canLaunchWithoutRoot: boolean
+  hasLauncherIntent: boolean
+}
+
+export interface AppActivities {
+  packageName: string
+  appName: string
+  iconBase64?: string
+  isSystem: boolean
+  activities: ActivityInfo[]
+}