Android usb 配件模式通信示例

当使用 Android 设备作为 USB 配件时，可以使用 Android 提供的 USB Accessory API 来进行 USB 通信。以下是一个简单的 Android USB 配件模式的通信例子。在本例中，我们将接收连接到 Android 设备的 USB 主机发送的数据并向 USB 主机发送响应。

首先，在 AndroidManifest.xml 文件中添加以下权限：

<uses-feature android:name="android.hardware.usb.accessory" />
<uses-permission android:name="android.permission.ACCESSORY" />
<uses-permission android:name="android.permission.WAKE_LOCK" />

接着，在 res/xml 文件夹中创建一个名为 accessory_filter.xml 的文件，用于指定 USB 配件的属性及其应用程序的信息。以下是示例文件的内容：

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <usb-accessory model="Android Accessory" manufacturer="Android" version="1.0" />
</resources>

在 Activity 中，添加以下代码：

private static final String TAG = "USBAccessoryDemo";

private static final String ACTION_USB_PERMISSION = "com.example.android.usbaccessory.USB_PERMISSION";
private static final int TIMEOUT = 1000;
private static final int MAX_PACKET_SIZE = 16384;

private UsbAccessory mAccessory;
private UsbManager mUsbManager;
private PendingIntent mPermissionIntent;
private boolean mPermissionRequestPending;
private UsbAccessoryConnection mAccessoryConnection;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
    mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
    IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
    registerReceiver(mUsbReceiver, filter);

    HashMap<String, UsbAccessory> accessoryList = mUsbManager.getAccessoryList();
    if (accessoryList != null) {
        UsbAccessory accessory = accessoryList.get(0);
        if (accessory != null) {
            if (mUsbManager.hasPermission(accessory)) {
                openAccessory(accessory);
            } else {
                mUsbManager.requestPermission(accessory, mPermissionIntent);
                mPermissionRequestPending = true;
            }
        } else {
            Log.d(TAG, "accessory is null");
        }
    } else {
        Log.d(TAG, "accessoryList is null");
    }
}

@Override
public void onResume() {
    super.onResume();
    if (mAccessoryConnection != null && mAccessoryConnection.isOpen()) {
        mAccessoryConnection.startReading();
    }
}

@Override
public void onPause() {
    super.onPause();
    if (mAccessoryConnection != null && mAccessoryConnection.isOpen()) {
        mAccessoryConnection.stopReading();
    }
}

@Override
protected void onDestroy() {
    super.onDestroy();
    unregisterReceiver(mUsbReceiver);
    if (mAccessoryConnection != null && mAccessoryConnection.isOpen()) {
        mAccessoryConnection.close();
    }
}

private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (ACTION_USB_PERMISSION.equals(action)) {
            synchronized (this) {
                UsbAccessory accessory = (UsbAccessory) intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
                if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                    openAccessory(accessory);
                } else {
                    Log.d(TAG, "permission denied for accessory " + accessory);
                }
                mPermissionRequestPending = false;
            }
        }
    }
};

private void openAccessory(UsbAccessory accessory) {
    mAccessoryConnection = new UsbAccessoryConnection(this, accessory);
    mAccessoryConnection.open();
}

private class UsbAccessoryConnection implements Runnable {
    private final UsbManager mUsbManager;
    private final UsbAccessory mAccessory;
    private ParcelFileDescriptor mConnection;
    private UsbEndpoint mInEndpoint;
    private UsbEndpoint mOutEndpoint;
    private InputStream mInputStream;
    private OutputStream mOutputStream;
    private Thread mReadThread;
    private boolean mIsRunning;

    public UsbAccessoryConnection(Context context, UsbAccessory accessory) {
        mUsbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
        mAccessory = accessory;
    }

    public void open() {
        Connection = mUsbManager.openAccessory(mAccessory);
            if (mConnection != null) {
                FileDescriptor fd = mConnection.getFileDescriptor();
                mInputStream = new FileInputStream(fd);
                mOutputStream = new FileOutputStream(fd);
                mIsRunning = true;
                mReadThread = new Thread(this);
                mReadThread.start();
            } else {
                Log.d(TAG, "openAccessory failed");
            }
    }

    public void close() {
        mIsRunning = false;
        if (mReadThread != null) {
            try {
                mReadThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if (mInputStream != null) {
            try {
                mInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (mOutputStream != null) {
            try {
                mOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (mConnection != null) {
        try {
                mConnection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
    }

    public boolean isOpen() {
        return mConnection != null;
    }

    public void startReading() {
        if (mReadThread != null && !mReadThread.isAlive()) {
            mIsRunning = true;
            mReadThread = new Thread(this);
            mReadThread.start();
        }
    }

    public void stopReading() {
        mIsRunning = false;
    }

    public void write(byte[] data) {
        if (mOutputStream != null) {
            try {
                mOutputStream.write(data);
                mOutputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        byte[] buffer = new byte[MAX_PACKET_SIZE];
        while (mIsRunning) {
            try {
                int len = mInputStream.read(buffer);
                if (len > 0) {
                    final String receivedData = new String(buffer, 0, len);
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            // 处理接收到的数据
                        }
                    });
                }
            } catch (IOException e) {
                e.printStackTrace();
                mIsRunning = false;
            }
        }
    }
}

在上面的代码中，我们首先检查是否已连接 USB 配件。如果已连接，则尝试打开连接。如果没有权限，则请求权限。如果没有可用的 USB 配件，则在日志中记录错误消息。

在打开连接后，我们创建一个 UsbAccessoryConnection 对象，并使用 open() 方法打开连接。在 open() 方法中，我们获取连接的 UsbDeviceConnection 对象，并使用它来获取读取和写入数据的输入/输出流。我们还启动了一个读线程，该线程不断地从输入流中读取数据，并将其传递给主线程以进行处理。

最后，我们可以使用 write() 方法向 USB 主机发送数据，并使用 close() 方法关闭连接。

以上就是Android usb 配件模式下的示例，在实际的开发过程中会比较复杂，但原理基本类似。如果文档对你有帮助，欢迎点赞、收藏和评论，谢谢！