1. 概述

當(dāng)初決定分享內(nèi)涵段子的這個項(xiàng)目我有些擔(dān)心，擔(dān)心很多東西心里雖然有了輪廓和細(xì)節(jié)采驻。但是如果涉及到的東西比較多双揪，那么就有可能沒辦法去講太多的細(xì)節(jié)，況且某些哥們還不會C和C++至耻，所以如果的確覺得IPC這方面比較難可以多去找找這方面的文章看看。這里我們就從三個方面去講解：
　　1.1：進(jìn)程間通信的一個小事例；
　　1.2：應(yīng)用層的具體流程分析尘颓；
　　1.3：google源碼層的具體走向走触；

所有分享大綱：2017Android進(jìn)階之路與你同行

視頻講解地址：http://pan.baidu.com/s/1pLrvFj9

2. 進(jìn)程間通信的一個小事例

為什么會出現(xiàn)IPC這個概念，Android操作系統(tǒng)為了確保進(jìn)程之間不會產(chǎn)生相互干擾疤苹，就是為了你掛了不會影響我互广，所以采用了進(jìn)程隔離的機(jī)制，即為每個進(jìn)程分配獨(dú)立虛擬地址空間卧土，進(jìn)程之間感覺不到彼此的存在惫皱，感覺自己仿佛占用整個內(nèi)存空間。這樣保證了進(jìn)程的數(shù)據(jù)安全尤莺，但是必然存在另外的問題旅敷，那就是進(jìn)程間通信，進(jìn)程不可能完全獨(dú)立運(yùn)行颤霎，有時候需要相互通信獲取別的進(jìn)程的運(yùn)行結(jié)果等媳谁，因此需要想辦法解決進(jìn)程間通信的問題，所以就出現(xiàn)了IPC這個概念友酱。其他就不說了韩脑，假設(shè)我A應(yīng)用要去B里面應(yīng)用獲取的數(shù)據(jù)該怎么辦，接下來我們就寫這么一個實(shí)例粹污，這里就涉及到兩個單獨(dú)的應(yīng)用，我們就把A應(yīng)用作為客戶端首量，B應(yīng)用作為服務(wù)端壮吩。

2.1 應(yīng)用服務(wù)端：

// 編寫aidl文件
interface UserCalcAIDL {
    String getUserName();
    String getUserPassword();
}

上面是編寫aidl文件，類似于interface加缘，這里我就不介紹aidl了鸭叙，到后面再去介紹。然后我們在項(xiàng)目中新建一個服務(wù)Service拣宏，代碼如下：

public class UserService extends Service{
    private static final String TAG = "server";

    // 應(yīng)用間通信進(jìn)行綁定
    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 的實(shí)例
    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中運(yùn)行該服務(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);
    }

    /**
     * 點(diǎn)擊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);
    }
    /**
     * 點(diǎn)擊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 運(yùn)行的效果：

首先我們先把服務(wù)端Ｂ應(yīng)用運(yùn)行起來，然后我們把客戶端Ａ應(yīng)用運(yùn)行起來測試一下效果試試：

小事例運(yùn)行效果

3. 應(yīng)用層的具體流程分析

接下來我們就來看一下徙融，跨進(jìn)程間的通信在應(yīng)用層的具體走向洒缀，有請aidl出場，我們在客戶端會通過
bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE)去請求連接张咳，在onServiceConnected()通過IBinder獲取UserCalcAIDL實(shí)例：

    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實(shí)例mCalcAidl
            mCalcAidl = UserCalcAIDL.Stub.asInterface(service);
        }
    };

     /**
     * 點(diǎn)擊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實(shí)例之后就可以調(diào)用里面的getUserName和getUserPassword方法，我們點(diǎn)擊進(jìn)去看一下脚猾，發(fā)現(xiàn)是一個抽象方法葱峡，這里我們就不得不說一下 UserCalcAIDL.java文件。這個文件我們自己并沒有寫我們只寫了UserCalcAIDL.aidl文件是系統(tǒng)贈送給我們的龙助，他里面有很多代碼：

public interface UserCalcAIDL extends android.os.IInterface {
    /**
     *  Stub 繼承自Binder 實(shí)現(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) {
                // 這是傳遞進(jìn)來的服務(wù)端給我們返回的 IBinder其實(shí)也是Stub
                mRemote = remote;
            }

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

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

            // 這個才是客戶端獲取用戶名的實(shí)現(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實(shí)例調(diào)用transact方法寫入到_reply中
                    mRemote.transact(Stub.TRANSACTION_getUserName, _data, _reply, 0);
                    _reply.readException();
                    // 然后進(jìn)行讀取
                    _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實(shí)例军援，然后將該實(shí)例返回給客戶端的onServiceConnected()方法里面，有兩個參數(shù)有一個IBinder就是服務(wù)端返回的mBinder称勋，然后客戶端通過該實(shí)例建立一個新的AIDL.Stub.Proxy對象胸哥，我們在客戶端調(diào)用獲取信息方法的時候其實(shí)就是調(diào)用的AIDL.Stub.Proxy里面的getUserName()方法，通過mBinder的onTransact()方法寫入數(shù)據(jù)赡鲜，然后獲取數(shù)據(jù)空厌，就這么個流程了。

IPC Binder流程圖.png

4. google源碼層的具體走向

你怎么知道調(diào)用bindService就會來到服務(wù)端的service的onBind()方法呢银酬？當(dāng)然是源碼嘲更，記得前面有人說我很喜歡看源碼，這其實(shí)是一種習(xí)慣不是喜不喜歡就像學(xué)習(xí)一樣要漸漸成為一種習(xí)慣揩瞪，有的時候我們寧愿反復(fù)的去百度搜索問題的解決方案赋朦，卻忘記了有一個更好的辦法就是源碼：

    @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獲取的也是一個遠(yuǎn)程服務(wù)的Binder對象，也是跨進(jìn)程李破，而ServiceManager就是上面
            // 流程圖里用來管理這些服務(wù)和Binder驅(qū)動
            IBinder b = ServiceManager.getService("activity");
            if (false) {
                Log.v("ActivityManager", "default service binder = " + b);
            }
            // 獲取到ActivityManager的管理類宠哄，最終調(diào)用ActivityManagerService是一個典型的跨進(jìn)程通訊，
            // 別問為什么千萬別糾結(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實(shí)例公開回調(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);
                }
            }
        }
    }

看到這里其實(shí)Android系統(tǒng)進(jìn)程間通信機(jī)制Binder的總體架構(gòu)，它由Client屯曹、Server狱庇、Service Manager和驅(qū)動程序Binder四個組件構(gòu)成惊畏。那么Service Manager在這里起到了什么作用呢？其實(shí)Service Manager密任，它是整個Binder機(jī)制的守護(hù)進(jìn)程颜启，用來管理開發(fā)者創(chuàng)建的各種Server，并且向Client提供查詢Server遠(yuǎn)程接口的功能浪讳。
　　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)建過程透揣。
    // 進(jìn)入到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ù)進(jìn)入循環(huán)辐真，等待Client來請求了须尚。
    // binder_loop函數(shù)定義在frameworks/base/cmds/servicemanager/binder.c文件中
    binder_loop(bs, svcmgr_handler);  
    return 0;  
}  

關(guān)于Native的代碼我就不貼了，如果再貼下去很多人估計(jì)都要開始罵人了侍咱，上來就蒙B耐床。

Native層具體的流程大致是：
1.先打開binder文件 -> 2.建立內(nèi)存映射 -> 3.通知binder程序驅(qū)動 -> 4.進(jìn)入循環(huán)等待請求的到來。

最近有人反應(yīng)視頻更新有點(diǎn)慢楔脯，我只能說還真是抱歉撩轰，因?yàn)槲耶吘惯€是要生活所以還得去公司上班，目前還沒有達(dá)到佛陀的心態(tài)昧廷，所以只能在周末跟大家分享了钧敞。看了這么多也不知道到底怎么用麸粮，這么麻煩干嘛？其實(shí)是為了后面的雙進(jìn)程守護(hù)做準(zhǔn)備的镜廉，建立打不死的Service小強(qiáng)弄诲。

所有分享大綱：2017Android進(jìn)階之路與你同行

視頻講解地址：https://pan.baidu.com/s/1dFB7Vot