Version 0.4.2

.github/workflows/build_and_test.yaml

@@ -0,0 +1,73 @@
+name: Build and Test
+on: [pull_request, push, workflow_dispatch]
+
+jobs:
+  # Job 1: Build and fast checks
+  build-and-unit-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: true
+
+      - name: Set up JDK
+        uses: actions/setup-java@v5
+        with:
+          java-version: "21"
+          distribution: "temurin"
+          cache: gradle
+
+      - name: Build, lint and run Unit Tests in parallel
+        run: |
+          chmod +x gradlew
+          ./gradlew build lint test
+
+  # Job 2: Parallel Instrumented Tests
+  instrumented-tests:
+    needs: build-and-unit-test # Only run if build/unit tests pass
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false # Don't cancel API 34 if API 26 fails
+      matrix:
+        api-level:
+          - 26 # Minimum supported API level
+          - 34 # Target API level for testing
+          - 36 # Latest API level
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: true
+
+      - name: set up JDK
+        uses: actions/setup-java@v5
+        with:
+          java-version: "21"
+          distribution: "temurin"
+          cache: gradle
+
+      - name: Make gradlew executable
+        run: chmod +x gradlew
+
+      - name: Enable KVM
+        run: |
+          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+          sudo udevadm control --reload-rules
+          sudo udevadm trigger --name-match=kvm
+
+      - name: Run Instrumented Tests (API ${{ matrix.api-level }})
+        uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: ${{ matrix.api-level }}
+          target: ${{ matrix.api-level >= 31 && 'google_apis' || 'default' }}
+          arch: x86_64
+          disable-animations: true
+          script: ./gradlew connectedCheck --stacktrace
+
+      - name: Upload Test Report (API ${{ matrix.api-level }})
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: reports-api-${{ matrix.api-level }}
+          path: app/build/reports/androidTests/connected/
+          retention-days: 7

.gitignore

@@ -45,8 +45,5 @@ replay_pid*
 # Kotlin Gradle plugin data, see https://kotlinlang.org/docs/whatsnew20.html#new-directory-for-kotlin-data-in-gradle-projects
 .kotlin/
 
-# Generated files
-/app/src/main/java/io/github/kitswas/VGP_Data_Exchange
-
 # Ignore the following file to keep keystore information private
 signing.properties

app/build.gradle.kts

@@ -4,7 +4,6 @@ import java.util.Properties
 
 plugins {
     alias(libs.plugins.android.application)
-    alias(libs.plugins.kotlin.android)
     alias(libs.plugins.kotlin.compose)
     alias(libs.plugins.dokka)
     alias(libs.plugins.kotlin.parcelize)
@@ -21,8 +20,8 @@ android {
         minSdk = 26
         // Specifies the API level used to test the app.
         targetSdk = 34
-        versionCode = 10
-        versionName = "0.4.1"
+        versionCode = 11
+        versionName = "0.4.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
@@ -52,18 +51,13 @@ android {
 
     compileOptions {
         isCoreLibraryDesugaringEnabled = true
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-
-    kotlin {
-        compilerOptions {
-            jvmTarget = JvmTarget.fromTarget("17")
-        }
+        sourceCompatibility = JavaVersion.VERSION_21
+        targetCompatibility = JavaVersion.VERSION_21
     }
 
     buildFeatures {
         compose = true
+        resValues = true
     }
 
     composeOptions {
@@ -82,10 +76,22 @@ android {
         includeInApk = false
         includeInBundle = false
     }
+
+    sourceSets {
+        getByName("main") {
+            java.directories.add("../VGP_Data_Exchange")
+        }
+    }
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.fromTarget("21")
+    }
 }
 
 val props = Properties()
-val propFile = File("signing.properties")
+val propFile: File = rootProject.file("signing.properties")
 
 if (propFile.canRead()) {
     props.load(FileInputStream(propFile))
@@ -117,6 +123,7 @@ dependencies {
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.window)
     implementation(libs.compose.ui)
+    implementation(libs.compose.material.icons.extended)
     implementation(libs.compose.ui.tooling.preview)
     implementation(libs.kotlinx.serialization.json)
     implementation(libs.material3)
@@ -127,7 +134,6 @@ dependencies {
     implementation(libs.zxing.android.embedded)
     implementation(libs.zxing.core)
     implementation(platform(libs.compose.bom))
-    testImplementation(libs.robolectric)
     coreLibraryDesugaring(libs.desugar.jdk.libs)
 
     // Test dependencies
@@ -144,15 +150,3 @@ dependencies {
     debugImplementation(libs.compose.ui.test.manifest)
     debugImplementation(libs.compose.ui.tooling)
 }
-
-val updateVGPDataExchangePackage by tasks.registering(ProcessResources::class) {
-    println("Updating VGP_Data_Exchange package...")
-    from(rootDir.toPath().resolve("VGP_Data_Exchange/io/github/kitswas/VGP_Data_Exchange"))
-    into(rootDir.toPath().resolve("app/src/main/java/io/github/kitswas/VGP_Data_Exchange"))
-}
-
-tasks.matching {
-    it != updateVGPDataExchangePackage.get()
-}.configureEach {
-    dependsOn(updateVGPDataExchangePackage)
-}

app/src/test/java/io/github/kitswas/virtualgamepadmobile/TestGamepadServer.kt → app/src/androidTest/java/io/github/kitswas/virtualgamepadmobile/TestGamepadServer.kt

@@ -11,27 +11,7 @@ import java.util.concurrent.atomic.AtomicBoolean
 object TestGamepadServer {
     private val running = AtomicBoolean(false)
     private var serverSocket: ServerSocket? = null
-
-    @JvmStatic
-    fun main(args: Array<String>) {
-        val port = if (args.isNotEmpty()) args[0].toInt() else 7878
-        start(port)
-
-        // Add shutdown hook for clean server shutdown
-        Runtime.getRuntime().addShutdownHook(Thread {
-            println("[TestGamepadServer] Shutting down...")
-            stop()
-        })
-
-        // Keep main thread alive
-        try {
-            while (running.get()) {
-                Thread.sleep(1000)
-            }
-        } catch (_: InterruptedException) {
-            stop()
-        }
-    }
+    private val readings = Collections.synchronizedList(mutableListOf<GamepadReading>())
 
     fun start(port: Int) {
         if (running.getAndSet(true)) {
@@ -41,40 +21,32 @@ object TestGamepadServer {
 
         try {
             serverSocket = ServerSocket(port)
-            println("[TestGamepadServer] Listening on port $port on interfaces:")
+            println("[TestGamepadServer] Listening on port ${serverSocket?.localPort} on interfaces:")
             // List all network interfaces and addresses
             Collections.list(NetworkInterface.getNetworkInterfaces())
                 .filter { it.isUp && !it.isLoopback }.forEach { nif ->
                     Collections.list(nif.inetAddresses).forEach { address ->
                         println("[TestGamepadServer] ${nif.displayName}: $address")
                     }
                 }
-            println("[TestGamepadServer] Connect to 10.0.2.2:$port from your emulator")
 
             // Start server loop in a separate thread
             Thread {
                 try {
                     while (running.get()) {
                         try {
-                            // Block waiting for client connection (like production server)
+                            // Block waiting for client connection
                             val client = serverSocket?.accept()
                             if (client != null && running.get()) {
                                 println("[TestGamepadServer] Client connected: ${client.remoteSocketAddress}")
-
-                                // Configure socket like production server
                                 client.tcpNoDelay = true
-
-                                // Handle client in current thread (blocking, like production server)
-                                // This mimics tcpServer->pauseAccepting() behavior
                                 handleClient(client)
-
                                 println("[TestGamepadServer] Client disconnected, ready for new connections")
                             }
                         } catch (e: Exception) {
                             if (running.get()) {
                                 System.err.println("[TestGamepadServer] Error accepting client: $e")
-                                // Small delay before retrying
-                                Thread.sleep(1000)
+                                Thread.sleep(100)
                             }
                         }
                     }
@@ -97,17 +69,24 @@ object TestGamepadServer {
         }
 
         println("[TestGamepadServer] Stopping server...")
-
-        // Close server socket
         try {
             serverSocket?.close()
         } catch (e: Exception) {
             System.err.println("[TestGamepadServer] Error closing server socket: $e")
         }
-
         println("[TestGamepadServer] Server stopped")
     }
 
+    fun getPort(): Int = serverSocket?.localPort ?: -1
+
+    fun clearReadings() {
+        readings.clear()
+    }
+
+    fun getReadings(): List<GamepadReading> {
+        return readings.toList()
+    }
+
     private fun handleClient(client: Socket) {
         try {
             client.use { socket ->
@@ -117,30 +96,22 @@ object TestGamepadServer {
                         try {
                             val len = inputStream.read(buf)
                             if (len == -1) {
-                                println("[TestGamepadServer] Client closed connection (EOF)")
                                 break
                             }
 
-                            // Process the received data
-                            try {
-                                val reading = GamepadReading()
-                                reading.unmarshal(buf, 0, len)
-                                logGamepadReading(reading)
-                            } catch (e: Exception) {
-                                // Handle partial reads or invalid data gracefully
-                                System.err.println("[TestGamepadServer] Failed to unmarshal: $e")
-                                System.err.println(
-                                    "[TestGamepadServer] Raw bytes (len=$len): ${
-                                        buf.copyOf(
-                                            len
-                                        ).joinToString(" ") { "%02x".format(it) }
-                                    }"
-                                )
+                            var offset = 0
+                            while (offset < len) {
+                                try {
+                                    val reading = GamepadReading()
+                                    offset = reading.unmarshal(buf, offset, len)
+                                    readings.add(reading)
+                                    logGamepadReading(reading)
+                                } catch (e: Exception) {
+                                    System.err.println("[TestGamepadServer] Failed to unmarshal at offset $offset: $e")
+                                    break
+                                }
                             }
                         } catch (e: Exception) {
-                            if (running.get() && !socket.isClosed) {
-                                System.err.println("[TestGamepadServer] Read error: $e")
-                            }
                             break
                         }
                     }