Prepare release 0.9.88

app/build.gradle.kts

@@ -37,8 +37,8 @@ android {
         applicationId = "org.kabiri.android.usbterminal"
         minSdk = 24
         targetSdk = 35
-        versionCode = System.getenv("CIRCLE_BUILD_NUM")?.toIntOrNull() ?: 17
-        versionName = "0.9.87${System.getenv("CIRCLE_BUILD_NUM") ?: ""}"
+        versionCode = System.getenv("CIRCLE_BUILD_NUM")?.toIntOrNull() ?: 18
+        versionName = "0.9.88${System.getenv("CIRCLE_BUILD_NUM") ?: ""}"
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
@@ -120,7 +120,8 @@ tasks.register<JacocoReport>("jacocoTestReport") {
     )
     val kotlinDebugTree = fileTree(layout.buildDirectory.dir("tmp/kotlin-classes/debug")) { exclude(fileFilter) }
     val mainKotlinSrc = layout.projectDirectory.dir("src/main/kotlin")
-    sourceDirectories.from(files(mainKotlinSrc))
+    val mainJavaSrc = layout.projectDirectory.dir("src/main/java")
+    sourceDirectories.from(files(mainKotlinSrc, mainJavaSrc))
     classDirectories.from(files(kotlinDebugTree))
     executionData.from(fileTree(layout.buildDirectory) {
         include(

app/src/androidTest/java/org/kabiri/android/usbterminal/MainActivityAndroidTest.kt

@@ -41,7 +41,7 @@ internal class MainActivityAndroidTest {
         // arrange
         // act
         // assert
-        onView(withId(R.id.tvOutput)).check(matches(isDisplayed()))
+        onView(withId(R.id.composeOutput)).check(matches(isDisplayed()))
         onView(withId(R.id.btEnter)).check(matches(isDisplayed()))
         onView(withId(R.id.etInput)).check(matches(isDisplayed()))
     }

app/src/androidTest/java/org/kabiri/android/usbterminal/ui/terminal/TerminalOutputAndroidTest.kt

@@ -0,0 +1,183 @@
+package org.kabiri.android.usbterminal.ui.terminal
+
+import android.content.ClipboardManager
+import android.content.Context
+import androidx.activity.ComponentActivity
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.longClick
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performTouchInput
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.kabiri.android.usbterminal.model.OutputText
+import org.kabiri.android.usbterminal.ui.theme.UsbTerminalTheme
+
+@RunWith(AndroidJUnit4::class)
+class TerminalOutputAndroidTest {
+    @get:Rule
+    val composeRule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun terminalOutput_displaysAllLines() {
+        // arrange
+        val logs =
+            mutableStateListOf(
+                OutputText("Line 1", OutputText.OutputType.TYPE_NORMAL),
+                OutputText("Error!", OutputText.OutputType.TYPE_ERROR),
+                OutputText("Info", OutputText.OutputType.TYPE_INFO),
+            )
+
+        // act
+        composeRule.setContent {
+            UsbTerminalTheme {
+                TerminalOutput(logs = logs, autoScroll = false)
+            }
+        }
+
+        // assert
+        composeRule.onNodeWithText("Line 1").assertIsDisplayed()
+        composeRule.onNodeWithText("Error!").assertIsDisplayed()
+        composeRule.onNodeWithText("Info").assertIsDisplayed()
+    }
+
+    @Test
+    fun terminalOutput_longPressCopiesAllText() {
+        // arrange
+        val context = composeRule.activity
+        val logs =
+            mutableStateListOf(
+                OutputText("A\n", OutputText.OutputType.TYPE_NORMAL),
+                OutputText("B", OutputText.OutputType.TYPE_NORMAL),
+            )
+
+        composeRule.setContent {
+            UsbTerminalTheme {
+                TerminalOutput(logs = logs, autoScroll = true)
+            }
+        }
+
+        // act: long-press on one of the visible lines (parent handles the gesture)
+        composeRule.onNodeWithText("B").performTouchInput { longClick() }
+        composeRule.waitForIdle()
+
+        // assert clipboard contains concatenated text
+        val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+        val copied =
+            clipboard.primaryClip
+                ?.getItemAt(0)
+                ?.coerceToText(context)
+                ?.toString()
+        assertThat(copied).isEqualTo("A\nB")
+    }
+
+    @Test
+    fun terminalOutput_appliesModifierTag() {
+        // arrange
+        val logs =
+            mutableStateListOf(
+                OutputText("Tagged line", OutputText.OutputType.TYPE_NORMAL),
+            )
+
+        // act
+        composeRule.setContent {
+            UsbTerminalTheme {
+                TerminalOutput(
+                    logs = logs,
+                    autoScroll = false,
+                    modifier = Modifier.testTag("terminal"),
+                )
+            }
+        }
+
+        // assert: the tagged node exists and is visible, and the text is displayed
+        composeRule.onNodeWithTag("terminal").assertExists().assertIsDisplayed()
+        composeRule.onNodeWithText("Tagged line").assertIsDisplayed()
+    }
+
+    @Test
+    fun terminalOutput_handlesEmptyLogs_andLongPressCopiesEmpty() {
+        // arrange
+        val context = composeRule.activity
+        val logs = mutableStateListOf<OutputText>()
+
+        composeRule.setContent {
+            UsbTerminalTheme {
+                TerminalOutput(
+                    logs = logs,
+                    autoScroll = false,
+                    modifier =
+                        Modifier.testTag("terminal"),
+                )
+            }
+        }
+
+        // act: long-press the list itself
+        composeRule.onNodeWithTag("terminal").performTouchInput { longClick() }
+        composeRule.waitForIdle()
+
+        // assert: clipboard should contain empty string
+        val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+        val copied =
+            clipboard.primaryClip
+                ?.getItemAt(0)
+                ?.coerceToText(context)
+                ?.toString()
+        assertThat(copied).isEqualTo("")
+    }
+
+    @Test
+    fun terminalOutput_autoScrollTrue_withEmptyList_isStable() {
+        // arrange
+        val logs = mutableStateListOf<OutputText>()
+
+        // act
+        composeRule.setContent {
+            UsbTerminalTheme {
+                TerminalOutput(
+                    logs = logs,
+                    autoScroll = true,
+                    modifier = Modifier.testTag("terminal"),
+                )
+            }
+        }
+
+        // assert: composable exists but not enabled when with empty logs and autoScroll enabled
+        composeRule.onNodeWithTag("terminal").assertExists()
+    }
+
+    @Test
+    fun terminalOutput_noAutoScroll_append_rendersNewItem() {
+        // arrange
+        val logs =
+            mutableStateListOf(
+                OutputText("Initial", OutputText.OutputType.TYPE_NORMAL),
+            )
+
+        composeRule.setContent {
+            UsbTerminalTheme {
+                TerminalOutput(
+                    logs = logs,
+                    autoScroll = false,
+                    modifier = Modifier.testTag("terminal"),
+                )
+            }
+        }
+
+        // act: append a new line while autoScroll is disabled
+        composeRule.runOnUiThread {
+            logs.add(OutputText("Next", OutputText.OutputType.TYPE_NORMAL))
+        }
+        composeRule.waitForIdle()
+
+        // assert: new item is rendered (if condition path with autoScroll=false evaluated)
+        composeRule.onNodeWithText("Next").assertIsDisplayed()
+    }
+}

app/src/main/java/org/kabiri/android/usbterminal/MainActivity.kt

@@ -1,7 +1,6 @@
 package org.kabiri.android.usbterminal
 
 import android.os.Bundle
-import android.text.method.ScrollingMovementMethod
 import android.util.Log
 import android.view.KeyEvent
 import android.view.Menu
@@ -11,17 +10,17 @@ import android.view.View
 import android.view.inputmethod.EditorInfo
 import android.widget.Button
 import android.widget.EditText
-import android.widget.TextView
 import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.runtime.collectAsState
+import androidx.compose.ui.platform.ComposeView
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
-import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.launch
 import org.kabiri.android.usbterminal.ui.setting.SettingModalBottomSheet
 import org.kabiri.android.usbterminal.ui.setting.SettingViewModel
-import org.kabiri.android.usbterminal.util.scrollToLastLine
+import org.kabiri.android.usbterminal.ui.terminal.TerminalOutput
+import org.kabiri.android.usbterminal.ui.theme.UsbTerminalTheme
 import org.kabiri.android.usbterminal.viewmodel.MainActivityViewModel
 
 private const val TAG = "MainActivity"
@@ -34,6 +33,7 @@ class MainActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         viewModel.startObservingUsbDevice()
+        viewModel.startObservingTerminalOutput()
         setContentView(R.layout.activity_main)
 
         val rootView = findViewById<View>(R.id.root_view)
@@ -56,26 +56,17 @@ class MainActivity : AppCompatActivity() {
         }
 
         val etInput = findViewById<EditText>(R.id.etInput)
-        val tvOutput = findViewById<TextView>(R.id.tvOutput)
+        val composeOutput = findViewById<ComposeView>(R.id.composeOutput)
         val btEnter = findViewById<Button>(R.id.btEnter)
 
-        // make the text view scrollable:
-        tvOutput.movementMethod = ScrollingMovementMethod()
-
-        var autoScrollEnabled = true
-        lifecycleScope.launch {
-            settingViewModel.currentAutoScroll.collect { enabled ->
-                autoScrollEnabled = enabled
-            }
-        }
-
-        lifecycleScope.launch {
-            viewModel.getLiveOutput()
-            viewModel.output.collect {
-                tvOutput.apply {
-                    text = it
-                    if (autoScrollEnabled) scrollToLastLine()
-                }
+        // Compose terminal output UI
+        composeOutput.setContent {
+            UsbTerminalTheme {
+                val autoScrollEnabled = settingViewModel.currentAutoScroll.collectAsState(initial = true).value
+                TerminalOutput(
+                    logs = viewModel.output,
+                    autoScroll = autoScrollEnabled,
+                )
             }
         }