1. 概述
當初決定分享內(nèi)涵段子的這個項目我有些擔心，擔心很多東西心里雖然有了輪廓和細節(jié)。但是如果涉及到的東西比較多，那么就有可能沒辦法去講太多的細節(jié)，況且某些哥們還不會C和C++，所以如果的確覺得IPC這方面比較難可以多去找找這方面的文章看看。這里我們就從三個方面去講解：
1.1：進程間通信的一個小事例；
1.2：應(yīng)用層的具體流程分析；
1.3：google源碼層的具體走向；
所有分享大綱：2017Android進階之路與你同行
視頻講解地址：http://pan.baidu.com/s/1pLrvFj9
2. 進程間通信的一個小事例
為什么會出現(xiàn)IPC這個概念，Android操作系統(tǒng)為了確保進程之間不會產(chǎn)生相互干擾，就是為了你掛了不會影響我，所以采用了進程隔離的機制，即為每個進程分配獨立虛擬地址空間，進程之間感覺不到彼此的存在，感覺自己仿佛占用整個內(nèi)存空間。這樣保證了進程的數(shù)據(jù)安全，但是必然存在另外的問題，那就是進程間通信，進程不可能完全獨立運行，有時候需要相互通信獲取別的進程的運行結(jié)果等，因此需要想辦法解決進程間通信的問題，所以就出現(xiàn)了IPC這個概念。其他就不說了，假設(shè)我A應(yīng)用要去B里面應(yīng)用獲取的數(shù)據(jù)該怎么辦，接下來我們就寫這么一個實例，這里就涉及到兩個單獨的應(yīng)用，我們就把A應(yīng)用作為客戶端，B應(yīng)用作為服務(wù)端。
2.1 應(yīng)用服務(wù)端：
// 編寫aidl文件
interface UserCalcAIDL {
String getUserName();
String getUserPassword();
}
上面是編寫aidl文件，類似于interface，這里我就不介紹aidl了，到后面再去介紹。然后我們在項目中新建一個服務(wù)Service，代碼如下：
public class UserService extends Service{
private static final String TAG = "server";
// 應(yīng)用間通信進行綁定
public IBinder onBind(Intent t)
{
Log.e(TAG, "onBind");
return mBinder;
}
// 應(yīng)用間解綁
public boolean onUnbind(Intent intent)
{
Log.e(TAG, "onUnbind");
return super.onUnbind(intent);
}
// mBinder 的實例
private final UserCalcAIDL.Stub mBinder = new UserCalcAIDL.Stub()
{
@Override
public String getUserName() throws RemoteException {
return "Darren@163.com";
}
@Override
public String getUserPasword() throws RemoteException {
return "940223";
}
};
}
最后我們在AndroidManifest中注冊配置Service，然后在主Activity中運行該服務(wù)，那么服務(wù)端代碼就算告成了。
<service android:name="com.example.study.aidl.UserService" >
<intent-filter>
<action android:name="com.study.aidl.user" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>
2.2 應(yīng)用客戶端：
另外再建一個工程，創(chuàng)建與服務(wù)端同樣的aidl，然后再創(chuàng)建一個布局，里面包含4個按鈕，分別為綁定服務(wù)，解除綁定，獲取用戶名，獲取用戶密碼。布局代碼我就不貼了，直接上Activity里面的代碼：
public class MainActivity extends Activity{
private UserCalcAIDL mCalcAidl;
private ServiceConnection mServiceConn = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e("client", "onServiceDisconnected");
mCalcAidl = null;
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.e("client", "onServiceConnected");
mCalcAidl = UserCalcAIDL.Stub.asInterface(service);
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
/**
* 點擊BindService按鈕時調(diào)用
* @param view
*/
public void bindService(View view) {
Intent intent = new Intent();
intent.setAction("com.study.aidl.user");
// 在Android 5.0之后google出于安全的角度禁止了隱式聲明Intent來啟動Service.也禁止使用Intent filter.否則就會拋個異常出來
intent.setPackage("com.study.aidl");
bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE);
}
/**
* 點擊unBindService按鈕時調(diào)用
* @param view
*/
public void unbindService(View view) {
if(mCalcAidl != null){
unbindService(mServiceConn);
}
}
/**
* 獲取用戶密碼
* @param view
*/
public void getUserPassword(View view) throws Exception {
if (mCalcAidl != null) {
String userPassword = mCalcAidl.getUserPasword();
Toast.makeText(this, "用戶密碼："+userPassword, Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(this, "服務(wù)器未綁定或被異常殺死，請重新綁定服務(wù)端", Toast.LENGTH_SHORT)
.show();
}
}
/**
* 獲取用戶名
* @param view
*/
public void getUserName(View view) throws Exception {
if (mCalcAidl != null) {
String userName = mCalcAidl.getUserName();
Toast.makeText(this, "用戶名："+userName, Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(this, "服務(wù)器未綁定或被異常殺死，請重新綁定服務(wù)端", Toast.LENGTH_SHORT)
.show();
}
}
}
2.3 運行的效果：
首先我們先把服務(wù)端Ｂ應(yīng)用運行起來，然后我們把客戶端Ａ應(yīng)用運行起來測試一下效果試試：
小事例運行效果
3. 應(yīng)用層的具體流程分析
接下來我們就來看一下，跨進程間的通信在應(yīng)用層的具體走向，有請aidl出場，我們在客戶端會通過
bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE)去請求連接，在onServiceConnected()通過IBinder獲取UserCalcAIDL實例：
private UserCalcAIDL mCalcAidl;
private ServiceConnection mServiceConn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.e("client", "onServiceConnected");
// 請求連接后會調(diào)用該方法，通過IBinder service獲取UserCalcAIDL實例mCalcAidl
mCalcAidl = UserCalcAIDL.Stub.asInterface(service);
}
};
/**
* 點擊BindService按鈕時調(diào)用
* @param view
*/
public void bindService(View view) {
Intent intent = new Intent();
intent.setAction("com.study.aidl.user");
// 在Android 5.0之后google出于安全的角度禁止了隱式聲明Intent來啟動Service.也禁止使用Intent filter.否則就會拋個異常出來
intent.setPackage("com.study.aidl");
// 請求綁定連接 服務(wù)端
bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE);
}
客戶端在獲取到aidl實例之后就可以調(diào)用里面的getUserName和getUserPassword方法，我們點擊進去看一下，發(fā)現(xiàn)是一個抽象方法，這里我們就不得不說一下 UserCalcAIDL.java文件。這個文件我們自己并沒有寫我們只寫了UserCalcAIDL.aidl文件是系統(tǒng)贈送給我們的，他里面有很多代碼：
public interface UserCalcAIDL extends android.os.IInterface {
/**
* Stub 繼承自Binder 實現(xiàn)了 UserCalcAIDL ，連接后服務(wù)端返回的mBinder 我們是這么new的
* new UserCalcAIDL.Stub() 也就是客服端連接后的 IBinder service
*/
public static abstract class Stub extends android.os.Binder implements com.hc.androidipc.UserCalcAIDL {
private static final java.lang.String DESCRIPTOR = "com.hc.androidipc.UserCalcAIDL";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* 這個方法是在客戶端 onServiceConnected 中調(diào)用的返回是一個 Stub.Proxy
*/
public static com.hc.androidipc.UserCalcAIDL asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.hc.androidipc.UserCalcAIDL))) {
return ((com.hc.androidipc.UserCalcAIDL) iin);
}
return new com.hc.androidipc.UserCalcAIDL.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_getUserName: {
// 服務(wù)端寫數(shù)據(jù) 寫入到reply里面
data.enforceInterface(DESCRIPTOR);
java.lang.String _result = this.getUserName();
reply.writeNoException();
reply.writeString(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.hc.androidipc.UserCalcAIDL {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
// 這是傳遞進來的服務(wù)端給我們返回的 IBinder其實也是Stub
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
// 這個才是客戶端獲取用戶名的實現(xiàn)方法
@Override
public java.lang.String getUserName() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.lang.String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
// 首先調(diào)用服務(wù)端返回的Ibinder實例調(diào)用transact方法寫入到_reply中
mRemote.transact(Stub.TRANSACTION_getUserName, _data, _reply, 0);
_reply.readException();
// 然后進行讀取
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
// 返回讀取到的用戶名
return _result;
}
static final int TRANSACTION_getUserName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_getUserPassword = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public java.lang.String getUserName() throws android.os.RemoteException;
public java.lang.String getUserPassword() throws android.os.RemoteException;
}
總結(jié)一下畫一個流程圖，客戶端通過bindService連接服務(wù)端，會調(diào)用服務(wù)端Service的onBind方法返回一個UserCalcAIDL.Stub的mBinder實例，然后將該實例返回給客戶端的onServiceConnected()方法里面，有兩個參數(shù)有一個IBinder就是服務(wù)端返回的mBinder，然后客戶端通過該實例建立一個新的AIDL.Stub.Proxy對象，我們在客戶端調(diào)用獲取信息方法的時候其實就是調(diào)用的AIDL.Stub.Proxy里面的getUserName()方法，通過mBinder的onTransact()方法寫入數(shù)據(jù)，然后獲取數(shù)據(jù)，就這么個流程了。
IPC Binder流程圖.png
4. google源碼層的具體走向
你怎么知道調(diào)用bindService就會來到服務(wù)端的service的onBind()方法呢？當然是源碼，記得前面有人說我很喜歡看源碼，這其實是一種習慣不是喜不喜歡就像學習一樣要漸漸成為一種習慣，有的時候我們寧愿反復的去百度搜索問題的解決方案，卻忘記了有一個更好的辦法就是源碼：
@Override
public boolean bindService(Intent service, ServiceConnection conn,
int flags) {
warnIfCallingFromSystemProcess();
return bindServiceCommon(service, conn, flags, mMainThread.getHandler(),
Process.myUserHandle());
}
private boolean bindServiceCommon(Intent service, ServiceConnection conn, int flags, Handler
handler, UserHandle user) {
IServiceConnection sd;
if (conn == null) {
throw new IllegalArgumentException("connection is null");
}
if (mPackageInfo != null) {
sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);
} else {
throw new RuntimeException("Not supported in system context");
}
try {
// 調(diào)用ActivityManagerNative.getDefault().bindService方法
int res = ActivityManagerNative.getDefault().bindService(
mMainThread.getApplicationThread(), getActivityToken(), service,
service.resolveTypeIfNeeded(getContentResolver()),
sd, flags, getOpPackageName(), user.getIdentifier());
return res != 0;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
// binderService獲取的也是一個遠程服務(wù)的Binder對象，也是跨進程，而ServiceManager就是上面
// 流程圖里用來管理這些服務(wù)和Binder驅(qū)動
IBinder b = ServiceManager.getService("activity");
if (false) {
Log.v("ActivityManager", "default service binder = " + b);
}
// 獲取到ActivityManager的管理類，最終調(diào)用ActivityManagerService是一個典型的跨進程通訊，
// 別問為什么千萬別糾結(jié)
IActivityManager am = asInterface(b);
if (false) {
Log.v("ActivityManager", "default service = " + am);
}
return am;
}
};
// 省略掉一些有關(guān)Activity的啟動流程，我們再后面再說
private final void realStartServiceLocked(ServiceRecord r,
ProcessRecord app, boolean execInFg) throws RemoteException {
if (app.thread == null) {
throw new RemoteException();
}
requestServiceBindingsLocked(r, execInFg);
}
private final boolean requestServiceBindingLocked(ServiceRecord r, IntentBindRecord i,
boolean execInFg, boolean rebind) throws TransactionTooLargeException {
if (r.app == null || r.app.thread == null) {
// If service is not currently running, can't yet bind.
return false;
}
if ((!i.requested || rebind) && i.apps.size() > 0) {
bumpServiceExecutingLocked(r, execInFg, "bind");
r.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
// IApplicationThread
r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind,
r.app.repProcState);
}
return true;
}
// 找了半天才找到這個方法，在ActivityThread的一個內(nèi)部類
public final void scheduleBindService(IBinder token, Intent intent,
boolean rebind, int processState) {
updateProcessState(processState, false);
BindServiceData s = new BindServiceData();
s.token = token;
s.intent = intent;
s.rebind = rebind;
if (DEBUG_SERVICE)
Slog.v(TAG, "scheduleBindService token=" + token + " intent=" + intent + " uid="
+ Binder.getCallingUid() + " pid=" + Binder.getCallingPid());
// 請求綁定
sendMessage(H.BIND_SERVICE, s);
}
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case BIND_SERVICE:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
handleBindService((BindServiceData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
}
}
private void handleBindService(BindServiceData data) {
Service s = mServices.get(data.token);
if (DEBUG_SERVICE)
Slog.v(TAG, "handleBindService s=" + s + " rebind=" + data.rebind);
if (s != null) {
try {
data.intent.setExtrasClassLoader(s.getClassLoader());
data.intent.prepareToEnterProcess();
try {
if (!data.rebind) {
// 果真調(diào)用了service的onBind方法
IBinder binder = s.onBind(data.intent);
// 然后把返回的binder實例公開回調(diào)出去
ActivityManagerNative.getDefault().publishService(
data.token, data.intent, binder);
} else {
// 調(diào)用 onRebind 方法
s.onRebind(data.intent);
ActivityManagerNative.getDefault().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
}
ensureJitEnabled();
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
} catch (Exception e) {
if (!mInstrumentation.onException(s, e)) {
throw new RuntimeException(
"Unable to bind to service " + s
+ " with " + data.intent + ": " + e.toString(), e);
}
}
}
}
看到這里其實Android系統(tǒng)進程間通信機制Binder的總體架構(gòu)，它由Client、Server、Service Manager和驅(qū)動程序Binder四個組件構(gòu)成。那么Service Manager在這里起到了什么作用呢？其實Service Manager，它是整個Binder機制的守護進程，用來管理開發(fā)者創(chuàng)建的各種Server，并且向Client提供查詢Server遠程接口的功能。
Service Manager在用戶空間的源代碼位于frameworks/base/cmds/servicemanager目錄下，主要是由binder.h、binder.c和service_manager.c三個文件組成。Service Manager的入口位于service_manager.c文件中的main函數(shù)：
int main(int argc, char **argv) {
struct binder_state *bs;
void *svcmgr = BINDER_SERVICE_MANAGER;
// 這個函數(shù)位于frameworks/base/cmds/servicemanager/binder.c文件中
// 通過文件操作函數(shù)open來打開/dev/binder設(shè)備文件。
// 設(shè)備文件/dev/binder是在Binder驅(qū)動程序模塊初始化的時候創(chuàng)建的，
// 大家可以先看一下這個設(shè)備文件的創(chuàng)建過程。
// 進入到kernel/common/drivers/staging/android目錄中，打開binder.c文件，
// 可以看到模塊初始化入口binder_init：
bs = binder_open(128*1024);
if (binder_become_context_manager(bs)) {
LOGE("cannot become context manager (%s)\n", strerror(errno));
return -1;
}
svcmgr_handle = svcmgr;
// binder_loop函數(shù)進入循環(huán)，等待Client來請求了。
// binder_loop函數(shù)定義在frameworks/base/cmds/servicemanager/binder.c文件中
binder_loop(bs, svcmgr_handler);
return 0;
}
關(guān)于Native的代碼我就不貼了，如果再貼下去很多人估計都要開始罵人了，上來就蒙B。
Native層具體的流程大致是：
1.先打開binder文件 -> 2.建立內(nèi)存映射 -> 3.通知binder程序驅(qū)動 -> 4.進入循環(huán)等待請求的到來。
最近有人反應(yīng)視頻更新有點慢，我只能說還真是抱歉，因為我畢竟還是要生活所以還得去公司上班，目前還沒有達到佛陀的心態(tài)，所以只能在周末跟大家分享了?？戳诉@么多也不知道到底怎么用，這么麻煩干嘛？其實是為了后面的雙進程守護做準備的，建立打不死的Service小強。
所有分享大綱：2017Android進階之路與你同行
