Android启动USB服务源码分析

已于 2023-11-16 09:38:34 修改
阅读量394 收藏 3
点赞数 1
文章标签： android iphone c++ 笔记 linux
于 2023-11-08 10:17:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43767456/article/details/134282398
版权

Android 启动的时候会启动SystemServer进程，在这个服务中启动（注册）USB服务。

启动USB服务

//http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/java/com/android/server/SystemServer.java#2111
       if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)
                      || mPackageManager.hasSystemFeature(
                     PackageManager.FEATURE_USB_ACCESSORY)
                      || isEmulator) {
                  // Manage USB host and device support
                  t.traceBegin("StartUsbService");
// 启动USBService服务   String USB_SERVICE_CLASS ="com.android.server.usb.UsbService$Lifecycle";
                  mSystemServiceManager.startService(USB_SERVICE_CLASS); //启动USB服务
                  t.traceEnd();
              }
​
​

其中mSystemServiceManager 是 SystemServiceManager类的对象。从上面的第9行（2111行）进入到下面

//http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java#110
//className = "com.android.server.usb.UsbService$Lifecycle";
      public SystemService startService(String className) {
             // Java的反射机制，通过类名拿到该类的Class对象
             // 这里拿到的是UsbService$Lifecycle 的对象 ，
              // 这个类定义在http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/usb/java/com/android/server/usb/UsbService.java#79 
         final Class<SystemService> serviceClass = loadClassFromLoader(className,
                 this.getClass().getClassLoader()); 
          return startService(serviceClass);
      }
 // loadClassFromLoader 的定义
//http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java#140
      private static Class<SystemService> loadClassFromLoader(String className,
             ClassLoader classLoader) {
         try {
              return (Class<SystemService>) Class.forName(className, true, classLoader);
         } catch (ClassNotFoundException ex) {
              throw new RuntimeException("Failed to create service " + className
                      + " from class loader " + classLoader.toString() + ": service class not "
                     + "found, usually indicates that the caller should "
                      + "have called PackageManager.hasSystemFeature() to check whether the "
                     + "feature is available on this device before trying to start the "
                     + "services that implement it. Also ensure that the correct path for the "
                      + "classloader is supplied, if applicable.", ex);
          }
      }
​

进入到下面的代码

​//​ http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java#163
​
      public <T extends SystemService> T startService(Class<T> serviceClass) {
          try {
                 //​ 获取类名，这里拿到的name 值 = "com.android.server.usb.UsbService$Lifecycle"
                 //​ 这里仅仅是为了打印日志
             final String name = serviceClass.getName();
              Slog.i(TAG, "Starting " + name);
              Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
​
              // Create the service.
                  //​ 判断 serviceClass 所表示的类是否是 SystemService 的子类
                  //​ 也就是判断UsbService$Lifecycle 是否是 SystemService 的子类
                  //​ 很显然是的，这里不会进if语句
              if (!SystemService.class.isAssignableFrom(serviceClass)) {
                  throw new RuntimeException("Failed to create " + name
                          + ": service must extend " + SystemService.class.getName());
              }
              final T service;
              try {
                      //​ 获取 参数为Context 类 的 构造函数
                Constructor<T> constructor = serviceClass.getConstructor(Context.class);
                      //​ 调用构造创建对象，这里创建了UsbService$Lifecycle的对象
                      //​ 实际上调用  http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/usb/java/com/android/server/usb/UsbService.java#85 
                  service = constructor.newInstance(mContext);
              } catch (InstantiationException ex) {
                 throw new RuntimeException("Failed to create service " + name
                          + ": service could not be instantiated", ex);
              } catch (IllegalAccessException ex) {
                  throw new RuntimeException("Failed to create service " + name
                          + ": service must have a public constructor with a Context argument", ex);
              } catch (NoSuchMethodException ex) {
                  throw new RuntimeException("Failed to create service " + name
                          + ": service must have a public constructor with a Context argument", ex);
              } catch (InvocationTargetException ex) {
                  throw new RuntimeException("Failed to create service " + name
                          + ": service constructor threw an exception", ex);
            }
             startService(service); //​ 接着往下看
              return service;
          } finally {
             Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
         }
      }
​

代码运行到第40 行（192行），进入到下面的方法

//http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/core/java/com/android/server/SystemServiceManager.java#199
​
      public void startService(@NonNull final SystemService service) {
          // Register it.
          mServices.add(service); // 注册服务
          // Start it.
          long time = SystemClock.elapsedRealtime();
          try {
              service.onStart(); //启动服务
          } catch (RuntimeException ex) {
              throw new RuntimeException("Failed to start service " + service.getClass().getName()
                      + ": onStart threw an exception", ex);
          }
          warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
      }

进入启动服务代码：

// http://aospxref.com/android-12.0.0_r3/xref/frameworks/base/services/usb/java/com/android/server/usb/UsbService.java#90
// 这里是USBService 的内部类 Lifecycle 的方法
          public void onStart() {
            // Java的Lamda 表达式 91行到 95行之间 大括号中的代码是一个函数
            // SystemServerInitThreadPool.submit 是将Lamda 表达是加入线程池
              SystemServerInitThreadPool.submit(() -> {
                  mUsbService = new UsbService(getContext());
                  publishBinderService(Context.USB_SERVICE, mUsbService);
                  mOnStartFinished.complete(null);
              }, "UsbService$Lifecycle#onStart");
          }

上面的代码创建了一个线程。这个线程的代码如下：

                  mUsbService = new UsbService(getContext());
                  publishBinderService(Context.USB_SERVICE, mUsbService);
                  mOnStartFinished.complete(null);

接下来我们看一下UsbService 的构造函数做了什么。

// http://aosp.opersys.com/xref/android-12.0.0_r2/xref/frameworks/base/services/usb/java/com/android/server/usb/UsbService.java#165
    public UsbService(Context context) {
        mContext = context;

        mUserManager = context.getSystemService(UserManager.class);
        mSettingsManager = new UsbSettingsManager(context, this);
        mPermissionManager = new UsbPermissionManager(context, this);
        mAlsaManager = new UsbAlsaManager(context);

        final PackageManager pm = mContext.getPackageManager();
        if (pm.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {
            mHostManager = new UsbHostManager(context, mAlsaManager, mPermissionManager);
        }
        if (new File("/sys/class/android_usb").exists()) {
               //  这里创建 DeviceManager对象
            mDeviceManager = new UsbDeviceManager(context, mAlsaManager, mSettingsManager,
                    mPermissionManager);
        }
        if (mHostManager != null || mDeviceManager != null) {
            mPortManager = new UsbPortManager(context);
        }

        onSwitchUser(UserHandle.USER_SYSTEM);
        // 接收到广播 调用 OnReceive
        BroadcastReceiver receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                final String action = intent.getAction();
                if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED
                        .equals(action)) {
                    if (mDeviceManager != null) {
                        mDeviceManager.updateUserRestrictions();
                    }
                }
            }
        };
        // 注册广播
        final IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
        mContext.registerReceiverAsUser(receiver, UserHandle.ALL, filter, null, null);
    }

以手机作为 device 端 ，看一下UsbDeviceManager 的构造都干了哪些事。

// http://aosp.opersys.com/xref/android-12.0.0_r2/xref/frameworks/base/services/usb/java/com/android/server/usb/UsbDeviceManager.java#281
    public UsbDeviceManager(Context context, UsbAlsaManager alsaManager,
            UsbSettingsManager settingsManager, UsbPermissionManager permissionManager) {
        mContext = context;
        mContentResolver = context.getContentResolver();
        PackageManager pm = mContext.getPackageManager();
        mHasUsbAccessory = pm.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY);
        initRndisAddress();

        boolean halNotPresent = false;
        try {
            IUsbGadget.getService(true);
        } catch (RemoteException e) {
            Slog.e(TAG, "USB GADGET HAL present but exception thrown", e);
        } catch (NoSuchElementException e) {
            halNotPresent = true;
            Slog.i(TAG, "USB GADGET HAL not present in the device", e);
        }

        mControlFds = new HashMap<>();
        FileDescriptor mtpFd = nativeOpenControl(UsbManager.USB_FUNCTION_MTP);
        if (mtpFd == null) {
            Slog.e(TAG, "Failed to open control for mtp");
        }
        mControlFds.put(UsbManager.FUNCTION_MTP, mtpFd);
        FileDescriptor ptpFd = nativeOpenControl(UsbManager.USB_FUNCTION_PTP);
        if (ptpFd == null) {
            Slog.e(TAG, "Failed to open control for ptp");
        }
        mControlFds.put(UsbManager.FUNCTION_PTP, ptpFd);
        // 初始化mHandler对象
        if (halNotPresent) {
            /**
             * Initialze the legacy UsbHandler
             */
            mHandler = new UsbHandlerLegacy(FgThread.get().getLooper(), mContext, this,
                    alsaManager, permissionManager);
        } else {
            /**
             * Initialize HAL based UsbHandler
             */
            mHandler = new UsbHandlerHal(FgThread.get().getLooper(), mContext, this,
                    alsaManager, permissionManager);
        }

        if (nativeIsStartRequested()) {
            if (DEBUG) Slog.d(TAG, "accessory attached at boot");
            startAccessoryMode();
        }
      
        BroadcastReceiver portReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                ParcelableUsbPort port = intent.getParcelableExtra(UsbManager.EXTRA_PORT);
                UsbPortStatus status = intent.getParcelableExtra(UsbManager.EXTRA_PORT_STATUS);
                mHandler.updateHostState(
                        port.getUsbPort(context.getSystemService(UsbManager.class)), status);
            }
        };

        BroadcastReceiver chargingReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                int chargePlug = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
                boolean usbCharging = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
                mHandler.sendMessage(MSG_UPDATE_CHARGING_STATE, usbCharging);
            }
        };

        BroadcastReceiver hostReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                Iterator devices = ((UsbManager) context.getSystemService(Context.USB_SERVICE))
                        .getDeviceList().entrySet().iterator();
                if (intent.getAction().equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
                    mHandler.sendMessage(MSG_UPDATE_HOST_STATE, devices, true);
                } else {
                    mHandler.sendMessage(MSG_UPDATE_HOST_STATE, devices, false);
                }
            }
        };

        BroadcastReceiver languageChangedReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                mHandler.sendEmptyMessage(MSG_LOCALE_CHANGED);
            }
        };
  // 注册广播
        mContext.registerReceiver(portReceiver,
                new IntentFilter(UsbManager.ACTION_USB_PORT_CHANGED));
        mContext.registerReceiver(chargingReceiver,
                new IntentFilter(Intent.ACTION_BATTERY_CHANGED));

        IntentFilter filter =
                new IntentFilter(UsbManager.ACTION_USB_DEVICE_ATTACHED);
        filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
        mContext.registerReceiver(hostReceiver, filter);

        mContext.registerReceiver(languageChangedReceiver,
                new IntentFilter(Intent.ACTION_LOCALE_CHANGED));
// 通过Linux Uevent机制监听USB状态变换
        // Watch for USB configuration changes
        mUEventObserver = new UsbUEventObserver();
        mUEventObserver.startObserving(USB_STATE_MATCH);
        mUEventObserver.startObserving(ACCESSORY_START_MATCH);
    }

UsbDeviceManager的构造函数做了三件事。

第一件事，初始化mHandler对象。mHandler的初始化使用的是UsbHandlerLegacy对象或者是UsbHandlerHal取决于是否有该模式的hal层支持。

第二事，注册了各种广播接收器，例如端口变化，语言变化，等等。这里我把关于充电的广播接收器代码展示出来了。当我们把手机通过USB线连接到电脑端的时候，手机会充电，并且手机上会出现一个关于USB充电的通知。打开这个关于USB的通知，我们就可以切换USB的功能，例如MTP, PTP，等等。

第三件事，通过Linux Uevent机制监听USB状态变换。当手机通过USB线连接电脑时，USB状态会从DISCONNECTED变为CONNECTED，再变为CONFIGURED。当状态改变会处理usb状态更新操作。

看一下UsbHandlerLegacy 对象的创建。

// http://aosp.opersys.com/xref/android-12.0.0_r2/xref/frameworks/base/services/usb/java/com/android/server/usb/UsbDeviceManager.java#1480
​
        UsbHandlerLegacy(Looper looper, Context context, UsbDeviceManager deviceManager,
                UsbAlsaManager alsaManager, UsbPermissionManager permissionManager) {
            super(looper, context, deviceManager, alsaManager, permissionManager);
            try {
                    //  1. 读取oem覆盖配置
                readOemUsbOverrideConfig(context);
                // Restore default functions.
                    // 读取 属性的 值 
                    // getSystemProperty  这个函数用于读取 系统属性的值 
                    // 它有两个参数 参数1 ： 属性名称， 参数 2 ： 默认返回的值
                    // 返回 属性的 值
                    
                    //  读取的是persist.sys.usb.config属性的值
               mCurrentOemFunctions = getSystemProperty(getPersistProp(false),
                        UsbManager.USB_FUNCTION_NONE);
                    // ro.bootmode属性的值为normal或unknown，就表示正常启动
               if (isNormalBoot()) {
                        // 读取sys.usb.config属性的值，这个属性表示当前设置的usb功能
                    mCurrentFunctionsStr = getSystemProperty(USB_CONFIG_PROPERTY,
                           UsbManager.USB_FUNCTION_NONE);
                        // 比较sys.usb.config属性与sys.usb.state属性的值
                        // sys.usb.state属性表示usb的实际功能
                 // 如果两个属性相等，表示usb设置的功能都起效了
                   mCurrentFunctionsApplied = mCurrentFunctionsStr.equals(
                           getSystemProperty(USB_STATE_PROPERTY, UsbManager.USB_FUNCTION_NONE));
               } else {
                   mCurrentFunctionsStr = getSystemProperty(getPersistProp(true),
                           UsbManager.USB_FUNCTION_NONE);
                    mCurrentFunctionsApplied = getSystemProperty(USB_CONFIG_PROPERTY,
                            UsbManager.USB_FUNCTION_NONE).equals(
                           getSystemProperty(USB_STATE_PROPERTY, UsbManager.USB_FUNCTION_NONE));
              }
                   //  mCurrentFunctions代表当前要设置的usb功能，初始值为0
                    mCurrentFunctions = UsbManager.FUNCTION_NONE;
                    mCurrentUsbFunctionsReceived = true;
​
               mUsbSpeed = UsbSpeed.UNKNOWN;
               mCurrentGadgetHalVersion = UsbManager.GADGET_HAL_NOT_SUPPORTED;
                   
                //  读取一次usb状态，然后做一次更新操作
                String state = FileUtils.readTextFile(new File(STATE_PATH), 0, null).trim();
               updateState(state);
           } catch (Exception e) {
               Slog.e(TAG, "Error initializing UsbHandler", e);
           }
        }
麦子zzy
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Android USB通信源码/DEMO
01-08
Android USB通信源码/DEMO 说明：https://blog.csdn.net/lxt1292352578/article/details/131976810 github：https://github.com/LXTTTTTT/USBtoSerialPortDemo 连接流程： 获取当前系统可用的 USB 设备列表 → 选中对应的USB设备并申请权限（首次）→ 获取设备端口（通常只有一个）→ 按照特定参数打开端口
android usb相关知识总结
hailushijie的专栏
04-18 4681
转载请注明出处：http://blog.csdn.net/droyon/article/details/45098027 1、android背景介绍 UsbService，在系统启动时创建，在该文件中，和usb状态息息相关的操作类是UsbDeviceManager，大部分的usb以及adb相关的逻辑，在这个类中做处理。UsbDeviceManager中，我们需要关注三部分内容。一、配置文件。二、  UEventObserver 监听。
Android USB相关流程解析（android4.4）
daweibalang717的专栏
12-24 8464
前言： 对于USB的一些常量属性，比如：UsbManager. USB_FUNCTION_RNDIS等，现在也是一个比较模糊的概念，只能具体问题具体分析，我们重点说的是类结构，与USB整个框架（仅限于framework层）的逻辑。本来想画一张流程图呢。画来画去好像都跟实际情况有出入。就只能用文字叙述了。 一、调用： 我们从最常见与USB相关的界面说起。当手机连接电脑时，有如下界面：
安卓USB模块源码分析（一）- 准备
Hanly Jiang的专栏
08-04 1605
介绍USB服务在Android服务体系中的位置，源码的位置及使用AndroidStudio 查看USB模块FWK的配置方式。
Android10 USB devices mode 分析
weixin_42196034的博客
03-30 2311
USB platform/build / tools/post_process_props.py在此设置默认的usb配置,在编译的时候makefile会将其编译到系统中 将默认的配置保存在UsbDeviceManagerPrefs.xml中(路径没找到) usb中重要的属性persist.sys.usb.config和 sys.usb.config, system/core/rootdir...
Android USB识别开发
小旭的专栏
05-18 3514
该方法目前也存在缺陷，如果有多个文件夹挂载到该目录，就会出现识别错误情况，所以该方案的前提需要该目录（"/mnt/xiaoxu_rw/"）只挂载 U 盘，或者在知道其他固定挂载目录时进行判断剔除（U 盘路径不固定，无法直接判断）。通过3）和4）可以看出，内置SD卡的插入或拔出，会影响外置U盘的识别。对于上面两种方法，在需要拿到 U 盘路径，又不支持方法二的情况下，在我们知道 U 盘挂载路径的情况下，可以通过下面的方法实现。先插入内置SD卡，再插入外置U盘，返回true，在拔出内置SD卡，返回false；
Android 开机启动模式源码分析
05-10
### Android 开机启动模式源码分析 #### 一、引言 随着移动互联网技术的快速发展，Android操作系统作为当今最流行的移动设备...希望本文能够帮助开发者更好地理解Android启动流程，为进一步的技术探索打下坚实的基础。
Android 如何启用user版本的adb源码分析
最新发布
05-10
### Android如何启用User版本的ADB源码分析 #### 一、ADB概述与配置解析 ADB（Android Debug Bridge）是Android平台下的一种工具，主要用于设备调试。它提供了多种功能，包括安装应用、运行shell命令以及管理进程...
Android 2.1 源码结构分析
04-03
### Android 2.1 源码结构分析 在深入探讨Android 2.1源码结构之前，我们先简要回顾一下Android系统的基本概念。Android操作系统是由Google公司于2007年11月5日宣布建立的一个基于Linux内核的操作系统平台。它主要...
ADB源码（android / platform / system / core）
04-28
1. 开启ADB服务：在Host端启动adb_server，监听特定端口（默认5037）等待客户端连接。 2. 设备连接：当Android设备通过USB或Wi-Fi连接到Host时，ADB识别并建立连接。 3. 设备枚举：ADB服务器会自动发现连接的设备，...
Android高级应用源码-exarusbdriver.zip
10-14
通过对"exarusbdriver.zip"的源码分析，开发者不仅可以深入了解Android USB驱动的实现细节，还可以学习到如何优化USB通信性能，以及如何编写和调试驱动程序。这对于从事Android系统定制、硬件适配或者外设开发的...
USBService源码分析（一）
Flying snow
01-24 1970
1、概述
Android Usb（OTG）串口通信，Service 后台服务实现方式
MSONG93的博客
05-17 4165
库 里面有例子，但发现里面有两个比较大的问题，第一个就是 插入的时候要直接启动 主界面，哪怕在程序里面时候，也需要重新进入。这是一个支持 USB 转串口通信的 Android 库，可以连接到 FTDI、PL2303 等 USB 转串口芯片，并且提供了非常详细的文档和示例代码。这是一个非常流行的 Android 串口通信库，支持多种设备和多种波特率，并且提供了非常详细的文档和示例代码。通过Actitity 启动ConnectService即可！以上三个库都是开源的，可以在 GitHub 上获取源码和文档。
android9.0 UsbService源码解析
NEY10MAR的博客
03-21 4768
android USBService源码解析
Android 10 USB用途切换失败分析
这个人很懒，什么都没留下...
02-20 1527
最近处理一个USB的问题，偶现，现象如下：快速切换USB的用途，会导致切换失败，最后变为不进行数据传输状态。首先按照惯例，得先把切换USB的流程梳理清楚，当前界面的UI在
【Android系统源码修改】默认开启adb模式(USB调试)
Bright的博客
07-06 1万+
针对MT6735m平台： 找到\frameworks\base\services\usb\java\com\android\server\usb\UsbDeviceManager.java下的 Settings.Global.putInt(mContentResolver, Settings.Global.ADB_ENABLED, mAdbEnabled ? 1 : 0); 改为： Settin...
用Android代码实现自动打开USB调试
01-29 598
在 packages/apps/Settings/src/com/android/settings/DevelopmentSettings.java 找到关于 USB Debug Enable 的代码： [java] view plaincopy Settings.Secure.putInt(getContentResolver(), Settings.Secure...
Android USB通信弹出权限确认框
热门推荐
Chaos的专栏
11-18 1万+
介绍 Android usb通信有两种模式：Host和Accessory；二者差异之处在于Host模式下，Android设备供电给usb设备；Accessory模式下usb设备供电给Android设备;官方示意图如下： 获取权限原理
Android下USB Accessory的实现分析 （三）--- Android Open AccessoryProtocol
|~~~热爱生活、努力学习的小伙汁~~~|
06-24 4276
本文 接着前面的文章 《Android下USB Accessory的实现分析 （二）— 底层驱动设计实现》 2.1.4 Android Open AccessoryProtocol 为了支持USB Accessory，让USB主从设备双方能够互相识别和兼容对方，Google定义了一套Android OpenAccessory Protocol（简称AOA）， 此协议目前有两个版本：Version...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

麦子zzy

谢谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值