Patch manifest

.github/workflows/ci.yml

@@ -126,11 +126,11 @@ jobs:
       - name: Install dependencies
         run: yarn install --frozen-lockfile
 
-      - name: Setup Java 17
+      - name: Setup Java 21
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '17'
+          java-version: '21'
 
       - name: Setup Android SDK
         uses: android-actions/setup-android@v3
@@ -151,6 +151,9 @@ jobs:
       - name: Initialize Tauri Android project
         run: yarn tauri android init --ci
 
+      - name: Patch Android manifest for USB support
+        run: bash scripts/tauri-patch-android.sh
+
       - name: Build Tauri Android APK
         uses: tauri-apps/tauri-action@v0
         with:

ANDROID.md

@@ -319,12 +319,6 @@ mkdir -p dist && touch dist/.gitkeep
 
 ## Available Scripts
 
-### Emulator Management
-- `yarn android:emu:list` - List all AVDs
-- `yarn android:emu:check` - Check if emulator is running
-- `yarn android:emu:start` - Start emulator with SwiftShader
-- `yarn android:emu:start:host` - Start with host GPU
-
 ### Tauri Android
 - `yarn tauri:dev:android` - Development build with hot reload
 - `yarn tauri:build:android` - Production release build

package.json

@@ -20,33 +20,12 @@
     "android:run": "vite build && node capacitor.config.generator.mjs && npx cap run android",
     "android:sync": "vite build && node capacitor.config.generator.mjs && npx cap sync android",
     "android:release": "vite build && node capacitor.config.generator.mjs && npx cap build android --release",
-    "android:emu:list": "run-script-os",
-    "android:emu:list:win32": "%ANDROID_HOME%\\emulator\\emulator.exe -list-avds",
-    "android:emu:list:default": "$ANDROID_HOME/emulator/emulator -list-avds",
-    "android:emu:check": "run-script-os",
-    "android:emu:check:win32": "%ANDROID_HOME%\\platform-tools\\adb.exe devices",
-    "android:emu:check:default": "$ANDROID_HOME/platform-tools/adb devices | grep -q emulator && echo 'Emulator running' || echo 'No emulator'",
-    "android:emu:start": "run-script-os",
-    "android:emu:start:win32": "start \"\" \"%ANDROID_HOME%\\emulator\\emulator.exe\" -avd Medium_Phone_API_35 -gpu swiftshader_indirect -no-snapshot-load",
-    "android:emu:start:default": "QT_QPA_PLATFORM=xcb $ANDROID_HOME/emulator/emulator -avd ${AVD:-Medium_Phone_API_35} -gpu swiftshader_indirect -no-snapshot-load &",
-    "android:emu:start:host": "run-script-os",
-    "android:emu:start:host:win32": "start \"\" \"%ANDROID_HOME%\\emulator\\emulator.exe\" -avd Medium_Phone_API_35 -gpu host -no-snapshot-load",
-    "android:emu:start:host:default": "QT_QPA_PLATFORM=xcb $ANDROID_HOME/emulator/emulator -avd ${AVD:-Medium_Phone_API_35} -gpu host -no-snapshot-load &",
-    "android:adb:wait": "run-script-os",
-    "android:adb:wait:win32": "%ANDROID_HOME%\\platform-tools\\adb.exe wait-for-device && %ANDROID_HOME%\\platform-tools\\adb.exe shell \"while [ $(getprop sys.boot_completed) != 1 ]; do sleep 1; done\"",
-    "android:adb:wait:default": "$ANDROID_HOME/platform-tools/adb wait-for-device && until $ANDROID_HOME/platform-tools/adb shell getprop sys.boot_completed 2>/dev/null | grep -q 1; do sleep 1; done",
-    "android:adb:reverse": "run-script-os",
-    "android:adb:reverse:win32": "%ANDROID_HOME%\\platform-tools\\adb.exe reverse tcp:8000 tcp:8000",
-    "android:adb:reverse:default": "$ANDROID_HOME/platform-tools/adb reverse tcp:8000 tcp:8000",
     "format": "prettier --write {src,test}/**/*.{js,vue,css,less}",
     "storybook": "start-storybook -p 6006",
     "prepare": "husky install",
     "tauri:dev": "tauri dev",
     "tauri:build": "tauri build",
-    "tauri:dev:android": "run-script-os",
-    "tauri:dev:android:win32": "yarn android:emu:start && yarn android:adb:wait && yarn android:adb:reverse && tauri android dev",
-    "tauri:dev:android:default": "yarn android:emu:start && yarn android:adb:wait && yarn android:adb:reverse && tauri android dev",
-    "tauri:dev:android:with-dist": "yarn build && yarn tauri:dev:android",
+    "tauri:dev:android": "tauri android dev",
     "tauri:build:android": "tauri android build"
   },
   "window": {
@@ -94,6 +73,7 @@
     "semver-min": "^0.7.2",
     "short-unique-id": "^5.2.0",
     "switchery-latest": "^0.8.2",
+    "tauri-plugin-serialplugin-api": "^2.21.1",
     "three": "^0.176.0",
     "tiny-emitter": "^2.1.0",
     "tippy.js": "^6.3.7",

scripts/MainActivity.kt

@@ -0,0 +1,165 @@
+package com.betaflight.app
+
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.hardware.usb.UsbDevice
+import android.hardware.usb.UsbManager
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+
+class MainActivity : TauriActivity() {
+    private val TAG = "BetaflightUSB"
+    private val ACTION_USB_PERMISSION = "com.betaflight.configurator.USB_PERMISSION"
+
+    private val usbReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            when (intent.action) {
+                ACTION_USB_PERMISSION -> {
+                    synchronized(this) {
+                        val device: UsbDevice? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                            intent.getParcelableExtra(UsbManager.EXTRA_DEVICE, UsbDevice::class.java)
+                        } else {
+                            @Suppress("DEPRECATION")
+                            intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
+                        }
+
+                        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
+                            device?.let {
+                                Log.d(TAG, "Permission granted for device ${it.deviceName}")
+                                // Device is ready to use
+                            }
+                        } else {
+                            Log.d(TAG, "Permission denied for device ${device?.deviceName}")
+                        }
+                    }
+                }
+                UsbManager.ACTION_USB_DEVICE_ATTACHED -> {
+                    val device: UsbDevice? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        intent.getParcelableExtra(UsbManager.EXTRA_DEVICE, UsbDevice::class.java)
+                    } else {
+                        @Suppress("DEPRECATION")
+                        intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
+                    }
+                    device?.let {
+                        Log.d(TAG, "USB device attached: ${it.deviceName}")
+                        requestUsbPermission(it)
+                    }
+                }
+                UsbManager.ACTION_USB_DEVICE_DETACHED -> {
+                    val device: UsbDevice? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        intent.getParcelableExtra(UsbManager.EXTRA_DEVICE, UsbDevice::class.java)
+                    } else {
+                        @Suppress("DEPRECATION")
+                        intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
+                    }
+                    Log.d(TAG, "USB device detached: ${device?.deviceName}")
+                }
+            }
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Register USB broadcast receiver
+        val filter = IntentFilter().apply {
+            addAction(ACTION_USB_PERMISSION)
+            addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED)
+            addAction(UsbManager.ACTION_USB_DEVICE_DETACHED)
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            registerReceiver(usbReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            registerReceiver(usbReceiver, filter)
+        }
+
+        // Check if launched by USB device attachment
+        if (intent.action == UsbManager.ACTION_USB_DEVICE_ATTACHED) {
+            val device: UsbDevice? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                intent.getParcelableExtra(UsbManager.EXTRA_DEVICE, UsbDevice::class.java)
+            } else {
+                @Suppress("DEPRECATION")
+                intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
+            }
+            device?.let {
+                Log.d(TAG, "App launched by USB device: ${it.deviceName}")
+                requestUsbPermission(it)
+            }
+        } else {
+            // Check for already connected devices
+            checkConnectedDevices()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        unregisterReceiver(usbReceiver)
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+
+        if (intent.action == UsbManager.ACTION_USB_DEVICE_ATTACHED) {
+            val device: UsbDevice? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                intent.getParcelableExtra(UsbManager.EXTRA_DEVICE, UsbDevice::class.java)
+            } else {
+                @Suppress("DEPRECATION")
+                intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
+            }
+            device?.let {
+                Log.d(TAG, "USB device attached via new intent: ${it.deviceName}")
+                requestUsbPermission(it)
+            }
+        }
+    }
+
+    private fun checkConnectedDevices() {
+        val usbManager = getSystemService(Context.USB_SERVICE) as UsbManager
+        val deviceList = usbManager.deviceList
+
+        Log.d(TAG, "Checking connected USB devices: ${deviceList.size} found")
+
+        deviceList.values.forEach { device ->
+            Log.d(TAG, "Device: ${device.deviceName}, VID: ${device.vendorId}, PID: ${device.productId}")
+            if (!usbManager.hasPermission(device)) {
+                Log.d(TAG, "No permission for ${device.deviceName}, requesting...")
+                requestUsbPermission(device)
+            } else {
+                Log.d(TAG, "Already have permission for ${device.deviceName}")
+            }
+        }
+    }
+
+    private fun requestUsbPermission(device: UsbDevice) {
+        val usbManager = getSystemService(Context.USB_SERVICE) as UsbManager
+
+        if (usbManager.hasPermission(device)) {
+            Log.d(TAG, "Already have permission for ${device.deviceName}")
+            return
+        }
+
+        // Use FLAG_IMMUTABLE for Android 12+ (API 31+) as required by Android 14+ (API 34+)
+        // when using implicit intents with PendingIntent
+        val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
+
+        val permissionIntent = PendingIntent.getBroadcast(
+            this as Context,
+            0,
+            Intent(ACTION_USB_PERMISSION),
+            flags
+        )
+
+        Log.d(TAG, "Requesting USB permission for ${device.deviceName} (VID: ${device.vendorId}, PID: ${device.productId})")
+        usbManager.requestPermission(device, permissionIntent)
+    }
+}

scripts/README.md

@@ -0,0 +1,88 @@
+# Android USB Support Scripts
+
+This directory contains scripts to configure Android USB serial support for the Betaflight Configurator Tauri app.
+
+## Scripts Overview
+
+### `tauri-patch-android.sh` (Main Orchestrator)
+The main script that coordinates all Android USB configuration. Run this after `cargo tauri android init`.
+
+**What it does:**
+- Calls all individual scripts in the correct order
+- Provides overall progress reporting
+- Ensures Android project exists before proceeding
+
+### `patch-android-manifest.sh`
+Configures the Android manifest with USB permissions and intent filters.
+
+**What it does:**
+- Adds `android.permission.USB_PERMISSION` permission
+- Adds `android.hardware.usb.host` feature
+- Adds USB device attach intent filter
+- Adds metadata referencing the device filter XML
+
+### `create-device-filter.sh`
+Creates the USB device filter XML file that defines supported USB devices.
+
+**What it does:**
+- Creates `res/xml/device_filter.xml`
+- Defines USB device filters for Betaflight-compatible devices:
+  - FT232R USB UART
+  - STM32 devices (various modes)
+  - CP210x devices
+  - GD32 devices
+  - AT32 devices
+  - APM32 devices
+  - Raspberry Pi Pico devices
+
+### `patch-gradle-settings.sh`
+Configures project-level Gradle repositories in `settings.gradle.kts`.
+
+**What it does:**
+- Adds jitpack.io repository to `dependencyResolutionManagement`
+- Adds jitpack.io repository to `pluginManagement`
+- Ensures Google Maven and Maven Central are available
+
+### `patch-app-gradle.sh`
+Configures app-level Gradle dependencies and repositories.
+
+**What it does:**
+- Adds jitpack.io repository to app module
+- Adds `usb-serial-for-android:3.8.0` dependency
+- Ensures dependency resolution works at module level
+
+## Usage
+
+After running `cargo tauri android init`, execute:
+
+```bash
+bash scripts/tauri-patch-android.sh
+```
+
+This will run all configuration steps automatically.
+
+## Individual Script Usage
+
+You can also run individual scripts if needed:
+
+```bash
+# Only update manifest permissions
+bash scripts/patch-android-manifest.sh
+
+# Only update device filters
+bash scripts/create-device-filter.sh
+
+# Only update Gradle settings
+bash scripts/patch-gradle-settings.sh
+
+# Only update app dependencies
+bash scripts/patch-app-gradle.sh
+```
+
+## Maintenance Benefits
+
+- **Separation of Concerns**: Each script handles one specific aspect
+- **Independent Testing**: Scripts can be tested and debugged individually
+- **Selective Updates**: Only run the scripts that need changes
+- **Clear Documentation**: Each script has a focused purpose
+- **Easier Maintenance**: Changes to one aspect don't affect others