2.Android内核 Binder

 

   Binder,英文的意思是别针、回形针。平常我们经常用回形针把几张纸夹起来。而在Android

中，Binder用于完成进程间通信（IPC），就是把多个线程夹起来。比如，普通应用程序可以

调用音乐播放服务的播放、暂停、停止等功能。

   Binder工作在Linux层面，属于一个驱动，只是这个驱动不需要硬件，或者说Binder操作的硬

件是基于一小段内存。从线程的角度来讲，Binder驱动代码运行在内核态，客户端程序调用Binder

是通过系统调用完成的。

Binder框架

   Binder是一种架构，这种架构提供了服务端接口、Binder驱动、客户端接口三个模块，如下图 ：

   首先来看服务端。一个Binder服务端实际上就是一个Binder类的对象，该对象一旦创建，内部就

启动一个隐藏线程。该线程接下来会接收Binder驱动发送的消息，收到消息后，会执行到Binder对

象中的onTransact()函数，并按照该函数的参数执行不同的服务代码。因此，要实现一个Binder服

务，就必须重载onTransact()方法。

   可以想象，重载onTransact()函数的主要内容是把onTransact()函数的参数转换为服务函数的参数

而onTransact()函数的参数来源是客户端调用transact()函数时输入的，因此，如果transact()有固定

格式的输入，那么onTransact()就会有固定格式的输出。

   那再看Binder驱动。任意一个服务端Binder对象被创建时，同时会在Binder驱动中创建一个mRemote

对象，该对象的类型也是Binder类。客户端访问远程服务时，都是通过mRemote对象。

   最后来看应用程序客户端。客户端要想访问远程服务，必须获取远程服务在Binder对象中对应的mRemote

引用。获取该mRemote对象后，就可以调用其transact()方法，而在Binder驱动中，mRemote对象也重载了

transact()方法，重载的内容包括以下几项：

1.以线程间消息通信的模式，向服务端发送客户端传递过来的参数。

        2.挂起当前线程，当前线程正是客户端线程，并等待服务端线程执行完指定服务函数后通知(notify)。

3.接收服务端线程的通知，然后继续执行客户端线程，并返回到客户端代码区。

   以上可以得出，客户端似乎是直接调用远程服务对应的Binder，而事实上则是通过Binder驱动进行

了中转。即存在两个Binder对象，一个是服务端的Binder对象，另一个则是Binder驱动中的Binder对

象，所不同的是Binder驱动中的对象不会再额外产生一个线程。

   那么，我们来看看Android Binder的源代码：

    /**
     * Default constructor initializes the object.
     */
    public Binder() {
        init();

        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Binder> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Binder class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }
    }

    private native final void init();
    private native final void destroy();

   这两段代码可以看出，在Binder的构造函数中，执行了init()方法。通过JNI的形式调用了底层C

的init()函数，内部就完成了"启动隐藏线程"。 

    /**
     * Default implementation is a stub that returns false.  You will want
     * to override this to do the appropriate unmarshalling of transactions.
     *
     * <p>If you want to call this, call transact().
     */
    protected boolean onTransact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        if (code == INTERFACE_TRANSACTION) {
            reply.writeString(getInterfaceDescriptor());
            return true;
        } else if (code == DUMP_TRANSACTION) {
            ParcelFileDescriptor fd = data.readFileDescriptor();
            String[] args = data.readStringArray();
            if (fd != null) {
                try {
                    dump(fd.getFileDescriptor(), args);
                } finally {
                    try {
                        fd.close();
                    } catch (IOException e) {
                        // swallowed, not propagated back to the caller
                    }
                }
            }
            // Write the StrictMode header.
            if (reply != null) {
                reply.writeNoException();
            } else {
                StrictMode.clearGatheredViolations();
            }
            return true;
        }
        return false;
    }

    /**
     * Default implementation rewinds the parcels and calls onTransact.  On
     * the remote side, transact calls into the binder to do the IPC.
     */
    public final boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        if (false) Log.v("Binder", "Transact: " + code + " to " + this);
        if (data != null) {
            data.setDataPosition(0);
        }
        boolean r = onTransact(code, data, reply, flags);
        if (reply != null) {
            reply.setDataPosition(0);
        }
        return r;
    }

   这两段代码可以看出，onTransact中主要对data进行了处理，即把onTranSact()函数的参数转换

为服务函数的参数；而在transact中调用了onTransact()函数也恰巧说明了：transact()有固定格式的

输入，那么onTransact()就会有固定格式的输出。

简单实现Binder架构

设计Server端

设计Server端实际上非常简单，从代码的角度而言，只要基于Binder类新建一个Server类即可。

MusicPlayerService:

package com.zyy.android_csdn.skill;

import android.os.Binder;
import android.os.Parcel;
import android.os.RemoteException;
import android.util.Log;

/**
 * 
 * 请叫我"Server端"
 * 
 * @author CaMnter
 * 
 */

public class MusicPlayerServiceBinder extends Binder implements
		IMusicPlayerService {

	@Override
	protected boolean onTransact(int code, Parcel data, Parcel reply, int flags)
			throws RemoteException {

		switch (code) {
		case 1000:

			// enforceInterface为了校验 与客户端的writeInterfaceToken()对应
			data.enforceInterface("MusicPlayerService");

			// data 中读取客户端传递的参数
			String filePath = data.readString();

			/*
			 * 如果该IPC调用的客户端期望返回一些结果，则可以在返回包裹reply 中调用Parcel提供的相关函 数写入相应的结果
			 */
			// reply.writeXXX()

			start(filePath);

			break;

		default:
			break;
		}

		return super.onTransact(code, data, reply, flags);

	}

	public void start(String filePath) {

		Log.i("CaMnter", filePath);

	}

	public void stop() {

	}

}

IMusicPlayerService：

package com.zyy.android_csdn.skill;

/**
 * 
 * 请叫我 "MusicPlayerService 标识接口"
 * 
 * @author CaMnter
 * 
 */

public interface IMusicPlayerService {

}

   以上定义了服务类，重载了Binder的onTransact()方法，code变量用于标识客户端期望调用服务端

的哪个函数，因此，双方需要约束一组int值，不同的值代表不同的服务端函数，该值和客户端的transact()

函数中的第一个参数code是一致的。这里假定1000是双方约束要调用start函数的值。

   enforceInterface()是为了某种校验，与客户端的writeInterfaceToken()对应。

   readString()用于从包裹中取出一个字符串。取出filePath变量后，就可以调用服务端的start()函数。

   如果该IPC调用的客户端期望返回一些结果，我们则可以再返回包裹reply中调用Parcel提供的相关函数写入相应的方法

设计Binder 客户端

   要想使用服务端（MusicPlayerServiceBinder）,首先要获取服务端在Binder驱动中对应的

mRemote变量的引用，获取的方法在以后的会讲到，这里我们就 new MusicPlayerServiceBinder()

出来代替mRemote，合情合理的，因为mRemote也同属于IBinder类型。这个不多提，获得这个

mRemote后，就可以调用mRemote的transact()方法，该方法的函数原型就让我们参照一下Binder

的部分源代码吧：

    /**
     * Default implementation rewinds the parcels and calls onTransact.  On
     * the remote side, transact calls into the binder to do the IPC.
     */
    public final boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        if (false) Log.v("Binder", "Transact: " + code + " to " + this);
        if (data != null) {
            data.setDataPosition(0);
        }
        boolean r = onTransact(code, data, reply, flags);
        if (reply != null) {
            reply.setDataPosition(0);
        }
        return r;
    }

   final的"终结"方法。其中data表示要传递给远程Binder的包裹（Parcel），远程服务函数所需要的

参数必须放入这个Parcel data 里。Parcel中只能放入一些特定类型的变量，这些类型有：String、int

、long等，要查看Parcel可以放入的全部数据类型，可以参照一下Parcel类。当然值得一提的是，Parcel

还提供了一个writeParcel()方法，可以再Parcel中包含一个小包裹（Parcel）。因此，要进行Binder远程

服务调用时，服务函数的参数要么是一个原子类，要么必须继承Parcel类。否则，不能传递。

接下来，我做了一个简单的实现，直观上就是客户端调用了mRemote.transact()：

package com.zyy.android_csdn.skill;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;

/**
 * 
 * 请叫我"Binder 客户端"
 * 
 * @author CaMnter
 * 
 */

public class MusicPlayerService extends Service implements IMusicPlayerService {

	private MusicPlayerServiceBinder musicPlayerServiceBinder = new MusicPlayerServiceBinder();

	@Override
	public IBinder onBind(Intent intent) {
		return this.musicPlayerServiceBinder;
	}

	public MusicPlayerService() {

		super();

		this.startTransact();

	}

	public void startTransact() {

		IBinder mRemote = musicPlayerServiceBinder;

		String filePath = "/sdcard/music/helloword.mp3";

		int code = 1000;

		Parcel data = Parcel.obtain();

		Parcel reply = Parcel.obtain();

		data.writeInterfaceToken("MusicPlayerService");

		data.writeString(filePath);

		try {
			
			mRemote.transact(code, data, reply, 0);
			
		} catch (RemoteException e) {
			
			e.printStackTrace();
			
		}

		reply.recycle();

		data.recycle();

	}

}

   以上代码。首先，Parcel类型的data、reply不是客户端自己创建的，而是调用Parcel.obtain()申请

的， 这正如生活中的邮局一样，用户一般只能用邮局提供的信封（EMS）。其中data和reply变量都是

由客户端提供，reply变量用户客户端把返回结果放入其中。

   writeInterfaceToken()方法标注远程服务名称，理论上而言，这个名称不是必需的，因为客户端既然

已经获取指定远程服务的Binder引用（这里我IBinder mRemote = musicPlayerServiceBinder; 来模拟

获取过程），那么就不会调用到其他远程服务。该名称将作为Binder驱动确保客户端的确想调用指定的服

务端。

   writeString()方法用于向Parcel类型中添加一个String变量。注意，Parcel中添加的内容是有序的，这个

顺序必须是客户端和服务端事先约束好的，在服务端onTransact方法中会按照约定的顺序取出变量。

   接着，mRemote.transact(code, data, reply, 0)。调用transact()方法，客户端线程进入了Binder驱动

Binder驱动会挂起当前的线程(客户端线程)，并向远程服务发送一个消息，消息中包含了客户端传来的包裹

（Parcel）。服务端拿到包裹（Parcel）后，会对包裹（Parcel）进行拆解，然后执行指定的服务函数，执

行完毕后，再将执行完毕后的执行结果放入客户端提供的reply包裹（Parcel）中。然后服务端想Binder驱动

发送一个notify的消息，从而使得客户端线程从Binder驱动代码区返回到客户端代码区。

再看：

    /**
     * Default implementation rewinds the parcels and calls onTransact.  On
     * the remote side, transact calls into the binder to do the IPC.
     */
    public final boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        if (false) Log.v("Binder", "Transact: " + code + " to " + this);
        if (data != null) {
            data.setDataPosition(0);
        }
        boolean r = onTransact(code, data, reply, flags);
        if (reply != null) {
            reply.setDataPosition(0);
        }
        return r;
    }

   可以发现transact()方法的最后一个参数是 int flags。这个flags参数的含义是执行IPC调用的模式，分为

两种：一种 0 表示 双向的，其含义表示服务端执行完指定服务后会返回一定的数据；另一张 1 表示 单向的，其

含义是不返回任何数据。

   最后，客户端（我这的是MusicPlayerService）就可以从reply中解析服务端（我这的是MusicPlayerServiceBinder）

返回的数据了，同样，返回包裹中包含的数据也必须是有序的，而且这个顺序也必须是服务端和客户端事先约定好的。

绑定服务，实现Binder架构

BinderActivity:

package com.zyy.android_csdn;

import com.zyy.android_csdn.skill.IMusicPlayerService;

import android.support.v7.app.ActionBarActivity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;

public class BinderActivity extends ActionBarActivity {

	/**
	 * 
	 * onServiceConnected(ComponentName name, IBinder service)中的 service保存为一个全局变量
	 * 
	 * 
	 * 从而在客户端的任何地方都可以随时调用该远程服务 这就解决了第一个重要问题
	 * 
	 * 
	 * 即客户端如何 获取远程服务的Binder引用。
	 * 
	 * 
	 */
	public static IMusicPlayerService iMusicPlayerService;

	private ServiceConnection serviceConnection = new ServiceConnection() {

		@Override
		public void onServiceDisconnected(ComponentName name) {

		}

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {

			/**
			 * 
			 * 保存这个IBinder
			 * 
			 */
			BinderActivity.iMusicPlayerService = (IMusicPlayerService) service;

			Log.i("CaMnter", iMusicPlayerService.getClass().hashCode() + "");

		}
	};

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.adapter);

		new Thread("CaMnterThread") {

			@Override
			public void run() {

				BinderActivity.this
						.bindService(new Intent("com.zyy.MusicPlayerService"),
								BinderActivity.this.serviceConnection,
								BIND_AUTO_CREATE);

			}

		}.start();

	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		getMenuInflater().inflate(R.menu.main, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		int id = item.getItemId();
		if (id == R.id.action_settings) {
			return true;
		}
		return super.onOptionsItemSelected(item);
	}
}

   这里就是用一个ServiceConnection取出了Binder类型然后转成标识接口IMusicPlayerService，接着就是

绑定服务了。

  我们可以看到 "/sdcard/music/helloword.mp3" 证明了一个简单的Binder架构已经实现了。

ServiceConnection里的学问和技巧

   请注意，onServiceConnected()的第二个变量service。当客户端请求AmS（ActivityManagerService）

启动某个服务（Service）后，该服务（Service）如果正常启动，那么Ams（ActivityManagerService）就

会远程调用Ams（ActivityManagerService）就会调用ActivityThread类中的ApplicationThread对象，调用

的参数中会包含服务（Service）的Binder引用，然后ApplicationThread中会回调bindService中的ServiceConnection接口

（这里我的是 BinderActivity.this.serviceConnection）。因此，在客户端中，可以再onServiceConnected()

方法中将第二个变量service保存为一个全局变量（这里我做了 BinderActivity.iMusicPlayerService = (IMusicPlayerService) service;）

从而客户端的任何地方都可以随时调用该远程服务。这就解决了第一个重要问题，就是客户端如何获取远程服务的Binder引用。

   客户端 -> Ams(ActivityManagerService) -> 调用ActivityThread类中的ApplicationThread（参数包含Binder引用）

   -> 回调bindService的ServiceConnection

Binder和AIDL

   关于第二个问题，Android的SDK中提供了一个aidl工具，该工具可以把一个aidl文件转换为一
个Java类文件，在该Java类文件，同时重载了 transact和onTransactO方法，统一 了存入包裹和

读取包裹参数，从而使设计者可以把注意力放到服务代码本身上。

可以首先编写一个IMusicPlayerServiceAIDL.aidl：

package com.zyy.android_csdn.skill;

interface IMusicPlayerServiceAIDL{

	boolean start(String filePath);
	
	void stop();

}

   aidl文件的语法基本类似于Java，package指定输出后的Java文件对应的包名。如果该文件需要引
用其他Java类，则可以使用import关键字，但需要注意的是，包裹（Parcel，这里指的是 String filePath

 属于原子型）内只能写入以下三个类型的内容。

• Java原子类型，如int、long、String等变量。
• Binder 引用。
• 实现了 Parcelable的对象。

   接下来，我们看看该aidl生成的IMusicPlayerService.java文件的代码：

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: D:\\git-camnter\\CaMnter_CSDN\\src\\com\\zyy\\android_csdn\\skill\\IMusicPlayerServiceAIDL.aidl
 */
package com.zyy.android_csdn.skill;

public interface IMusicPlayerServiceAIDL extends android.os.IInterface {
	/** Local-side IPC implementation stub class. */
	public static abstract class Stub extends android.os.Binder implements
			com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL {
		private static final java.lang.String DESCRIPTOR = "com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL";

		/** Construct the stub at attach it to the interface. */
		public Stub() {
			this.attachInterface(this, DESCRIPTOR);
		}

		/**
		 * Cast an IBinder object into an
		 * com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL interface,
		 * generating a proxy if needed.
		 */
		public static com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL asInterface(
				android.os.IBinder obj) {
			if ((obj == null)) {
				return null;
			}
			android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
			if (((iin != null) && (iin instanceof com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL))) {
				return ((com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL) iin);
			}
			return new com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL.Stub.Proxy(
					obj);
		}

		@Override
		public android.os.IBinder asBinder() {
			return this;
		}

		@Override
		public boolean onTransact(int code, android.os.Parcel data,
				android.os.Parcel reply, int flags)
				throws android.os.RemoteException {
			switch (code) {
			case INTERFACE_TRANSACTION: {
				reply.writeString(DESCRIPTOR);
				return true;
			}
			case TRANSACTION_start: {
				data.enforceInterface(DESCRIPTOR);
				java.lang.String _arg0;
				_arg0 = data.readString();
				boolean _result = this.start(_arg0);
				reply.writeNoException();
				reply.writeInt(((_result) ? (1) : (0)));
				return true;
			}
			case TRANSACTION_stop: {
				data.enforceInterface(DESCRIPTOR);
				this.stop();
				reply.writeNoException();
				return true;
			}
			}
			return super.onTransact(code, data, reply, flags);
		}

		private static class Proxy implements
				com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL {
			private android.os.IBinder mRemote;

			Proxy(android.os.IBinder remote) {
				mRemote = remote;
			}

			@Override
			public android.os.IBinder asBinder() {
				return mRemote;
			}

			public java.lang.String getInterfaceDescriptor() {
				return DESCRIPTOR;
			}

			@Override
			public boolean start(java.lang.String filePath)
					throws android.os.RemoteException {
				android.os.Parcel _data = android.os.Parcel.obtain();
				android.os.Parcel _reply = android.os.Parcel.obtain();
				boolean _result;
				try {
					_data.writeInterfaceToken(DESCRIPTOR);
					_data.writeString(filePath);
					mRemote.transact(Stub.TRANSACTION_start, _data, _reply, 0);
					_reply.readException();
					_result = (0 != _reply.readInt());
				} finally {
					_reply.recycle();
					_data.recycle();
				}
				return _result;
			}

			@Override
			public void stop() throws android.os.RemoteException {
				android.os.Parcel _data = android.os.Parcel.obtain();
				android.os.Parcel _reply = android.os.Parcel.obtain();
				try {
					_data.writeInterfaceToken(DESCRIPTOR);
					mRemote.transact(Stub.TRANSACTION_stop, _data, _reply, 0);
					_reply.readException();
				} finally {
					_reply.recycle();
					_data.recycle();
				}
			}
		}

		static final int TRANSACTION_start = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
		static final int TRANSACTION_stop = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
	}

	public boolean start(java.lang.String filePath)
			throws android.os.RemoteException;

	public void stop() throws android.os.RemoteException;
}

以上代码主要完成了三件事：

定义一个Java Interface，内部包含aidl文件所声明的服务函数，类名字为IMusicPlayerServiceAIDL

并且该类基于Ilnterface接口，即需要提供一个asBinder()函数。

定义一个Proxy类，该类将作为客户端程序访问服务端的代理。所谓的代理主要就是为了前面所提到的

第二个重要问题——统一包裹（Parcel）内写入参数的顺序。

定义一个Stub类，这是一个 abstract 类，基于Binder类，并且实现了IMusicPlayerServiceAIDL接口，

主要由服务端来使用。该类之所以要定义为一个abstract类，是因为具体的服务函数必须由程序员实现，因此

，IMusicPlayerServiceAIDL接口里定义的函数在Stub类中可以没有具体的实现。同时，在Stub类中重载了

onTransact()方法，由于transact()方法内部给包裹（Parcel）内写入参数的顺序是由aidl工具定义的，也因此

aidl工具自然知道应该按照何种顺序从包裹（Parcel）中取出相应的参数。

   在Stub类中还定义了一些int常量，比如TRANSACTION_start，这些常量与服务函数对应，transact()
和onTransactO方法的第一个参数code的值即来源于此。

   在Stub类中，除了以上所述的任务外，Stub还提供了一个asInterface()函数。提供这个函数的作用是

这样的：首先需要明确的是，aidl所产生的代码完全可以由应用程序员手工编写，IMusicPlayerServiceAIDL

中的函数只是一种编码习惯而已，aslnterface即如此，提供这个函数的原因是：服务端提供的服务除了其他

进程可以使用外（前者），在服务进程内部的其他类可以使用该服务（后者），对于后者，显然是不需要经

过IPC调用的，而可以直接在进程内部调用的，而Binder内部有一个queryLocallnterface (String description) 

函数，那么，我们顺便来看一看Binder内的这部分关于queryLocallnterface (String description) 的源代码：

   
    /**
     * Use information supplied to attachInterface() to return the
     * associated IInterface if it matches the requested
     * descriptor.
     */
    public IInterface queryLocalInterface(String descriptor) {
        if (mDescriptor.equals(descriptor)) {
            return mOwner;
        }
        return null;
    }

    
    /**
     * Convenience method for associating a specific interface with the Binder.
     * After calling, queryLocalInterface() will be implemented for you
     * to return the given owner IInterface when the corresponding
     * descriptor is requested.
     */
    public void attachInterface(IInterface owner, String descriptor) {
        mOwner = owner;
        mDescriptor = descriptor;
    }

    /* mObject is used by native code, do not remove or rename */
    private long mObject;
    private IInterface mOwner;
    private String mDescriptor;

   以上的三段代码可以看出，queryLocallnterface根据输入的字符串判断该Binder对象时一个本地的Binder

引用。我们再看看如下图所示：

   当创建一个Binder对象时，服务端进程内部创建一个Binder对象，Binder驱动中也会创建一个Binder

对象。如果从远程获取服务端的Binder，则只会返回Binder驱动中的的Binder对象，而如果从服务端内

部获取Binder对象的话，则会获取服务端本身的Binder对象

   再结合aidl生成的asInterface()的源码：

		/**
		 * Cast an IBinder object into an
		 * com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL interface,
		 * generating a proxy if needed.
		 */
		public static com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL asInterface(
				android.os.IBinder obj) {
			if ((obj == null)) {
				return null;
			}
			android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
			if (((iin != null) && (iin instanceof com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL))) {
				return ((com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL) iin);
			}
			return new com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL.Stub.Proxy(
					obj);
		}

   我可以看到这句：android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR)。调用了

queryLocalInterface()方法，asInterface()提供了一个统一的接口。无论是远程客户端还是本地端，当

获取Binder对象后，可以把获取的Binder对象作为asInterface()的参数，从而返回一个IMusicPlayerServicAIDL

接口。又可以从return new com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL.Stub.Proxy(obj）中看

出，该接口要么使用Proxy类，要么直接使用Stub所实现的相应服务函数。

那么问题来了!

    我们经常使用的getSystemService(String serviceName)方法获取一个系统服务，那么这些系统服务的

Binder引用时如何传递给客户端?

请关注我的 3.Android ServiceManager 篇