USB模块分析（四）- 设备列表&权限申请

已于 2022-11-18 09:32:13 修改
阅读量1.3k 收藏 5
点赞数 1
分类专栏： 安卓应用开发 安卓系统开发 文章标签： android java 开发语言
于 2022-08-06 09:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanly_jiang/article/details/126168162
版权

getDeviceList

其调用入口位于 UsbManager中：

// frameworks/base/core/java/android/hardware/usb/UsbManager.java

private final IUsbManager mService;
@RequiresFeature(PackageManager.FEATURE_USB_HOST)
public HashMap<String,UsbDevice> getDeviceList() {
    HashMap<String,UsbDevice> result = new HashMap<String,UsbDevice>();
    if (mService == null) {
        return result;
    }
    Bundle bundle = new Bundle();
    try {
        mService.getDeviceList(bundle);
        for (String name : bundle.keySet()) {
            result.put(name, (UsbDevice)bundle.get(name));
        }
        return result;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}

实际上调用的是 IUsbManager的，也就是通过AIDL调用了对应的 UsbService 远端的实现，我们看下UsbService的实现，这里的实现就是调用UsbHostManager的对应的方法向bundle中塞入数据。（frameworks/base/services/usb/java/com/android/server/usb/UsbService.java）的。

// frameworks/base/services/usb/java/com/android/server/usb/UsbService.java
// com.android.server.usb.UsbService#getDeviceList

/* Returns a list of all currently attached USB devices (host mdoe) */
@Override
public void getDeviceList(Bundle devices) {
    if (mHostManager != null) {
        mHostManager.getDeviceList(devices);
    }
}

UsbHostManager#getDeviceList 实现： 就是从成员变量mDevice中取出设备名称，然后塞到返回对象中，所以我们看下mDevice是何时填充的数据。

// frameworks/base/services/usb/java/com/android/server/usb/UsbHostManager.java
// com.android.server.usb.UsbHostManager#getDeviceList

/* Returns a list of all currently attached USB devices */
public void getDeviceList(Bundle devices) {
    synchronized (mLock) {
        for (String name : mDevices.keySet()) {
            devices.putParcelable(name, mDevices.get(name));
        }
    }
}

mDevices 添加数据

可以看到，mDevices 改变的地方位于 usbDeviceAdded 和 usbDeviceRemoved 两个回调方法中。

调用时机：

之前已经有过分析，在UsbService初始化的时候，会添加对于usb设备目录的监听，当有设备添加或者移除时，会调用 usbDeviceAdded 和 usbDeviceRemoved 两个回调方法。

在这里插入图片描述

接下来看下具体实现

usbDeviceAdded

// frameworks/base/services/usb/java/com/android/server/usb/UsbHostManager.java
// com.android.server.usb.UsbHostManager#usbDeviceAdded

private boolean usbDeviceAdded(String deviceAddress, int deviceClass, int deviceSubclass,
        byte[] descriptors) {
    if (isBlackListed(deviceAddress)) {
        return false;
    }
    if (isBlackListed(deviceClass, deviceSubclass)) {
        return false;
    }
    UsbDescriptorParser parser = new UsbDescriptorParser(deviceAddress, descriptors);
    if (deviceClass == UsbConstants.USB_CLASS_PER_INTERFACE
            && !checkUsbInterfacesBlackListed(parser)) {
        return false;
    }
    // Potentially can block as it may read data from the USB device.
    logUsbDevice(parser);
    synchronized (mLock) {
        if (mDevices.get(deviceAddress) != null) {
            Slog.w(TAG, "device already on mDevices list: " + deviceAddress);
            //TODO If this is the same peripheral as is being connected, replace
            // it with the new connection.
            return false;
        }
        UsbDevice.Builder newDeviceBuilder = parser.toAndroidUsbDeviceBuilder();
        if (newDeviceBuilder == null) {
            Slog.e(TAG, "Couldn't create UsbDevice object.");
            // Tracking
            addConnectionRecord(deviceAddress, ConnectionRecord.CONNECT_BADDEVICE,
                    parser.getRawDescriptors());
        } else {
            UsbSerialReader serialNumberReader = new UsbSerialReader(mContext,
                    mPermissionManager, newDeviceBuilder.serialNumber);
            UsbDevice newDevice = newDeviceBuilder.build(serialNumberReader);
            serialNumberReader.setDevice(newDevice);
            mDevices.put(deviceAddress, newDevice);
            Slog.d(TAG, "Added device " + newDevice);
            // It is fine to call this only for the current user as all broadcasts are
            // sent to all profiles of the user and the dialogs should only show once.
            ComponentName usbDeviceConnectionHandler = getUsbDeviceConnectionHandler();
            if (usbDeviceConnectionHandler == null) {
                getCurrentUserSettings().deviceAttached(newDevice);
            } else {
                getCurrentUserSettings().deviceAttachedForFixedHandler(newDevice,
                        usbDeviceConnectionHandler);
            }
            mUsbAlsaManager.usbDeviceAdded(deviceAddress, newDevice, parser);
            // Tracking
            addConnectionRecord(deviceAddress, ConnectionRecord.CONNECT,
                    parser.getRawDescriptors());
            // Stats collection
            FrameworkStatsLog.write(FrameworkStatsLog.USB_DEVICE_ATTACHED,
                    newDevice.getVendorId(), newDevice.getProductId(),
                    parser.hasAudioInterface(), parser.hasHIDInterface(),
                    parser.hasStorageInterface(),
                    FrameworkStatsLog.USB_DEVICE_ATTACHED__STATE__STATE_CONNECTED, 0);
        }
    }
    if (DEBUG) {
        Slog.d(TAG, "beginUsbDeviceAdded(" + deviceAddress + ") end");
    }
    return true;
}

usbDeviceRemoved

private void usbDeviceRemoved(String deviceAddress) {
    if (DEBUG) {
        Slog.d(TAG, "usbDeviceRemoved(" + deviceAddress + ") end");
    }
    synchronized (mLock) {
        UsbDevice device = mDevices.remove(deviceAddress);
        if (device != null) {
            Slog.d(TAG, "Removed device at " + deviceAddress + ": " + device.getProductName());
            mUsbAlsaManager.usbDeviceRemoved(deviceAddress);
            mPermissionManager.usbDeviceRemoved(device);
            getCurrentUserSettings().usbDeviceRemoved(device);
            ConnectionRecord current = mConnected.get(deviceAddress);
            // Tracking
            addConnectionRecord(deviceAddress, ConnectionRecord.DISCONNECT, null);
            if (current != null) {
                UsbDescriptorParser parser = new UsbDescriptorParser(deviceAddress,
                        current.mDescriptors);
                    // Stats collection
                FrameworkStatsLog.write(FrameworkStatsLog.USB_DEVICE_ATTACHED,
                        device.getVendorId(), device.getProductId(), parser.hasAudioInterface(),
                        parser.hasHIDInterface(),  parser.hasStorageInterface(),
                        FrameworkStatsLog.USB_DEVICE_ATTACHED__STATE__STATE_DISCONNECTED,
                        System.currentTimeMillis() - current.mTimestamp);
            }
        } else {
            Slog.d(TAG, "Removed device at " + deviceAddress + " was already gone");
        }
    }
}

权限申请

参考UsbManager的使用部分，我们知道 权限申请的方式是直接调用 UsbManager.requestPermission，然后传递对应的device及permissionPendingIntent。

https://shimo.im/docs/cXjRDCCTrc9xYCwC#anchor-8M36

UsbManager#requestPermission

我们看下实现代码：

// android.hardware.usb.UsbManager#requestPermission(android.hardware.usb.UsbDevice, android.app.PendingIntent)
public void requestPermission(UsbDevice device, PendingIntent pi) {
    try {
        mService.requestDevicePermission(device, mContext.getPackageName(), pi);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}

UsbService#requestDevicePermission

实际上最终也是调用 UsbService 的 对应方法 - requestDevicePermission

//  com.android.server.usb.UsbService#requestDevicePermission
@Override
public void requestDevicePermission(UsbDevice device, String packageName, PendingIntent pi) {
    final int uid = Binder.getCallingUid();
    final int pid = Binder.getCallingPid();
    final int userId = UserHandle.getUserId(uid);
    final long token = Binder.clearCallingIdentity();
    try {
        getPermissionsForUser(userId).requestPermission(device, packageName, pi, pid, uid);
    } finally {
        Binder.restoreCallingIdentity(token);
    }
}

UsbUserPermissionManager

这边通过Binder获取到用户的Uid，Pid等信息，然后交给 UsbPermissionManager 处理：

  1. 如果检测已经有权限，则直接启动pendingIntent 指向的intent
  2. 如果没有权限，则启动 权限申请的 Dialog （实际上是个位于System UI中Dialog风格的 Activity ）
// frameworks/base/services/usb/java/com/android/server/usb/UsbUserPermissionManager.java
// com.android.server.usb.UsbUserPermissionManager#requestPermission(android.hardware.usb.UsbDevice, java.lang.String, android.app.PendingIntent, int, int)

public void requestPermission(UsbDevice device, String packageName, PendingIntent pi, int pid,
        int uid) {
    Intent intent = new Intent();
    // respond immediately if permission has already been granted
    if (hasPermission(device, packageName, pid, uid)) {
        intent.putExtra(UsbManager.EXTRA_DEVICE, device);
        intent.putExtra(UsbManager.EXTRA_PERMISSION_GRANTED, true);
        try {
            pi.send(mContext, 0, intent);
        } catch (PendingIntent.CanceledException e) {
            if (DEBUG) Slog.d(TAG, "requestPermission PendingIntent was cancelled");
        }
        return;
    }
    if (isCameraDevicePresent(device)) {
        if (!isCameraPermissionGranted(packageName, pid, uid)) {
            intent.putExtra(UsbManager.EXTRA_DEVICE, device);
            intent.putExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false);
            try {
                pi.send(mContext, 0, intent);
            } catch (PendingIntent.CanceledException e) {
                if (DEBUG) Slog.d(TAG, "requestPermission PendingIntent was cancelled");
            }
            return;
        }
    }
    requestPermissionDialog(device, null,
            mUsbUserSettingsManager.canBeDefault(device, packageName), packageName, pi, uid);
}

// com.android.server.usb.UsbUserPermissionManager#requestPermissionDialog(android.hardware.usb.UsbDevice, android.hardware.usb.UsbAccessory, boolean, java.lang.String, int, android.content.Context, android.app.PendingIntent)
void requestPermissionDialog(@Nullable UsbDevice device,
        @Nullable UsbAccessory accessory,
        boolean canBeDefault,
        @NonNull String packageName,
        int uid,
        @NonNull Context userContext,
        @NonNull PendingIntent pi) {
    long identity = Binder.clearCallingIdentity();
    Intent intent = new Intent();
    if (device != null) {
        intent.putExtra(UsbManager.EXTRA_DEVICE, device);
    } else {
        intent.putExtra(UsbManager.EXTRA_ACCESSORY, accessory);
    }
    intent.putExtra(Intent.EXTRA_INTENT, pi);
    intent.putExtra(Intent.EXTRA_UID, uid);
    intent.putExtra(UsbManager.EXTRA_CAN_BE_DEFAULT, canBeDefault);
    intent.putExtra(UsbManager.EXTRA_PACKAGE, packageName);
    intent.setComponent(ComponentName.unflattenFromString(userContext.getResources().getString(
            com.android.internal.R.string.config_usbPermissionActivity)));
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    try {
        userContext.startActivityAsUser(intent, mUser);
    } catch (ActivityNotFoundException e) {
        Slog.e(TAG, "unable to start UsbPermissionActivity");
    } finally {
        Binder.restoreCallingIdentity(identity);
    }
}

SystemUI#UsbPermissionActivity

定义声明

前面会启动com.android.internal.R.string.config_usbPermissionActivity 定义的 Activity中，此字符串的定义位于 (./frameworks/base/core/res/res/values/config.xml）

<string name="config_usbPermissionActivity" translatable="false">com.android.systemui/com.android.systemui.usb.UsbPermissionActivity</string>

对应的Activity在 ./frameworks/base/packages/SystemUI/AndroidManifest.xml 中声明，其主题为一个Dialog

        <!-- started from UsbDeviceSettingsManager -->
        <activity android:name=".usb.UsbPermissionActivity"
            android:exported="true"
            android:permission="android.permission.MANAGE_USB"
            android:theme="@style/Theme.SystemUI.Dialog.Alert"
            android:finishOnCloseSystemDialogs="true"
            android:excludeFromRecents="true">

响应

  1. 点击按钮后，会记录是否赋予了权限；
  2. 在销毁时，会设置对应的权限到UsbService，然后启动对应的PendingIntent;
// frameworks/base/packages/SystemUI/src/com/android/systemui/usb/UsbPermissionActivity.java
public void onClick(DialogInterface dialog, int which) {
    if (which == AlertDialog.BUTTON_POSITIVE) {
        mPermissionGranted = true;
    }
    finish();
}

// com.android.systemui.usb.UsbPermissionActivity#onDestroy
@Override
public void onDestroy() {
    IBinder b = ServiceManager.getService(USB_SERVICE);
    IUsbManager service = IUsbManager.Stub.asInterface(b);
    // send response via pending intent
    Intent intent = new Intent();
    try {
        if (mDevice != null) {
            intent.putExtra(UsbManager.EXTRA_DEVICE, mDevice);
            if (mPermissionGranted) {
                service.grantDevicePermission(mDevice, mUid);
                if (mAlwaysUse != null && mAlwaysUse.isChecked()) {
                    final int userId = UserHandle.getUserId(mUid);
                    service.setDevicePackage(mDevice, mPackageName, userId);
                }
            }
        }
        if (mAccessory != null) {
            intent.putExtra(UsbManager.EXTRA_ACCESSORY, mAccessory);
            if (mPermissionGranted) {
                service.grantAccessoryPermission(mAccessory, mUid);
                if (mAlwaysUse != null && mAlwaysUse.isChecked()) {
                    final int userId = UserHandle.getUserId(mUid);
                    service.setAccessoryPackage(mAccessory, mPackageName, userId);
                }
            }
        }
        intent.putExtra(UsbManager.EXTRA_PERMISSION_GRANTED, mPermissionGranted);
        mPendingIntent.send(this, 0, intent);
    } catch (PendingIntent.CanceledException e) {
        Log.w(TAG, "PendingIntent was cancelled");
    } catch (RemoteException e) {
        Log.e(TAG, "IUsbService connection failed", e);
    }
    if (mDisconnectedReceiver != null) {
        unregisterReceiver(mDisconnectedReceiver);
    }
    super.onDestroy();
}
HanlyJiang
关注
专栏目录
Android 系统的安全性分析(6)--Android应用层权限的讨论
Android系统工程师--小馬佩德罗
04-13 803
最近工作上涉及到对Android系统安全性的改造，在改造之前先分析整理下目前Android系统自身的安全性； 参考了一些文章及书籍，在这里大部分是对别人描述的提炼，我挑出一些对我有用的内容整理； 如果你是一个APP开发者，想更深入了解Android权限机制，会对此篇更感兴趣。
Android 获得 usb 权限的两种方式
热门推荐
shihunyewu的博客
09-13 3万+
前言 在做 USB OTG 通信时，第一步就是要能够获取到 usb 的使用权限，因此特地在此处介绍一下两种我用过的获取 usb 权限方式。 1. 直接在 AndroidManifest.xml 中配置 这种配置方式是在 github 上 usb-serial-for-android 项目中看到的，大家如果有兴趣可以 &amp;amp;lt;activity android:name...
遍历USB设备，获取USB序列号
10-31
遍历USB设备，获取USB序列号 别人写的文章 VC
掌握Android USBManager类的完整指南
最新发布
weixin_35972981的博客
08-31 1492
本文还有配套的精品资源，点击获取 简介：USBManager类是Android系统管理USB设备与操作的核心组件，涉及设备识别、权限请求、数据传输、事件监听等。通过USBManager，开发者可以实现设备模式切换、USB权限管理、配置选择、自定义USB驱动程序开发以及支持MIDI和音频设备的管理。本指南详细介绍了USBManager的各个技术要点，并提供了实现USB相关功能...
USB设备分类
小九的专栏
10-26 9224
USB设备分类 USB从设备的分类可以从USB设备接口描述符（Standard   Interface   Descriptor）对应的的bInterfaceClass这一个byte得到。   bInterfaceClass的典型代码为1，2，3，6，7，8，9，10，11，255。分别代表意思为 1－audio：表示一个音频设   备。 2－communication   device：通讯设备，如电话，moden等等。 3－HID：人机交互设备，如键盘，鼠标等。 6－image图象设备，
android usb设备列表,android获取USB设备的名称
weixin_28703489的博客
05-27 1464
1.注释内 。是三星设备可能不支持，需要更换的代码。2.mUsbManager。是getSystemService(Context.USB_SERVICE)获的。3. 从stackoverflow摘过来的。源地址找不到咧。protected static final int STD_USB_REQUEST_GET_DESCRIPTOR = 0x06;// http://libusb.sourcef...
android ubuntu /windows usb device list of devices attach
hello8586的博客
10-15 372
http://bbs.csdn.net/topics/390519827 关于list of devices attach 打开设备驱动详细信息，找到设备的VID，如楼主的图设备VID 是0x12D1 找到 C:\Documents and Settings\Administrator\.android 文件夹下的 adb_usb.ini 信息，打开。在里面添加一行 0x12D1 ，保
遍历 USB devcie，读取设备描述符 device descriptor
flyyyri的专栏
04-13 1万+
理论:    对于USB接口的设备，现在越来越多了。本篇我们就通过获取一个USB扫描仪设备中的序列号，来介绍如何获取usb设备的一些硬件信息。对于usb设备都是采用HCD0,HCD1,HCD2,HCD3等符号描述的。如下图：因此，有了这个名字，我们就可以使用CreateFile来打开usb设备。然后使用DeviceIoControl函数与usb设备通讯了。HCD是host controller
Android 获取 usb 权限的两种方法
08-25
在上面的示例中，我们首先使用 UsbManager 来获取 USB 设备列表，然后遍历设备列表，找到要申请权限的设备。最后，我们使用 PendingIntent 来申请 USB 权限。 Android 获取 usb 权限有两种方法：在 AndroidManifest...
AndroidUSBCamera-master.zip
04-22
开发者在自己的项目中引入UVCCamera库后，首先需要申请USB权限，然后枚举并连接UVC摄像头。接着，通过UVCCamera提供的接口设置预览视图、捕获图像或视频流，并进行实时显示。 6. **优化与调试**： 在实际应用中，...
JAVA获取安卓系统下usb_Android 获取 usb 权限的两种方法
weixin_39888082的博客
02-23 911
前言：最近工作上遇到几个USB模块在android平台上适配使用的情况，所以要用到USB权限获取问题##USB权限获取有以下2种方式：一、直接在AndroidManifest.xml文件中进行如下配置：android:name=".DemoCustomAndroidUSBActivity"android:label="@string/app_name">需要注意的是:其中 device_fi...
AndroidUSB热敏打印机使用动态申请权限绕过系统权限对话框
03-05
AndroidUSB热敏打印机使用动态申请权限绕过系统权限对话框
USB 设备类代码表
SoldierJazz的专栏
02-24 3898
USB Class Codes USB defines class code information that is used to identify a device’s functionality and to nominally load a device driver based on that functionality. The information is contained in
安卓USB模块源码分析（一）- 准备
Hanly Jiang的专栏
08-04 1703
介绍USB服务在Android服务体系中的位置，源码的位置及使用AndroidStudio 查看USB模块FWK的配置方式。
Android 获取USB设备的类型
feelinghappy的专栏
08-30 2543
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/u013686019/article/details/50409421 Version info： Linux: 3.10 Android: 4.2 一、问题 现在有USB设备插入Android系统，那么如何得知插入的设备类型？是USB打...
android申请USB权限
weixin_29669143的博客
07-12 380
Android应用程序如何申请USB权限 介绍 在Android应用程序中，如果要访问USB外设，必须先请求权限才能进行通信。本文将介绍如何在Android应用程序中申请USB权限，并提供相应的代码示例。 USB权限申请流程 在Android中，要访问USB设备，需要经过以下流程： 声明权限：在AndroidManife...
Android 获取Usb设备类型
安卓兼职framework和app工程师的博客
12-22 2676
在进行关于USB设备相关的开发过程中，就会考虑一个问题，在插入USB设备时，会判断这个设备是U盘，鼠标 键盘，usb手写笔，打印设备等等 USB类型规定 而UsbHostManager.java中的usbDeviceAdded()方法，把信息写到UsbDevice.java中，APP部分调用UsbDevice类获取信息 UsbDevices.java类如下: public class UsbDevice implements Parcelable { private final String
Android 获取 USB 设备类型
pytorchCode的博客
08-18 797
接下来，在我们的 Activity 或 Fragment 中，我们需要注册一个 BroadcastReceiver 来接收 USB 设备的连接和断开事件。我们可以通过 Intent.ACTION_UMS_CONNECTED 和 Intent.ACTION_UMS_DISCONNECTED 来监听 USB 设备的连接和断开。为了正确处理不同类型的 USB 设备，我们需要获取 USB 设备的类型信息。根据 USB 设备的类型，我们可以执行不同的操作。根据实际需求，您可以根据不同的设备类型执行相应的逻辑。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值