android挂载usb设备,android usb挂载分析---MountService启动

在android usb挂载分析----vold启动，我们的vold模块已经启动了，通信的机制也已经建立起来了，接下来我们分析一下MountService的启动，也就是我们FrameWork层的启动，首先看下其大概流程：

MountService的启动在SystemServer.java中，有如下代码：

[cpp] view plain copy print ?

try{

/*

* NotificationManagerService is dependant on MountService,

* (for media / usb notifications) so we must start MountService first.

*/

Slog.i(TAG, "Mount Service");

ServiceManager.addService("mount",newMountService(context));

} catch(Throwable e) {

Slog.e(TAG, "Failure starting Mount Service", e);

} 这里new 了一个

MountService，并把service添加到了

ServiceManager,我们看下MountService的构造函数：

[cpp] view plain copy print ?

/**

* Constructs a new MountService instance

*

* @param context  Binder context for this service

*/

publicMountService(Context context) {

mContext = context;

// XXX: This will go away soon in favor of IMountServiceObserver

mPms = (PackageManagerService) ServiceManager.getService("package");//获取包管理服务

mContext.registerReceiver(mBroadcastReceiver,

newIntentFilter(Intent.ACTION_BOOT_COMPLETED), null, null);//注册广播接收器

mHandlerThread = newHandlerThread("MountService");//处理消息

mHandlerThread.start();

mHandler = newMountServiceHandler(mHandlerThread.getLooper());

// Add OBB Action Handler to MountService thread.

mObbActionHandler = newObbActionHandler(mHandlerThread.getLooper());

/*

* Vold does not run in the simulator, so pretend the connector thread

* ran and did its thing.

*/

if("simulator".equals(SystemProperties.get("ro.product.device"))) {

mReady = true;

mUmsEnabling = true;

return;

}

/*

* Create the connection to vold with a maximum queue of twice the

* amount of containers we'd ever expect to have. This keeps an

* "asec list" from blocking a thread repeatedly.

*/

mConnector = newNativeDaemonConnector(this,"vold",

PackageManagerService.MAX_CONTAINERS * 2, VOLD_TAG);

mReady = false;

Thread thread=newThread(mConnector, VOLD_TAG);

thread.start();

} 后面new 了一个NativeDaemonConnector，注意这里传递了一个"vold"字符串，跟我们在vold启动的时候传给CommandListener是一样的。

接下来调用 thread.start()启动线程，我们看下它的run函数

[cpp] view plain copy print ?

publicvoidrun() {

while(true) {

try{

listenToSocket();

} catch(Exception e) {

Slog.e(TAG, "Error in NativeDaemonConnector", e);

SystemClock.sleep(5000);

}

}

} 在循环中调用listenToSocket函数，看下这个函数

[cpp] view plain copy print ?

privatevoidlistenToSocket() throws IOException {

LocalSocket socket = null;

try{

socket = newLocalSocket();

LocalSocketAddress address = newLocalSocketAddress(mSocket,//这里mSocket=“vold"

LocalSocketAddress.Namespace.RESERVED);              //注意这里的RESERVED

socket.connect(address);              //连接到vold模块监听的套接字处

mCallbacks.onDaemonConnected();       //实现在MountService中

InputStream inputStream = socket.getInputStream();

mOutputStream = socket.getOutputStream();

byte[] buffer = newbyte[BUFFER_SIZE];

intstart = 0;

while(true) {

intcount = inputStream.read(buffer, start, BUFFER_SIZE - start);//读取消息

if(count break;

// Add our starting point to the count and reset the start.

count += start;

start = 0;

for(inti = 0; i

if(buffer[i] == 0) {

String event = newString(buffer, start, i - start);

if(LOCAL_LOGD) Slog.d(TAG, String.format("RCV , event));

String[] tokens = event.split(" ");

try{

intcode = Integer.parseInt(tokens[0]);

if(code >= ResponseCode.UnsolicitedInformational) {

try{

if(!mCallbacks.onEvent(code, event, tokens)) {//实现在MountService中

Slog.w(TAG, String.format(

"Unhandled event (%s)", event));

}

} catch(Exception ex) {

Slog.e(TAG, String.format(

"Error handling '%s'", event), ex);

}

}

try{

mResponseQueue.put(event);

} catch(InterruptedException ex) {

Slog.e(TAG, "Failed to put response onto queue", ex);

}

} catch(NumberFormatException nfe) {

Slog.w(TAG, String.format("Bad msg (%s)", event));

}

start = i + 1;

}

}

// We should end at the amount we read. If not, compact then

// buffer and read again.

if(start != count) {

final intremaining = BUFFER_SIZE - start;

System.arraycopy(buffer, start, buffer, 0, remaining);

start = remaining;

} else{

start = 0;

}

}

} catch(IOException ex) {

Slog.e(TAG, "Communications error", ex);

throwex;

} finally {

synchronized (this) {

if(mOutputStream != null) {

try{

mOutputStream.close();

} catch(IOException e) {

Slog.w(TAG, "Failed closing output stream", e);

}

mOutputStream = null;

}

}

try{

if(socket != null) {

socket.close();

}

} catch(IOException ex) {

Slog.w(TAG, "Failed closing socket", ex);

}

}

}

onDaemonConnected的实现在MountServices吕，将向下下发volume list消息 获取到了磁盘的标签，挂载点与状态，调用connect函数连接到vold模块，connetc最终调用native函数connectLocal进行连接工作，我们看下他的jni层代码，最后调用的：

[cpp] view plain copy print ?

intsocket_local_client_connect(intfd,constchar*name,intnamespaceId,

inttype)

{

structsockaddr_un addr;

socklen_t alen;

size_tnamelen;

interr;

err = socket_make_sockaddr_un(name, namespaceId, &addr, &alen);

if(err

gotoerror;

}

if(connect(fd, (structsockaddr *) &addr, alen)

gotoerror;

}

returnfd;

error:

return-1;

}

/**

* connect to peer named "name"

* returns fd or -1 on error

*/

我们再跟进socket_make_sockaddr_un函数，这时namespaceId传的ANDROID_SOCKET_NAMESPACE_RESERVED,所以会执行下面几句：

[cpp] view plain copy print ?

caseANDROID_SOCKET_NAMESPACE_RESERVED:

namelen = strlen(name) + strlen(ANDROID_RESERVED_SOCKET_PREFIX);

/* unix_path_max appears to be missing on linux */

if(namelen >sizeof(*p_addr)

- offsetof(structsockaddr_un, sun_path) - 1) {

gotoerror;

}

strcpy(p_addr->sun_path, ANDROID_RESERVED_SOCKET_PREFIX);  //  ANDROID_RESERVED_SOCKET_PREFIX="/dev/socket/"

strcat(p_addr->sun_path, name);

break;

注意在前面 connect  函数中的套接字的构造，使用了AF_LOCAL：

[cpp] view plain copy print ?

intsocket_local_client(constchar*name,intnamespaceId,inttype)

{

ints;

s = socket("color:#ff0000;">AF_LOCAL, type, 0);

if(s return-1;

if( 0 > socket_local_client_connect(s, name, namespaceId, type)) {

close(s);

return-1;

}

returns;

} 这样，就建立了一条从FrameWork层到vold层的通信链路，后面FrameWork层就等待Vold发送消息过来了。。。FrameWork层的通信也ok了，就可以等待U盘挂载了。。

转自：http://blog.csdn.net/new_abc/article/details/7400740