Refactor: Improve Device Handling and UI Elements

This commit introduces several enhancements to device interaction and user interface elements:

**Device Handling:**
- **Device Selection:** Users can now see a list of connected devices and select a specific device for ADB commands. The selected device is stored in `AdbInput.selectedDevice`.
- **`getDeviceList()`:** A new function in `AdbInput.kt` to retrieve a list of connected device serial numbers.
- **`DeviceListView` Updates:**
    - Displays the list of connected devices.
    - Allows users to select a device by clicking on its serial number.
    - Shows "(Selected)" next to the currently active device.
    - Includes a refresh button to update the device list.
    - Shows a toast message if no devices are found or when a device serial is long-pressed.
- **Command Execution:** ADB commands are now executed specifically on the selected device using `adb -s <selectedDevice> ...`.

**UI Enhancements:**
- **Toast Notifications:** Introduced a `ToastManager` to display short or long duration toast messages. This is used for notifying users about device connection status.
- **Icon Resources:** Added `ic_expand_less.svg`, `ic_expand_more.svg`, and `ic_power.svg` for UI elements.
- **`NeoIcon` Component:** The `size` parameter is now available to customize icon dimensions.
- **`AndroidNavigationView`:** Increased the size of navigation icons (Back, Home, Recent App) to `48.dp`.
- **`ControlsView`:**
    - Replaced the "Power Button" text button with a `NeoIcon` using `ic_power.svg`.
    - Added dropdown menus for selecting the target device (e.g., "Pixel 6", "Pixel 3") and the unlock method (e.g., "Password", "Pin") for the unlock functionality.
    - The unlock functionality now considers the selected device and unlock method.
- **`MainView`:**
    - Added an overlay that appears if no device is connected, prompting the user to connect a device. Clicking this overlay shows a toast message.
- **Input Handling:** Removed an unnecessary `AdbInput.sendEnter()` call after `AdbInput.sendText()` in `ADBTerminalInputs.kt` for "write" commands.

**Code Structure:**
- **`ToastDurationType.kt`:** New enum to define toast duration types (SHORT, LONG).
- **`setComposeWindowProvider`:** Added a function to provide the `ComposeWindow` instance to `ToastManager`.

These changes aim to provide a more user-friendly experience by clearly indicating connected devices, allowing selection, and offering more specific control options.

Author: laetuz

composeApp/src/desktopMain/kotlin/id/neotica/modernadb/adb/ADBTerminalInputs.kt

@@ -28,7 +28,7 @@ fun idiomaticAdbInputs(input: String, callback: ((String) -> Unit)? = null) {
         }
         input == "power" -> AdbInput.powerButton()
         input == "devices" -> {
-            val output = AdbInput.deviceList()//.inputStream.bufferedReader().readText()
+            val output = AdbInput.getDevices()//.inputStream.bufferedReader().readText()
             callback?.invoke(output)
         }
         input.startsWith("midtap") -> {
@@ -114,8 +114,6 @@ fun idiomaticAdbInputs(input: String, callback: ((String) -> Unit)? = null) {
 
             AdbInput.sendText(writeInput)
             Thread.sleep(200)
-            AdbInput.sendEnter()
-            Thread.sleep(300)
             callback?.invoke("")
         }
         else -> {

composeApp/src/desktopMain/kotlin/id/neotica/modernadb/adb/android/AdbInput.kt

@@ -6,16 +6,15 @@ import java.io.File
 import java.util.concurrent.TimeUnit
 
 object AdbInput {
+    var selectedDevice: String? = null
 
     private val adbExecutablePath: String by lazy {
         val sdkDirs = listOfNotNull(
             System.getenv("ANDROID_SDK_ROOT"),
             System.getenv("ANDROID_HOME"),
             "${System.getProperty("user.home")}/Library/Android/sdk",
             "/usr/local/share/android-sdk",
-            "/opt/android-sdk",
-//            "generated/moko-resources/desktopMain/res/files/adbmac",
-//            MR.files
+            "/opt/android-sdk"
         )
 
         val found = sdkDirs
@@ -25,18 +24,18 @@ object AdbInput {
         found?.absolutePath ?: error("ADB not found in common locations. Please install Android SDK.")
     }
 
-    /**
-     * Executes a command using the system shell, which correctly handles pipes and other features.
-     * It returns the Process object for further handling.
-     */
     private fun exec(cmd: String, waitAfter: Long = 100): Process {
         val fullCommand = cmd.replaceFirst("adb", adbExecutablePath)
         println("DEBUG: Executing command: '$fullCommand'")
+        val test = "adb devices"
+        val formattedSelectedAdb = fullCommand.replaceFirst("adb", "adb -s $selectedDevice")
+
+        println("modernadb: ${test.replaceFirst("adb", "adb -s $selectedDevice")}")
 
         val processBuilder = if (System.getProperty("os.name").startsWith("Windows")) {
-            ProcessBuilder("cmd.exe", "/c", fullCommand)
+            ProcessBuilder("cmd.exe", "/c", formattedSelectedAdb)
         } else {
-            ProcessBuilder("sh", "-c", fullCommand)
+            ProcessBuilder("sh", "-c", formattedSelectedAdb)
         }
 
         val environment = processBuilder.environment()
@@ -60,7 +59,7 @@ object AdbInput {
         return process
     }
 
-    fun deviceList(): String {
+    fun getDevices(): String {
         return try {
             val process = exec("adb devices")
             val reader = process.inputStream.bufferedReader().readText()
@@ -75,7 +74,31 @@ object AdbInput {
         }
     }
 
+    fun getDeviceList(): List<String> {
+        return try {
+            val process = exec("adb devices")
+            val reader = process.inputStream.bufferedReader().readText()
+            val result = reader.lines().drop(1).mapNotNull {
+                val serial = it.split('\t').firstOrNull()
+                serial?.takeIf { serial.isNotBlank() }
+            }
+
+            println("result: $result")
+            result
+        } catch (e: Exception) {
+            emptyList()
+        }
+    }
+
     fun powerButton() = exec("adb shell input keyevent 26")
+    fun longPressPowerButton() = exec("adb shell input keyevent --longpress 26")
+
+    //power
+    fun shutdown() = exec("adb reboot -p")
+    fun reboot() = exec("adb reboot")
+    fun rebootRecovery() = exec("adb reboot recovery")
+    fun rebootBootloader() = exec("adb reboot bootloader")
+
 
     fun isAwake(): Boolean {
         return try {

composeApp/src/desktopMain/kotlin/id/neotica/modernadb/presentation/AndroidNavigationView.kt

@@ -32,7 +32,8 @@ import kotlinx.coroutines.launch
 
 @OptIn(InternalComposeUiApi::class, ExperimentalMaterial3Api::class)
 @Composable
-fun AndroidNavigationView() {
+fun AndroidNavigationView(
+) {
     var expanded by remember { mutableStateOf(false) }
 
     val scope = rememberCoroutineScope()
@@ -51,20 +52,23 @@ fun AndroidNavigationView() {
                 NeoIcon(
                     desc = "Back",
                     image = MR.images.nav_back,
+                    size = 48.dp,
                     onClick = {
                         scope.launch { idiomaticAdbInputs("back") }
                     }
                 )
                 NeoIcon(
                     desc = "Home",
                     image = MR.images.nav_home,
+                    size = 48.dp,
                     onClick = {
                         scope.launch { idiomaticAdbInputs("home") }
                     }
                 )
                 NeoIcon(
                     desc = "Recent App",
                     image = MR.images.nav_recent,
+                    size = 48.dp,
                     onClick = {
                         scope.launch { idiomaticAdbInputs("switch") }
                     }

composeApp/src/desktopMain/kotlin/id/neotica/modernadb/presentation/CommandView.kt

@@ -45,19 +45,15 @@ fun CommandView(modifier: Modifier = Modifier) {
     ){
         Column(
             modifier = Modifier
-//                .fillMaxWidth()
                 .padding(16.dp),
             horizontalAlignment = Alignment.CenterHorizontally
         ) {
             Row(
                 verticalAlignment = Alignment.CenterVertically,
                 horizontalArrangement = Arrangement.Center
             ) {
-                // 2. The Switch logic is now based on the sealed class state.
                 Switch(
-                    // The switch is "on" (checked) if the mode is Write.
                     checked = currentMode == InputMode.Write,
-                    // When the switch is toggled, update the state to the corresponding mode.
                     onCheckedChange = { isChecked ->
                         currentMode = if (isChecked) InputMode.Write else InputMode.Command
                     }

composeApp/src/desktopMain/kotlin/id/neotica/modernadb/presentation/ControlsView.kt

@@ -1,8 +1,16 @@
 package id.neotica.modernadb.presentation
 
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.material.DropdownMenu
+import androidx.compose.material.DropdownMenuItem
+import androidx.compose.material.Icon
+import androidx.compose.material3.Text
 import androidx.compose.material.TextField
 import androidx.compose.material3.Card
 import androidx.compose.runtime.Composable
@@ -11,15 +19,18 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.key.Key
 import androidx.compose.ui.input.key.key
 import androidx.compose.ui.input.key.onKeyEvent
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.unit.dp
+import dev.icerock.moko.resources.compose.painterResource
 import id.neotica.modernadb.adb.android.AdbInput
-import id.neotica.modernadb.adb.idiomaticAdbInputs
 import id.neotica.modernadb.presentation.components.ButtonBasic
+import id.neotica.modernadb.presentation.components.NeoIcon
+import id.neotica.modernadb.res.MR
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
@@ -29,17 +40,27 @@ fun ControlsView(
 ) {
     val scope = rememberCoroutineScope()
 
+    val deviceList = listOf("Pixel 6", "Pixel 3")
+    var selectedDevice by remember { mutableStateOf(deviceList.first()) }
+    var dropDownState by remember { mutableStateOf(false) }
+
+    val unlockMethods = listOf("Password", "Pin")
+    var selectedMethod by remember { mutableStateOf(unlockMethods.first()) }
+    var unlockState by remember { mutableStateOf(false) }
     Card {
         Column(
             modifier = modifier
                 .padding(16.dp),
         ) {
-            ButtonBasic("Power Button") {
-                scope.launch(Dispatchers.IO) {
-                    idiomaticAdbInputs("power")
-                }
+            NeoIcon(
+                desc = "Power Button",
+                image = MR.images.ic_power,
+                onLongClick = { AdbInput.longPressPowerButton() }
+            ) {
+                AdbInput.powerButton()
             }
 
+
             var password by remember { mutableStateOf("") }
 
             TextField(
@@ -48,13 +69,13 @@ fun ControlsView(
                 visualTransformation = PasswordVisualTransformation(),
                 keyboardActions = KeyboardActions {
                     scope.launch(Dispatchers.IO) {
-                        AdbInput.unlock(password)
+                        unlock(password, selectedDevice, selectedMethod)
                     }
                 },
                 modifier = Modifier.onKeyEvent { keyEvent ->
                     if (keyEvent.key == Key.Enter) {
                         scope.launch(Dispatchers.IO) {
-                            AdbInput.unlock(password)
+                            unlock(password, selectedDevice, selectedMethod)
                         }
                         true
                     } else {
@@ -63,9 +84,104 @@ fun ControlsView(
                 }
             )
 
-            ButtonBasic("Unlock device") {
-                scope.launch {
-                    AdbInput.unlock(password)
+            Row(
+                modifier = Modifier.padding(16.dp),
+                horizontalArrangement = Arrangement.spacedBy(16.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                ButtonBasic("Unlock") {
+                    scope.launch {
+                        unlock(password, selectedDevice, selectedMethod)
+                    }
+                }
+
+                DropdownBasic(
+                    items = deviceList,
+                    selectedItem = selectedDevice,
+                    expanded = dropDownState
+                ) {
+                    selectedDevice = it
+                }
+
+                DropdownBasic(
+                    items = unlockMethods,
+                    selectedItem = selectedMethod,
+                    expanded = unlockState
+                ) {
+                    selectedMethod = it
+                }
+            }
+
+            var powerState by remember { mutableStateOf(false) }
+            ButtonBasic("Power") {
+                powerState = !powerState
+            }
+            if (powerState) {
+                ButtonBasic("Shut down") { AdbInput.shutdown() }
+                ButtonBasic("Reboot") { AdbInput.reboot() }
+                ButtonBasic("Reboot Recovery") { AdbInput.rebootRecovery() }
+                ButtonBasic("Reboot Bootloader") { AdbInput.rebootBootloader() }
+            }
+
+        }
+    }
+}
+
+private fun unlock(password: String, device: String, method: String) {
+
+    when (device) {
+        "Pixel 6" -> {
+            when (method) {
+                "Password" -> {}
+                "Pin" -> AdbInput.unlock(password)
+            }
+        }
+        else -> {
+            when (method) {
+                "Password" -> {}
+                "Pin" -> AdbInput.unlock(password)
+            }
+        }
+    }
+
+}
+
+@Composable
+fun DropdownBasic(
+    items: List<String>,
+    selectedItem: String,
+    expanded: Boolean,
+    dropDownStateCallback: (String) -> Unit
+) {
+    var dropDownState by remember { mutableStateOf(expanded) }
+    var selectedDevice by remember { mutableStateOf(selectedItem) }
+
+    Box {
+        Row(
+            modifier = Modifier.clickable {
+                dropDownState = true
+            },
+            horizontalArrangement = Arrangement.Center,
+        ) {
+            Text(selectedDevice)
+            Icon(
+                painter = painterResource(MR.images.ic_expand_more),
+                contentDescription = "Expand More"
+            )
+        }
+        DropdownMenu(
+            expanded = dropDownState,
+            onDismissRequest = {
+                dropDownState = false
+            }
+        ) {
+            items.forEach {
+                DropdownMenuItem(onClick = {
+                    dropDownStateCallback(it)
+                    selectedDevice = it
+                    dropDownState = false
+                }) {
+                    Text(it)
                 }
             }
         }