Libusb

[andreknieriem]

• Added Libusb as an alternative usb driver

[gemini-code-assist]

Code Review

This pull request introduces a native USB driver using libusb via JNI to handle USB accessory mode connections, adds a toggle setting to enable it, and implements support for projection on secondary displays. It also improves WiFi Direct auto-start behavior, fixes loading screen replacement issues, and enhances dialog keyboard focus. The code review feedback highlights several critical and high-severity improvement opportunities, including fixing an infinite loop bug in recvBlocking on read errors, optimizing JNI read/write operations to achieve zero-allocation transfers, avoiding hardcoded USB interface IDs, ensuring native resources are released via finalize(), making activeActivityRef volatile for thread safety, and cleaning up old loading screen files to prevent storage leaks.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Refactor recvBlocking to use the pre-allocated buffer and fix a critical infinite loop bug.

Critical Bug Fix: When a fatal read error occurs (native.read returns < 0), we must set isConnectedVal = false so that the connection state is updated. Otherwise, AapReadMultipleMessages.doRead will continuously spin at 100% CPU on a dead connection.

    override fun recvBlocking(buf: ByteArray, length: Int, timeout: Int, readFully: Boolean): Int {
        val native = usbNative ?: return -1
        var totalReturned = 0

        while (totalReturned < length) {
            if (leftoverSize > 0) {
                val available = leftoverSize - leftoverPos
                val toCopy = minOf(length - totalReturned, available)
                System.arraycopy(readBuffer, leftoverPos, buf, totalReturned, toCopy)
                leftoverPos += toCopy
                totalReturned += toCopy

                if (leftoverPos >= leftoverSize) {
                    leftoverSize = 0
                    leftoverPos = 0
                }

                if (totalReturned >= length || !readFully) break
                continue
            }

            val transferred = native.read(readBuffer, timeout)
            if (transferred < 0) {
                isConnectedVal = false
                return if (totalReturned > 0) totalReturned else -1
            }
            if (transferred == 0) {
                return totalReturned
            }

            leftoverSize = transferred
            leftoverPos = 0
        }

        return totalReturned
    }

[gemini-code-assist]

Optimizing JNI read/write operations to avoid memory allocations and array copying in the steady state.

1. nativeWrite: Instead of copying the array in Kotlin using copyOfRange when buf.size != length, we pass the length parameter directly to nativeWrite and use it in libusb_bulk_transfer.
2. nativeRead: Instead of allocating a new native buffer with malloc and a new Java jbyteArray on every single read, we pass a pre-allocated jbyteArray from Kotlin and read directly into it. This completely eliminates GC pressure and native heap fragmentation during high-bandwidth video streaming.

JNIEXPORT jint JNICALL
Java_com_andrerinas_headunitrevived_connection_UsbNative_nativeWrite(JNIEnv *env, jobject thiz, jlong handle_ptr, jbyteArray data, jint length, jint endpoint, jint timeout) {
    libusb_device_handle *handle = (libusb_device_handle *)handle_ptr;
    jsize array_len = (*env)->GetArrayLength(env, data);
    if (length > array_len) {
        length = array_len;
    }
    jbyte *buf = (*env)->GetByteArrayElements(env, data, NULL);
    if (!buf) {
        LOGE("nativeWrite: GetByteArrayElements returned NULL");
        return -2;
    }
    
    int transferred = 0;
    int r = libusb_bulk_transfer(handle, (unsigned char)endpoint, (unsigned char *)buf, length, &transferred, timeout);
    
    (*env)->ReleaseByteArrayElements(env, data, buf, JNI_ABORT);
    if (r < 0) {
        LOGE("libusb_bulk_transfer write failed: %d", r);
        return r;
    }
    return transferred;
}

JNIEXPORT jint JNICALL
Java_com_andrerinas_headunitrevived_connection_UsbNative_nativeRead(JNIEnv *env, jobject thiz, jlong handle_ptr, jbyteArray jbuf, jint endpoint, jint timeout) {
    libusb_device_handle *handle = (libusb_device_handle *)handle_ptr;
    jsize buf_size = (*env)->GetArrayLength(env, jbuf);
    jbyte *buffer = (*env)->GetByteArrayElements(env, jbuf, NULL);
    if (!buffer) {
        LOGE("nativeRead: GetByteArrayElements returned NULL");
        return -2;
    }
    
    int transferred = 0;
    int r = libusb_bulk_transfer(handle, (unsigned char)endpoint, (unsigned char *)buffer, buf_size, &transferred, timeout);
    
    (*env)->ReleaseByteArrayElements(env, jbuf, buffer, 0);
    if (r < 0) {
        if (r != LIBUSB_ERROR_TIMEOUT) {
            LOGE("libusb_bulk_transfer read failed: %d", r);
            return r;
        }
        return 0;
    }
    return transferred;
}

[gemini-code-assist]

Update the write and read helper methods to match the optimized JNI signatures that accept a pre-allocated buffer and a length parameter.

Suggested change

	fun write(data: ByteArray, timeout: Int): Int {
	if (handlePtr == 0L) return -1
	return try {
	nativeWrite(handlePtr, data, epOut, timeout)
	} catch (e: Throwable) {
	AppLog.e("UsbNative: Exception during write: ${e.message}")
	-1
	}
	}
	fun read(timeout: Int): ByteArray? {
	if (handlePtr == 0L) return null
	return try {
	nativeRead(handlePtr, epIn, timeout)
	} catch (e: Throwable) {
	AppLog.e("UsbNative: Exception during read: ${e.message}")
	null
	}
	}
	fun write(data: ByteArray, length: Int, timeout: Int): Int {
	if (handlePtr == 0L) return -1
	return try {
	nativeWrite(handlePtr, data, length, epOut, timeout)
	} catch (e: Throwable) {
	AppLog.e("UsbNative: Exception during write: ${e.message}")
	-1
	}
	}
	fun read(buffer: ByteArray, timeout: Int): Int {
	if (handlePtr == 0L) return -1
	return try {
	nativeRead(handlePtr, buffer, epIn, timeout)
	} catch (e: Throwable) {
	AppLog.e("UsbNative: Exception during read: ${e.message}")
	-1
	}
	}

[gemini-code-assist]

Update the external JNI declarations to support the optimized zero-allocation read and write operations.

Suggested change

	private external fun nativeWrite(handle: Long, data: ByteArray, endpoint: Int, timeout: Int): Int
	private external fun nativeRead(handle: Long, endpoint: Int, timeout: Int): ByteArray?
	private external fun nativeWrite(handle: Long, data: ByteArray, length: Int, endpoint: Int, timeout: Int): Int
	private external fun nativeRead(handle: Long, buffer: ByteArray, endpoint: Int, timeout: Int): Int

[gemini-code-assist]

Pre-allocate a single reusable buffer of 163840 bytes to avoid allocating 160KB on every single read operation.

Suggested change

	// Leftover buffer — serves read data without truncation
	private var leftoverBuffer: ByteArray? = null
	private var leftoverPos = 0
	// Leftover buffer — serves read data without truncation
	private val readBuffer = ByteArray(163840)
	private var leftoverSize = 0
	private var leftoverPos = 0

[gemini-code-assist]

Instead of hardcoding interface ID 0 for detachKernel and claimInterface, pass the actual interface ID from LibusbAccessoryConnection to make the wrapping logic more robust and compatible with devices that might use non-zero interface indices.

    fun wrap(connection: UsbDeviceConnection, interfaceId: Int, epInAddr: Int, epOutAddr: Int): Boolean {
        epIn = epInAddr
        epOut = epOutAddr
        if (contextPtr == 0L) {
            AppLog.e("UsbNative: Cannot wrap device, context is invalid")
            return false
        }
        try {
            handlePtr = wrapDevice(contextPtr, connection.fileDescriptor)
            if (handlePtr == 0L) {
                AppLog.e("UsbNative: wrapDevice returned NULL handle")
                return false
            }
            detachKernel(handlePtr, interfaceId)
            claimInterface(handlePtr, interfaceId)
            AppLog.i("UsbNative: Wrapped device fd=${connection.fileDescriptor} successfully")
            return true
        } catch (e: Throwable) {
            AppLog.e("UsbNative: Exception wrapping device: ${e.message}")
            return false
        }
    }

[gemini-code-assist]

Implement a finalize() method to ensure native resources (libusb context and device handle) are safely closed and released if the UsbNative instance is garbage collected without close() being called explicitly.

    fun close() {
        if (handlePtr != 0L) {
            try {
                closeDevice(handlePtr)
            } catch (e: Throwable) {
                AppLog.e("UsbNative: Exception during closeDevice: ${e.message}")
            }
            handlePtr = 0
        }
        if (contextPtr != 0L) {
            try {
                exitContext(contextPtr)
            } catch (e: Throwable) {
                AppLog.e("UsbNative: Exception during exitContext: ${e.message}")
            }
            contextPtr = 0
        }
    }

    protected fun finalize() {
        if (contextPtr != 0L || handlePtr != 0L) {
            AppLog.w("UsbNative: Native resources were not closed explicitly!")
            close()
        }
    }

[gemini-code-assist]

Pass the actual usbInterface.id to native.wrap instead of hardcoding 0 to support devices with non-zero interface indices.

Suggested change

	val native = UsbNative()
	if (!native.wrap(conn, endpointIn!!.address, endpointOut!!.address)) {
	AppLog.e("LibusbAccessoryConnection: Failed to wrap USB device via JNI")
	native.close()
	conn.releaseInterface(usbInterface)
	conn.close()
	usbDeviceConnection = null
	return@withContext false
	}
	val native = UsbNative()
	if (!native.wrap(conn, usbInterface!!.id, endpointIn!!.address, endpointOut!!.address)) {
	AppLog.e("LibusbAccessoryConnection: Failed to wrap USB device via JNI")
	native.close()
	conn.releaseInterface(usbInterface)
	conn.close()
	usbDeviceConnection = null
	return@withContext false
	}

[gemini-code-assist]

Mark activeActivityRef as @Volatile to ensure thread safety and visibility across threads, as getActiveActivityDisplayId() can be called from background threads (e.g., in AapService or CommManager).

Suggested change

	private var activeActivityRef = java.lang.ref.WeakReference<android.app.Activity>(null)
	@Volatile
	private var activeActivityRef = java.lang.ref.WeakReference<android.app.Activity>(null)

[andreknieriem]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces a native USB driver alternative using libusb to improve device compatibility, adding JNI wrappers, CMake configurations, and a toggle setting. While the integration is well-structured, several critical issues must be addressed: a coarse-grained lock in LibusbAccessoryConnection.connect() over blocking I/O and sleep retries poses an ANR risk; closing the native device while a read is blocked in recvBlocking can trigger a native use-after-free crash (SIGSEGV); and using DirectByteBuffer instead of ByteArray is recommended to optimize high-throughput JNI transfers. Additionally, a duplicate key in SettingsBackupManager should be removed, and the useLibusb setting should be conditionally displayed only on Android Lollipop (API 21) and above to prevent compatibility issues.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Critical Synchronization Issue

Holding synchronized(sStateLock) over the entire connect() method is extremely dangerous because it performs blocking I/O (usbMgr.openDevice) and contains a retry loop with Thread.sleep(1000).

If disconnect() is called from another thread (e.g., the main thread to abort a connection attempt), it will block waiting for sStateLock to be released. This can easily lead to Application Not Responding (ANR) crashes and prevents clean cancellation of pending connection attempts.

Recommendation

Avoid holding a coarse-grained lock over long-running or blocking operations. Instead:

1. Use a Kotlin coroutine-based Mutex for non-blocking synchronization of the connection state.
2. Or, use thread-safe state variables (like AtomicBoolean or @Volatile) and only synchronize brief, critical sections of code.
3. Ensure that disconnect() can run immediately to close any active or pending resources without being blocked by connect().

[gemini-code-assist]

Native Use-After-Free / Race Condition

Calling usbNative?.close() immediately inside disconnect() while the reader thread is actively blocked inside recvBlocking -> native.read(...) will cause a native crash (SIGSEGV).

When usbNative?.close() is called, it executes closeDevice(handlePtr) and exitContext(contextPtr), which frees the underlying libusb structures. If the reader thread is currently executing libusb_bulk_transfer in JNI, it will access freed memory, leading to undefined behavior or an immediate crash.

Recommendation

1. Set isConnectedVal = false first to signal the reader thread to exit.
2. Wait for the reader thread to completely exit (e.g., by joining its thread or coroutine job) before calling usbNative?.close().
3. Ensure that JNI methods are robust against null/zero pointers by adding defensive checks in the C code (e.g., checking if handle is NULL before calling libusb functions).

[gemini-code-assist]

Performance Optimization: Use DirectByteBuffer

Passing a large ByteArray (160KB) to JNI and calling GetByteArrayElements on every read operation introduces significant overhead due to potential array copying and pinning/unpinning by the JVM.

Since this is a high-throughput USB read loop for streaming video/audio, you can drastically improve efficiency and avoid garbage collection pressure by using a Direct ByteBuffer.

Suggested Refactoring

1. Allocate a direct byte buffer in Kotlin:

   private val readBuffer = ByteBuffer.allocateDirect(163840)

2. Update the JNI signature to accept ByteBuffer:

   private external fun nativeRead(handle: Long, buffer: ByteBuffer, endpoint: Int, timeout: Int): Int

3. In C, retrieve the direct buffer address in O(1) time without copying:

   void *buffer = (*env)->GetDirectBufferAddress(env, jbuf);
   jlong capacity = (*env)->GetDirectBufferCapacity(env, jbuf);
   // Use buffer and capacity directly in libusb_bulk_transfer

[gemini-code-assist]

There is a duplicate entry for "bluetooth-manager-service-name" in the backup keys map. This is redundant and can be cleaned up.

        "use-libusb" to ValueType.BOOLEAN,
        "bluetooth-manager-service-name" to ValueType.STRING

[gemini-code-assist]

Since libusb requires Android Lollipop (API 21) or higher (as indicated by the suppressed NDK min SDK error), this setting should only be displayed on supported devices to prevent users on older platforms from enabling a broken feature.

Suggested change

	items.add(SettingItem.ToggleSettingEntry(
	stableId = "useLibusb",
	nameResId = R.string.use_libusb,
	descriptionResId = R.string.use_libusb_description,
	isChecked = pendingUseLibusb!!,
	onCheckedChanged = { isChecked ->
	pendingUseLibusb = isChecked
	checkChanges()
	updateSettingsList()
	}
	))
	if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
	items.add(SettingItem.ToggleSettingEntry(
	stableId = "useLibusb",
	nameResId = R.string.use_libusb,
	descriptionResId = R.string.use_libusb_description,
	isChecked = pendingUseLibusb!!,
	onCheckedChanged = { isChecked ->
	pendingUseLibusb = isChecked
	checkChanges()
	updateSettingsList()
	}
	))
	}