feat: UI Redesign Navigation - Major Update

 Navigation Restructure:
- Migrated from BottomNavigationView to TabLayout + ViewPager2
- Added swipe gesture support between Dashboard and Apps tabs
- Implemented overflow menu (Settings, Action Logs, About)
- New MainPagerAdapter for fragment management

 Apps List Improvements:
- Added FilterSortBottomSheet for unified filter/sort UI
- New filter options: All, Running, Frozen, Restricted
- New sort options: Name A-Z, Name Z-A, Size, Last Updated
- Updated search bar with filter button

 Running State Detection:
- Added AppRunningStateDetector interface with multi-method detection
- RootRunningStateDetector: /proc check + dumpsys services
- ShizukuRunningStateDetector: dumpsys services
- ViewOnlyRunningStateDetector: UsageStatsManager
- New AppRunningState enum (RUNNING, AWAKENED, STOPPED, UNKNOWN)
- Running state badges on app list items

 Settings Enhancements:
- Added Action Logs section with View, Rollback, Clear options
- Added Animation Scale controls (presets + custom slider)
- Rollback availability state management

ℹ About Page Redesign:
- Material 3 card-based design
- Gradient header background
- App Info, Developer, and Links sections
- Removed informal text

 Data Models:
- AnimationScale with presets and custom values
- AppListFilter for filter/sort state
- Updated AppInfo with runningState and isBackgroundRestricted

Requirements: 1.x, 2.x, 3.x, 4.x, 6.x, 7.x, 8.x

Author: risunCode

app/src/main/java/com/appcontrolx/data/model/AnimationScale.kt

@@ -0,0 +1,65 @@
+package com.appcontrolx.data.model
+
+/**
+ * Data class representing animation scale settings for the device.
+ * Requirements: 7.3
+ */
+data class AnimationScale(
+    val windowScale: Float,
+    val transitionScale: Float,
+    val animatorScale: Float
+) {
+    companion object {
+        val DEFAULT = AnimationScale(1.0f, 1.0f, 1.0f)
+        val OFF = AnimationScale(0f, 0f, 0f)
+
+        /**
+         * Preset animation scale values with display names.
+         * Requirements: 7.3
+         */
+        val PRESETS = listOf(
+            0f to "Off",
+            0.5f to "0.5x",
+            0.75f to "0.75x",
+            1.0f to "1x (Default)",
+            1.5f to "1.5x",
+            2.0f to "2x"
+        )
+
+        /**
+         * Minimum allowed animation scale value.
+         */
+        const val MIN_SCALE = 0.0f
+
+        /**
+         * Maximum allowed animation scale value.
+         */
+        const val MAX_SCALE = 10.0f
+
+        /**
+         * Creates an AnimationScale with all three scales set to the same value.
+         */
+        fun uniform(scale: Float): AnimationScale {
+            val clampedScale = scale.coerceIn(MIN_SCALE, MAX_SCALE)
+            return AnimationScale(clampedScale, clampedScale, clampedScale)
+        }
+    }
+
+    /**
+     * Returns true if all scales are set to the same value.
+     */
+    fun isUniform(): Boolean = windowScale == transitionScale && transitionScale == animatorScale
+
+    /**
+     * Returns the uniform scale value if all scales are the same, or null otherwise.
+     */
+    fun getUniformScale(): Float? = if (isUniform()) windowScale else null
+
+    /**
+     * Returns the preset name if this matches a preset, or "Custom" otherwise.
+     */
+    fun getPresetName(): String {
+        val uniformScale = getUniformScale() ?: return "Custom"
+        return PRESETS.find { it.first == uniformScale }?.second ?: "Custom"
+    }
+}

app/src/main/java/com/appcontrolx/data/model/AppInfo.kt

@@ -15,6 +15,7 @@ enum class AppStatus {
 
 /**
  * Data class representing information about an installed application.
+ * Requirements: 5.1, 5.2, 4.6
  */
 data class AppInfo(
     val packageName: String,
@@ -28,7 +29,13 @@ data class AppInfo(
     val isStopped: Boolean,
     val isBackgroundRestricted: Boolean,
     val installedTime: Long,
-    val lastUpdateTime: Long
+    val lastUpdateTime: Long,
+    val size: Long = 0L,
+    /**
+     * The running state of the app detected via multi-method detection.
+     * Requirements: 4.6
+     */
+    val runningState: AppRunningState = AppRunningState.UNKNOWN
 ) {
     /**
      * Whether the app is frozen (disabled)

app/src/main/java/com/appcontrolx/data/model/AppListFilter.kt

@@ -0,0 +1,32 @@
+package com.appcontrolx.data.model
+
+/**
+ * Filter type options for app list filtering.
+ * Requirements: 3.4
+ */
+enum class FilterType(val displayName: String) {
+    ALL("All"),
+    RUNNING("Running"),
+    FROZEN("Frozen"),
+    RESTRICTED("Restricted")
+}
+
+/**
+ * Sort type options for app list sorting.
+ * Requirements: 3.5
+ */
+enum class SortType(val displayName: String) {
+    NAME_ASC("Name (A-Z)"),
+    NAME_DESC("Name (Z-A)"),
+    SIZE_DESC("Size"),
+    UPDATED_DESC("Last updated")
+}
+
+/**
+ * Data class representing the current filter and sort configuration for the app list.
+ * Requirements: 3.4, 3.5
+ */
+data class AppListFilter(
+    val filterType: FilterType = FilterType.ALL,
+    val sortType: SortType = SortType.NAME_ASC
+)

app/src/main/java/com/appcontrolx/data/model/AppRunningState.kt

@@ -0,0 +1,33 @@
+package com.appcontrolx.data.model
+
+/**
+ * Enum representing the running state of an application.
+ * Used for accurate running detection on Android 12+.
+ * 
+ * Requirements: 4.6
+ */
+enum class AppRunningState {
+    /**
+     * App is confirmed running (foreground or background service).
+     * Detected via /proc check, dumpsys services, or UsageStatsManager.
+     */
+    RUNNING,
+    
+    /**
+     * App has been launched but may not be running now.
+     * FLAG_STOPPED is false, meaning the app was launched at some point.
+     */
+    AWAKENED,
+    
+    /**
+     * App has never been launched or was force-stopped.
+     * FLAG_STOPPED is true.
+     */
+    STOPPED,
+    
+    /**
+     * Cannot determine the running state.
+     * Used when detection methods fail or timeout.
+     */
+    UNKNOWN
+}

app/src/main/java/com/appcontrolx/data/model/SystemInfo.kt

@@ -64,6 +64,8 @@ data class NetworkInfo(
     val type: NetworkType,
     val isConnected: Boolean,
     val signalStrength: Int?,  // 0-4 bars, null if unavailable
+    val signalPercent: Int?,   // 0-100 percentage, null if unavailable
+    val signalDbm: Int?,       // Signal strength in dBm, null if unavailable
     val ssid: String?          // WiFi name, null if not WiFi
 )
 
@@ -96,11 +98,13 @@ data class DeviceInfo(
     val model: String,
     val device: String,
     val androidVersion: String,
+    val androidCodename: String?,  // e.g., "Baklava" for Android 16
     val apiLevel: Int,
     val buildNumber: String,
     val kernelVersion: String,
+    val socName: String?,          // SoC/processor name
     val uptimeMs: Long,
-    val deepSleepMs: Long?     // requires root
+    val deepSleepMs: Long?         // requires root
 )
 
 /**

app/src/main/java/com/appcontrolx/di/ExecutorModule.kt

@@ -7,6 +7,8 @@ import com.appcontrolx.domain.executor.PermissionBridge
 import com.appcontrolx.domain.executor.RootExecutor
 import com.appcontrolx.domain.executor.ShizukuExecutor
 import com.appcontrolx.domain.manager.ActionLogger
+import com.appcontrolx.domain.manager.AnimationScaleManager
+import com.appcontrolx.domain.manager.AnimationScaleManagerImpl
 import com.appcontrolx.domain.manager.DisplayManager
 import dagger.Module
 import dagger.Provides
@@ -95,4 +97,14 @@ object ExecutorModule {
         @ApplicationContext context: Context,
         commandExecutor: CommandExecutor
     ): ActionLogger = ActionLogger(context, commandExecutor)
+    
+    /**
+     * Provides AnimationScaleManager for animation scale control.
+     * Requirements: 7.4
+     */
+    @Provides
+    @Singleton
+    fun provideAnimationScaleManager(
+        commandExecutor: CommandExecutor
+    ): AnimationScaleManager = AnimationScaleManagerImpl(commandExecutor)
 }

app/src/main/java/com/appcontrolx/domain/detector/AppRunningStateDetector.kt

@@ -0,0 +1,29 @@
+package com.appcontrolx.domain.detector
+
+import com.appcontrolx.data.model.AppRunningState
+
+/**
+ * Interface for detecting the running state of applications.
+ * Implementations use different methods based on execution mode.
+ * 
+ * Requirements: 4.1, 4.6
+ */
+interface AppRunningStateDetector {
+    
+    /**
+     * Detect the running state of a single application.
+     * 
+     * @param packageName The package name of the app to check
+     * @return The detected running state
+     */
+    suspend fun detectRunningState(packageName: String): AppRunningState
+    
+    /**
+     * Detect the running states of multiple applications in batch.
+     * More efficient than calling detectRunningState() for each app.
+     * 
+     * @param packageNames List of package names to check
+     * @return Map of package name to detected running state
+     */
+    suspend fun detectBatchRunningStates(packageNames: List<String>): Map<String, AppRunningState>
+}