Android USB相关流程解析（android4.4）

前言：

对于USB的一些常量属性，比如：UsbManager.
USB_FUNCTION_RNDIS（USB的模式）等，现在也是一个比较模糊的概念，只能具体问题具体分析，我们重点说的是类结构，与USB整个框架（仅限于framework层）的逻辑。本来想画一张流程图呢。画来画去好像都跟实际情况有出入。就只能用文字叙述了。

一、调用：

我们从最常见与USB相关的界面说起。当手机连接电脑时，有如下界面：



这个界面是设置里面的一个界面，源码就不贴了，核心代码

获取 UsbManager类的对象：

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

切换USB连接的模式。比如上图中的，把USB设置为仅充电：

function = UsbManager.USB_FUNCTION_CHARGE_ONLY;
mUsbManager.setCurrentFunction(function, true);

（在android系统源码中的路径：\frameworks\base\core\java\android\hardware\usb\UsbManager.java）
下面我们就围绕这两行代码进行分析。

二、UsbManager 如何获得的

1、首先，android 启动的时候会加载SystemServer.java（路径：\frameworks\base\services\java\com\android\server\SystemServer.java），在SystemServer 类中，调用

initAndLoop()方法加载各种服务，USB相关的核心代码

public void initAndLoop() {
 ......
               UsbService usb = null;
 ......
                try {
                    Slog.i(TAG, "USB Service");
                    // Manage USB host and device support
                    usb = new UsbService(context);
                    ServiceManager.addService(Context.USB_SERVICE, usb);
                } catch (Throwable e) {
                    reportWtf("starting UsbService", e);
                }

.....
}

可以看到SystemServer类中加载的USB相关的服务是 UsbServeice (路径：\frameworks\base\services\java\com\android\server\usb\UsbService.java)

我们这里记着：SystemServer类 中在initAndLoop()方法中，把UsbServeice 加到了 ServiceManager中。

2、其次，我们看ContextImpl.java （路径：\frameworks\base\core\java\android\app\ContextImpl.java）

static{
...
        registerService(USB_SERVICE, new ServiceFetcher() {
                public Object createService(ContextImpl ctx) {
                    IBinder b = ServiceManager.getService(USB_SERVICE);
                    return new UsbManager(ctx, IUsbManager.Stub.asInterface(b));
                }});
...
}

registerService()方法的代码：

private static void registerService(String serviceName, ServiceFetcher fetcher) {
        if (!(fetcher instanceof StaticServiceFetcher)) {
            fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++;
        }
        SYSTEM_SERVICE_MAP.put(serviceName, fetcher);
    }

SYSTEM_SERVICE_MAP 对象

private static final HashMap<String, ServiceFetcher> SYSTEM_SERVICE_MAP =
            new HashMap<String, ServiceFetcher>();

由上我们看到，ContextImpl 类中有一个static 块，从ServiceManager 把usbService取出来，然后注册到ContextImpl类中，其实是放到你个HashMap中。

我们在上文“调用”中执行的代码，

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

这句是在Activity中调用的，而Activity中都有一个关联的ContextImpl 对象，ContextImpl 是对Context的实现类，当在Activity中调用getSystemService（）,其实调用的就是ContextImpl类中的getSystemService（）。 这个ContextImpl 与Activity的关系我就不说了，可以看下源码，或者网上搜索，比如 http://www.cnblogs.com/android100/p/Android-Context.html 中就有相关的说明。

我们看下ContextImpl类中的getSystemService（）

@Override
    public Object getSystemService(String name) {
        ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
        return fetcher == null ? null : fetcher.getService(this);
    }

好吧，其实就是从HashMap中把UsbManager取出来了。

三、UsbManager 的使用

我们先分析下整个USB的类结构了。
首先，我们来一个大体的概念。UsbManager类里面引用了一个UsbService的对象，而UsbService里面又引用了UsbDeviceManager与UsbHostManager的对象，而UsbDeviceManager与UsbHostManager中又分别引用了UsbSettingsManager的对象，而UsbDeviceManager中又引用了UsbDebuggingManager类的对象。大体情况如下图：



这里所说的类的路径都在android 系统源码\frameworks\base\services\java\com\android\server\usb 目录下。

这里插一句：USB分两种模式（这里所说的模式是针对于手机与其所连接的设备所扮演的角色，而我们通篇说的模式是USB选择的功能，如仅充电，PTP,MTP，大容量存储）

usb host 模式：举一例，手机插上键盘之类的外设，手机充当host角色，而UsbHostManager就是跟这个模式相关的，来管理外接设备。

usb Accessory模式：举一例，手机连上电脑，电脑充当host角色，手机是电脑的附件。而UsbDeviceManager就是跟这个模式相关的。而我们通篇都是针对于这种模式来讲解的。

从上图，我们可以清晰的看出类之间的引用关系，接着我回到我们的主题

我们在上文“调用”中执行的代码，

function = UsbManager.USB_FUNCTION_CHARGE_ONLY;
mUsbManager.setCurrentFunction(function, true);

是设置USB为仅充电模式。那么这句调用是如何执行的呢。先看setCurrentFunction()方法

public void setCurrentFunction(String function, boolean makeDefault) {
        try {
            mService.setCurrentFunction(function, makeDefault);
        } catch (RemoteException e) {
            Log.e(TAG, "RemoteException in setCurrentFunction", e);
        }
    }

这里面的mService就是UsbService的对象，看下UsbService中的setCurrentFunction()方法

@Override
    public void setCurrentFunction(String function, boolean makeDefault) {
        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USB, null);
        if (mDeviceManager != null) {
            mDeviceManager.setCurrentFunctions(function, makeDefault);
        } else {
            throw new IllegalStateException("USB device mode not supported");
        }
    }

private UsbDeviceManager mDeviceManager;

其实调用的是UsbDeviceManager 中的setCurrentFunctions()方法

public void setCurrentFunctions(String functions, boolean makeDefault) {
        if (DEBUG) Slog.d(TAG, "setCurrentFunctions(" + functions + ") default: " + makeDefault);
        mHandler.sendMessage(MSG_SET_CURRENT_FUNCTIONS, functions, makeDefault);
    }

这里又通过handler机制发送MSG_SET_CURRENT_FUNCTIONS 消息来处理的。我们看下这个消息的处理

@Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                ......
                case MSG_SET_CURRENT_FUNCTIONS:
                    String functions = (String)msg.obj;
                    boolean makeDefault = (msg.arg1 == 1);
                    setEnabledFunctions(functions, makeDefault);
                    break;
    
            }
        }

setEnabledFunctions（）方法：

private void setEnabledFunctions(String functions, boolean makeDefault) {
            if (DEBUG) Slog.d(TAG, "setEnabledFunctions " + functions
                    + " makeDefault: " + makeDefault);

            // Do not update persystent.sys.usb.config if the device is booted up
            // with OEM specific mode.
            if (functions != null && makeDefault && !needsOemUsbOverride()) {

                if (mAdbEnabled) {
                    functions = addFunction(functions, UsbManager.USB_FUNCTION_ADB);
                } else {
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ADB);
                }
                if (!mDefaultFunctions.equals(functions)) {
                    mInUsbSetting = true;
                    if (!setUsbConfig("none")) {
                        Slog.e(TAG, "Failed to disable USB");
                        // revert to previous configuration if we fail
                        setUsbConfig(mCurrentFunctions);
                        mInUsbSetting = false;
                        return;
                    }
                    // setting this property will also change the current USB state
                    // via a property trigger
                    SystemProperties.set("persist.sys.usb.config", functions);
                    if (waitForState(functions)) {
                        mCurrentFunctions = functions;
                        mDefaultFunctions = functions;
                    } else {
                        Slog.e(TAG, "Failed to switch persistent USB config to " + functions);
                        // revert to previous configuration if we fail
                        SystemProperties.set("persist.sys.usb.config", mDefaultFunctions);
                    }
                    mInUsbSetting = false;
                }
            } else {
                boolean rndisTetherSetting = UsbManager.USB_FUNCTION_RNDIS.equals(functions);
                if (functions == null) {
                    functions = mDefaultFunctions;
                }

                // Override with bootmode specific usb mode if needed
                functions = processOemUsbOverride(functions);

                if (mAdbEnabled) {
                    functions = addFunction(functions, UsbManager.USB_FUNCTION_ADB);
                } else {
                    functions = removeFunction(functions, UsbManager.USB_FUNCTION_ADB);
                }
                if (!mCurrentFunctions.equals(functions) || rndisTetherSetting) {
                    if (rndisTetherSetting && containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_RNDIS)) {
                        functions = mCurrentFunctions;
                    }
                    mInUsbSetting = true;
                    if (!setUsbConfig("none")) {
                        Slog.e(TAG, "Failed to disable USB");
                        // revert to previous configuration if we fail
                        setUsbConfig(mCurrentFunctions);
                        mInUsbSetting = false;
                        return;
                    }
                    if (setUsbConfig(functions)) {
                        mCurrentFunctions = functions;
                    } else {
                        Slog.e(TAG, "Failed to switch USB config to " + functions);
                        // revert to previous configuration if we fail
                        setUsbConfig(mCurrentFunctions);
                    }
                    mInUsbSetting = false;
                }
            }

我们看下三个判断条件：

functions != null：设置的USB功能不为空；而当传如的参数为null的话，就是恢复默认功能。

makeDefault：“如果函数应设置为新的默认功能,makeDefault为true。“根据以上代码，当makeDefault为true的时候，会把mDefaultFunctions这个全局变量改为你这次的设置，这个全局变量的作用是，而当你断开连接时，或者传入参数functions为null的情况下，会用这个全局变量来设置USB功能。

needsOemUsbOverride()：是否用厂商的属性覆盖。

知道了这三个判断条件，就能很清楚的看到其实执行到这里，就是把functions 写入到了系统属性中，推测kernel会监听这个属性，来改变USB功能。

....
SystemProperties.set("persist.sys.usb.config", functions);
.....

private boolean setUsbConfig(String config) {
            if (DEBUG) Slog.d(TAG, "setUsbConfig(" + config + ")");
            // set the new configuration
            SystemProperties.set("sys.usb.config", config);
            return waitForState(config);
        }

好了，从应用层调用，一直追溯到这里，就知道了USB是模式切换是怎么实现的了，其实就是到最后，就是把要设置USB当前的模式写入到系统属性文件中。

四、USB查上电脑或者断开，上层会做些什么。

核心的类就是UsbDeviceManager类了。当插上或者断开USB的时候，这个类会监听底层上报的事件，然后上层根据这个事件来做一系列的动作。至于如何监听的，就是UEventObserver类了，UEventObserver是androidJava层利用uevent与获取Kernel层状态变化的机制，这里我们可以看到使用前必须先初始化一个新的UEventObserver类来处理事件，实现函数onUEvent，这是一个回调函数，之后我们会看到他是怎么被调用的

上代码：

private final UEventObserver mUEventObserver = new UEventObserver() {
        @Override
        public void onUEvent(UEventObserver.UEvent event) {
            if (DEBUG) Slog.v(TAG, "USB UEVENT: " + event.toString());

            String state = event.get("USB_STATE");
            String accessory = event.get("ACCESSORY");
            if (state != null) {
                mHandler.updateState(state);
            } else if ("START".equals(accessory)) {
                if (DEBUG) Slog.d(TAG, "got accessory start");
                startAccessoryMode();
            }
        }
    };

private final class UsbHandler extends Handler {
 ......
      public UsbHandler(Looper looper) {
            super(looper);
            try {
               .....
                mUEventObserver.startObserving(USB_STATE_MATCH);
                mUEventObserver.startObserving(ACCESSORY_START_MATCH);
              .....
            } catch (Exception e) {
                Slog.e(TAG, "Error initializing UsbHandler", e);
            }
        }
}

UsbHandler 是UsbDeviceManager中的一个内部类，设置一个UEventObserver监听Usb连接断开的状态，然后通过Handler机制来让上层做一系列的动作，如：弹出通知栏（Notification）,或者发送UsbManager.ACTION_USB_STATE 的广播等。

接着就要说UEventObserver机制了，上述代码中：

1、调用startObserving()启动,传入的参数是标记事件的，就是一个Key。

mUEventObserver.startObserving(USB_STATE_MATCH);
                mUEventObserver.startObserving(ACCESSORY_START_MATCH);

2、UEventObserver类中的startObserving()方法

public final void startObserving(String match) {
        if (match == null || match.isEmpty()) {
            throw new IllegalArgumentException("match substring must be non-empty");
        }

        final UEventThread t = getThread();
        t.addObserver(match, this);
    }

3、getThread()方法

private static UEventThread getThread() {
        synchronized (UEventObserver.class) {
            if (sThread == null) {
                sThread = new UEventThread();
                sThread.start();
            }
            return sThread;
        }
    }

4、上面getThread就是new了一个UEventThread 对象。看一下UEventThread

private static final class UEventThread extends Thread {
        private final ArrayList<Object> mKeysAndObservers = new ArrayList<Object>();

        private final ArrayList<UEventObserver> mTempObserversToSignal =
                new ArrayList<UEventObserver>();

        public UEventThread() {
            super("UEventObserver");
        }

        @Override
        public void run() {
            nativeSetup();

            while (true) {
                String message = nativeWaitForNextEvent();
                if (message != null) {
                    if (DEBUG) {
                        Log.d(TAG, message);
                    }
                    sendEvent(message);
                }
            }
        }

        private void sendEvent(String message) {
            synchronized (mKeysAndObservers) {
                final int N = mKeysAndObservers.size();
                for (int i = 0; i < N; i += 2) {
                    final String key = (String)mKeysAndObservers.get(i);
                    if (message.contains(key)) {
                        final UEventObserver observer =
                                (UEventObserver)mKeysAndObservers.get(i + 1);
                        mTempObserversToSignal.add(observer);
                    }
                }
            }

            if (!mTempObserversToSignal.isEmpty()) {
                final UEvent event = new UEvent(message);
                final int N = mTempObserversToSignal.size();
                for (int i = 0; i < N; i++) {
                    final UEventObserver observer = mTempObserversToSignal.get(i);
                    observer.onUEvent(event);
                }
                mTempObserversToSignal.clear();
            }
        }

        public void addObserver(String match, UEventObserver observer) {
            synchronized (mKeysAndObservers) {
                mKeysAndObservers.add(match);
                mKeysAndObservers.add(observer);
                nativeAddMatch(match);
            }
        }

        /** Removes every key/value pair where value=observer from mObservers */
        public void removeObserver(UEventObserver observer) {
            synchronized (mKeysAndObservers) {
                for (int i = 0; i < mKeysAndObservers.size(); ) {
                    if (mKeysAndObservers.get(i + 1) == observer) {
                        mKeysAndObservers.remove(i + 1);
                        final String match = (String)mKeysAndObservers.remove(i);
                        nativeRemoveMatch(match);
                    } else {
                        i += 2;
                    }
                }
            }
        }
    }

分析第1、2步，首先获取UEventThread的一个对象，然后启动，之后调用addObserver（）把键值对放入一个集合中。线程启动当然是执行Run()方法了，Run()方法中是一个死循环来等待消息，然后调用 sendEvent(message)发送出去，这个发送就是回调onUEvent(UEvent event)。就是mUEventObserver实现的方法。

Run()方法，调用了两个native方法(JNI)，我们来分析一下：

nativeSetup();
  nativeWaitForNextEvent();

UEventObserver中所有的JNI调用的方法所在的文件是android_os_UEventObserver.cpp

路径：\frameworks\base\core\jni\android_os_UEventObserver.cpp

static void nativeSetup(JNIEnv *env, jclass clazz) {
    if (!uevent_init()) {
        jniThrowException(env, "java/lang/RuntimeException",
                "Unable to open socket for UEventObserver");
    }
}

static jstring nativeWaitForNextEvent(JNIEnv *env, jclass clazz) {
    char buffer[1024];

    for (;;) {
        int length = uevent_next_event(buffer, sizeof(buffer) - 1);
        if (length <= 0) {
            return NULL;
        }
        buffer[length] = '\0';

        ALOGV("Received uevent message: %s", buffer);

        if (isMatch(buffer, length)) {
            // Assume the message is ASCII.
            jchar message[length];
            for (int i = 0; i < length; i++) {
                message[i] = buffer[i];
            }
            return env->NewString(message, length);
        }
    }
}

看到这两个JNI方法的调用，很明显的看出来，nativeSetup();主要调用的是uevent_init() ；而nativeWaitForNextEvent()主要调用的是uevent_next_event()方法，这两个方法是在在uevent.c 中，android_os_UEventObserver.cpp是通过#include "hardware_legacy/uevent.h" 来载入的。路径：\hardware\libhardware_legacy\uevent\uevent.c

int uevent_init()
{
    struct sockaddr_nl addr;
    int sz = 64*1024;
    int s;

    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = getpid();
    addr.nl_groups = 0xffffffff;

    s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
    if(s < 0)
        return 0;

    setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz));

    if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        close(s);
        return 0;
    }

    fd = s;
    return (fd > 0);
}

会创建一个socket ,定义内核事件向用户态通知（NETLINK_KOBJECT_UEVENT），返回返回一个fd

int uevent_next_event(char* buffer, int buffer_length)
{
    while (1) {
        struct pollfd fds;
        int nr;
    
        fds.fd = fd;
        fds.events = POLLIN;
        fds.revents = 0;
        nr = poll(&fds, 1, -1);
     
        if(nr > 0 && (fds.revents & POLLIN)) {
            int count = recv(fd, buffer, buffer_length, 0);
            if (count > 0) {
                struct uevent_handler *h;
                pthread_mutex_lock(&uevent_handler_list_lock);
                LIST_FOREACH(h, &uevent_handler_list, list)
                    h->handler(h->handler_data, buffer, buffer_length);
                pthread_mutex_unlock(&uevent_handler_list_lock);

                return count;
            } 
        }
    }
    
    // won't get here
    return 0;
}

是用Linux poll 机制，等待事件的通知，有数据来的话接收到buffer里，然后返回。（到这一层我已经有些说不明白了，如果说错的话，请指正。）

总结一下：底层通过Poll与socket获取消息，然后到上层android_os_UEventObserver.cpp 类中，然后到UEventObserver中，UEventObserver回调UsbDeviceManager类中mUEventObserver实现的函数onUEvent，然后上层做处理，无论是发通知，或者发广播。

5、编译android源码默认开启USB调试模式

当android源码编译时，会执行\build\tools\post_process_props.py （Python语言）文件来配置属性，有一段代码是这样的：

if prop.get("ro.debuggable") == "1":
    val = prop.get("persist.sys.usb.config")
    if val == "":
      val = "adb"
    else:
      val = val + ",adb"
    prop.put("persist.sys.usb.config", val)

如果ro.debuggable 值为1的话，就在属性里增加adb，就是开启USB调试模式

所以，你可以在你的属性配置文件里配置这个属性为1就行了。

比如我的配置文件prod_xxxxxx.mk中

#Add for adb debug open 
PRODUCT_PROPERTY_OVERRIDES += \
    ro.debuggable=1

到此，USB相关的逻辑部分就分析到这里。