RokidTelemetryApp.java

// Android app code to access Rokid Max2 telemetry without root
// This would be compiled into an APK and installed

package com.rokid.telemetry;

import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.*;
import android.os.Bundle;
import android.util.Log;
import java.nio.ByteBuffer;
import java.util.HashMap;

public class RokidTelemetryActivity extends Activity {
    private static final String TAG = "RokidTelemetry";
    private static final String ACTION_USB_PERMISSION = "com.rokid.telemetry.USB_PERMISSION";
    
    private static final int ROKID_VID = 0x04D2;
    private static final int ROKID_PID = 0x2002;
    
    private UsbManager usbManager;
    private UsbDevice rokidDevice;
    private UsbDeviceConnection connection;
    private UsbInterface hidInterface;
    private UsbEndpoint hidInEndpoint;
    
    private final BroadcastReceiver usbReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (ACTION_USB_PERMISSION.equals(action)) {
                synchronized (this) {
                    UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                    if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                        if(device != null){
                            connectToDevice(device);
                        }
                    }
                }
            }
        }
    };
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
        registerReceiver(usbReceiver, filter);
        
        findRokidDevice();
    }
    
    private void findRokidDevice() {
        HashMap<String, UsbDevice> deviceList = usbManager.getDeviceList();
        
        for (UsbDevice device : deviceList.values()) {
            if (device.getVendorId() == ROKID_VID && device.getProductId() == ROKID_PID) {
                Log.d(TAG, "Found Rokid Max2!");
                rokidDevice = device;
                
                // Request permission
                PendingIntent permissionIntent = PendingIntent.getBroadcast(
                    this, 0, new Intent(ACTION_USB_PERMISSION), 0);
                usbManager.requestPermission(device, permissionIntent);
                break;
            }
        }
    }
    
    private void connectToDevice(UsbDevice device) {
        connection = usbManager.openDevice(device);
        if (connection == null) {
            Log.e(TAG, "Cannot open device");
            return;
        }
        
        // Find HID interface (interface 2)
        for (int i = 0; i < device.getInterfaceCount(); i++) {
            UsbInterface intf = device.getInterface(i);
            if (intf.getInterfaceClass() == UsbConstants.USB_CLASS_HID) {
                hidInterface = intf;
                Log.d(TAG, "Found HID interface: " + i);
                break;
            }
        }
        
        if (hidInterface == null) {
            Log.e(TAG, "No HID interface found");
            return;
        }
        
        // Claim interface
        if (!connection.claimInterface(hidInterface, true)) {
            Log.e(TAG, "Cannot claim interface");
            return;
        }
        
        // Find IN endpoint
        for (int i = 0; i < hidInterface.getEndpointCount(); i++) {
            UsbEndpoint ep = hidInterface.getEndpoint(i);
            if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_INT &&
                ep.getDirection() == UsbConstants.USB_DIR_IN) {
                hidInEndpoint = ep;
                Log.d(TAG, "Found HID IN endpoint: 0x" + 
                    Integer.toHexString(ep.getAddress()));
                break;
            }
        }
        
        // Start reading sensor data
        startSensorReading();
    }
    
    private void startSensorReading() {
        new Thread(() -> {
            byte[] buffer = new byte[64];
            
            // Try to enable sensors via control transfer
            byte[] enableCmd = new byte[]{0x01, 0x00};
            int ret = connection.controlTransfer(
                0x21,  // Host to device, class, interface
                0x09,  // SET_REPORT
                0x0301, // Feature report, ID 1
                2,     // Interface 2
                enableCmd, enableCmd.length, 1000);
            
            Log.d(TAG, "Enable sensors: " + ret);
            
            // Continuous read loop
            while (true) {
                int transferred = connection.bulkTransfer(
                    hidInEndpoint, buffer, buffer.length, 100);
                
                if (transferred > 0) {
                    parseSensorData(buffer, transferred);
                }
            }
        }).start();
    }
    
    private void parseSensorData(byte[] data, int length) {
        // Parse IMU data based on discovered format
        ByteBuffer bb = ByteBuffer.wrap(data);
        bb.order(ByteOrder.LITTLE_ENDIAN);
        
        if (length >= 24) {
            short accelX = bb.getShort();
            short accelY = bb.getShort();
            short accelZ = bb.getShort();
            short gyroX = bb.getShort();
            short gyroY = bb.getShort();
            short gyroZ = bb.getShort();
            
            Log.d(TAG, String.format("IMU: A[%d,%d,%d] G[%d,%d,%d]",
                accelX, accelY, accelZ, gyroX, gyroY, gyroZ));
            
            // Send to UI or process further
            runOnUiThread(() -> updateSensorDisplay(
                accelX, accelY, accelZ, gyroX, gyroY, gyroZ));
        }
    }
}