android USB

最新推荐文章于 2024-08-31 10:57:48 发布

转载最新推荐文章于 2024-08-31 10:57:48 发布 · 565 阅读

安卓同时被 2 个专栏收录

71 篇文章

订阅专栏

Java

66 篇文章

订阅专栏

本文深入解析了Android系统中USB通讯的实现方式，包括USBAccessory和USBHost两种模式的区别，以及如何在不同Android版本中实现USB通讯功能。文章详细介绍了在Android应用中添加USB通讯支持所需的配置步骤，如在manifest文件中添加必要权限、使用广播接收器处理USB设备连接事件，以及如何请求和检查USB设备权限。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

google 在推出API 3.0后就增加啦USB通讯这块

同时为API 2.3提供啦一个USB通讯吧，这样也让2.3有啦USB通讯功能不过只支持USBAccessory模式

USB通讯分为两种模式：（1）附载模式 USBAccessory （2）主机模式 USBHost

什么叫主机模式？

android官方文档解释为 When your Android-powered device is in USB host mode, it acts as the USB host, powers the bus, and enumerates connected USB devices

个人理解为谁提供power 谁就USBHost

打个比方你手上有台音响可以和 android手机进行通讯这里手机为USBAccessory模式

下面为USB的相关代码与流程：

1. 首先需要在manifest中添加一些元素和一些过滤器：

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

如果是2.3时为：

<uses-feature android:name="com.android.future.usb.accessory" />

同时还要在application 中添加USB库 <uses-library android:name="com.android.future.usb.accessory"/>

添加过滤器：

<activity ...>
            ...
            <intent-filter>
                <action android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED" />
            </intent-filter>

            <meta-data android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED"
                android:resource="@xml/accessory_filter" />
        </activity>

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

2 . 获取一个usb管理者：

UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);

2.3 时： UsbManager manager = UsbManager.getInstance(this);

3. 获取 USBAccessory 当我们的设备连接到到另外的一个设备时系统会给我们发送一个系统广播

既我们在 manifest里面注册的当我们接受到这个广播后就可以获取连接的设备

UsbAccessory accessory = (UsbAccessory)intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);

2.3时为：UsbAccessory accessory = UsbManager.getAccessory(intent);

4. 在这个广播中我们获取他的action如果action与UsbManager.EXTRA_ACCESSORY 匹配

我们则开启一个diallog 来提示用户是否来接设备

首先要包装一个pendingintent来实现提示对话框

mPermissionIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(ACTION_USB_PERMISSION), 0);

接着实现

mUsbManager.requestPermission(usbAccessory, mPermissionIntent);

5.当我们按下确定后，我们会在次接到系统广播，来打开通信通道

action与 UsbManager.ACTION_USB_ACCESSORY_ATTACHED 匹配

我们就可以打开通信通道：

注意：通信通道不能在主线程中开启

以下为具体代码：

package hk.com.harbourlight.compones;

import java.io.FileDescriptor;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import com.android.future.usb.UsbAccessory;

import com.android.future.usb.UsbManager;

import android.app.PendingIntent;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.library.Utility;

import android.os.ParcelFileDescriptor;

public class USBController {

// --------------------------------------------------

// ----- enums -----

// --------------------------------------------------

public enum ConnectionState {

Connecting, Connected, Disconnected

}

// --------------------------------------------------

// ----- constants -----

// --------------------------------------------------

public static final String ACTION_CONNECTIONSTATE_CHANGED = "BluetoothControllerConnectionStateChangedAction";

private static final int TIMEOUT_DISCOVERY = 30000;

public final static String ACTION_USB_PERMISSION = "hk.com.harbourlight.USB_PERMISSION";

public final static String ACTION_OPENACCESSORY_FAIL="USBControllerOpenAccessoryFail";

public final static String ACTION_SHOWTOAST="USBControllerShowToast";

// --------------------------------------------------

// ----- properties -----

// --------------------------------------------------

private final Context mContext;

private HarbourLightController mHarbourLightController;

private HarbourLightUpgradeController mHarbourLightUpgradeController;

private ConnectionState mConnectionState;

private Boolean mIsStopped;

private PendingIntent mPendingIntent;

private UsbManager mUsbManager;

private ParcelFileDescriptor mFileDescriptor;

private FileInputStream mInputStream;

private FileOutputStream mOutputStream;

private boolean mIsRequestingPermission;

//---------------------------------------------------

//----- extends --------

//---------------------------------------------------

public USBController(final Context context,final UsbManager usbManager){

this.mContext=context;

this.mUsbManager=usbManager;

mHarbourLightController = new HarbourLightController(mContext, null, null);

mConnectionState = ConnectionState.Disconnected;

mIsStopped = false;

mPendingIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0);

mHarbourLightUpgradeController = new HarbourLightUpgradeController(mContext, null, null);

}

public void start(){

IntentFilter filter = new IntentFilter();

filter.addAction(ACTION_USB_PERMISSION);

filter.addAction(UsbManager.ACTION_USB_ACCESSORY_ATTACHED);

filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);

mContext.registerReceiver(mBroadcastReceiver, filter);

mIsStopped=false;

mIsRequestingPermission=false;

}

public void stop(){

mIsRequestingPermission=false;

mIsStopped=true;

mContext.unregisterReceiver(mBroadcastReceiver);

}

public void disConnect(){

mIsStopped=true;

mHarbourLightController.closeSession();

mConnectionState = ConnectionState.Disconnected;

mContext.sendBroadcast(new Intent(ACTION_CONNECTIONSTATE_CHANGED));

}

public HarbourLightController getHarbourLightController(){

if(mHarbourLightController==null){

mHarbourLightController= new HarbourLightController(mContext, null, null);

}

return mHarbourLightController;

}

public HarbourLightUpgradeController getHarbourLightUpgradeController(){

if(mHarbourLightUpgradeController==null){

mHarbourLightUpgradeController = new HarbourLightUpgradeController(mContext, null, null);

}

return mHarbourLightUpgradeController;

}

public ConnectionState getConnectionState(){

return mConnectionState;

}

public boolean getIsRequrstingPermission(){

return mIsRequestingPermission;

}

public void setIsRequrstingPermission(final boolean isRequrstingPermission){

this.mIsRequestingPermission=isRequrstingPermission;

}

public boolean hasPermission(final UsbAccessory accessory){

return mUsbManager.hasPermission(accessory);

}

public void requestPermission(final UsbAccessory accessory){

synchronized (mBroadcastReceiver) {

mUsbManager.requestPermission(accessory, mPendingIntent);

}

public UsbAccessory[] getUsbAccessories(){

return mUsbManager.getAccessoryList();

}

//---------------------------------------------------

//----processes------

//---------------------------------------------------

public void openAccessory(final UsbAccessory usbAccessory){

try

{

new Thread(){

public void run(){

mFileDescriptor = mUsbManager.openAccessory(usbAccessory);

if (mFileDescriptor != null)

{

FileDescriptor fd = mFileDescriptor.getFileDescriptor();

if(fd!=null){

mInputStream = new FileInputStream(fd);

mOutputStream = new FileOutputStream(fd);

if(mInputStream!=null && mOutputStream!=null){

mHarbourLightController = new HarbourLightController(mContext, mInputStream, mOutputStream);

mContext.sendBroadcast(Utility.creatBroadCastReceiverIntent(USBAccessoryController.ACTION_USB_UPDATEDATA_FILEOUTPUTSTREAM, "open Accessory"));

// mHarbourLightController.openSession();

// mHarbourLightController.handshake();

mContext.sendBroadcast(Utility.creatBroadCastReceiverIntent(HarbourLightController.ACTION_OPENSESSIONSUCCESS, "open Session success"));

mHarbourLightUpgradeController = new HarbourLightUpgradeController(mContext, mInputStream, mOutputStream);

mHarbourLightUpgradeController.openSession();

int timeOut=0;

while (!mIsStopped && timeOut< 10000) {

mContext.sendBroadcast(Utility.creatBroadCastReceiverIntent(ACTION_CONNECTIONSTATE_CHANGED, "wait connect"));

// if (mHarbourLightController.isConnected()) {

if(mHarbourLightUpgradeController.isConnected()){

mConnectionState = ConnectionState.Connected;

mContext.sendBroadcast(Utility.creatBroadCastReceiverIntent(ACTION_CONNECTIONSTATE_CHANGED, "connect"));

return;

}

try

{

Thread.sleep(500);

}

catch (InterruptedException e)

{

e.printStackTrace();

}

timeOut += 500;

}

}else {

mContext.sendBroadcast(new Intent(ACTION_OPENACCESSORY_FAIL));

}

}.start();

}

catch (Exception e)

{

}

private void closeAccessory() {

try {

if (mFileDescriptor != null) {

mFileDescriptor.close();

}

if (mHarbourLightController != null) {

mHarbourLightController.closeSession();

}

if (mInputStream != null) {

mInputStream = null;

}

if (mOutputStream != null) {

mOutputStream = null;

}

mHarbourLightController.closeSession();

disConnect();

setIsRequrstingPermission(false);

mConnectionState=ConnectionState.Disconnected;

mContext.sendBroadcast(new Intent(ACTION_SHOWTOAST));

}

catch (final Exception ex) {

}

//--------------------------------------------------

//--------- BroadcastReceiver --------

//--------------------------------------------------

private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

String action=intent.getAction();

if(action.equalsIgnoreCase(ACTION_USB_PERMISSION)){

synchronized (this) {

UsbAccessory accessory = (UsbAccessory)intent.getParcelableExtra(UsbManager.ACTION_USB_ACCESSORY_ATTACHED);

if(accessory==null){

accessory=getUsbAccessories()[0];

}

if(accessory!=null){

if(hasPermission(accessory)){

mIsStopped=false;

openAccessory(accessory);

}

}else if (action.equalsIgnoreCase(UsbManager.ACTION_USB_ACCESSORY_DETACHED)) {

closeAccessory();

}

};

}