2. 程式人生 > >Android進階——Android跨程序通訊機制之Binder、IBinder、Parcel、AIDL

Android進階——Android跨程序通訊機制之Binder、IBinder、Parcel、AIDL

阿新 • • 發佈：2019-01-08

前言

Binder機制是Android系統提供的跨程序通訊機制，這篇文章開始會從Linux相關的基礎概念知識開始介紹，從基礎概念知識中引出Binder機制，歸納Binder機制與Linux系統的跨程序機制的優缺點，接著分析Binder的通訊模型和原理，而Binder機制最佳體現就是AIDL，所以在後面會分析AIDL的實現原理，最後簡單的提下AMS的Binder體系，整篇文章中間會穿插有IBinder、Binder、Parcel的介紹，整篇文章閱讀難度不大，不會涉及到framework層的Binder原理，AIDL部分需要有AIDL的使用基礎

基礎概念

基礎概念部分介紹Linux的某些機制，主要想表達Binder驅動的出現的原因，如果對Linux熟悉的可以直接跳過這部分，看第五點即可

一、程序隔離

出於安全考慮，一個程序不能操作另一個程序的資料，進而一個作業系統必須具備程序隔離這個特性。在Linux系統中，虛擬記憶體機制為每個程序分配了線性連續的記憶體空間，作業系統將這種虛擬記憶體空間對映到實體記憶體空間，每個程序有自己的虛擬記憶體空間，進而不能操作其他程序的記憶體空間，每個程序只能操作自己的虛擬記憶體空間，只有作業系統才有許可權操作實體記憶體空間。程序隔離保證了每個程序的記憶體安全，但是在大多數情形下，不同程序間的資料通訊是不可避免的，因此作業系統必須提供跨程序通訊機制

二、使用者空間和核心空間

  • 使用者空間：表示程序執行在一個特定的操作模式中，沒有接觸實體記憶體或裝置的許可權
  • 核心空間：表示獨立於普通的應用程式，可以訪問受保護的記憶體空間，也有訪問底層硬體裝置的所有許可權

三、系統呼叫/核心態/使用者態

抽象來看，作業系統中安全邊界的概念就像環路的概念一樣(前提是系統支援這種特性)，一個環上持有一個特定的許可權組，Intel 支援四層環，但是 Linux 只使用了其中的兩環(0號環持有全部許可權，3號環持有最少許可權，1號和2號環未使用)，系統程序執行在1號環，使用者程序執行在３號環，如果一個使用者程序需要其他高階許可權，其必須從３號環過渡成０號環，過渡需要通過一個安全引數檢查的閘道器，這種過渡被稱為系統呼叫，在執行過程中會產生一定數量的計算開銷。所以，使用者空間要訪問核心空間的唯一方式就是系統呼叫(System Call)

這裡寫圖片描述

四、核心模組/驅動

通過系統呼叫，使用者空間可以訪問核心空間，它是怎麼做到訪問核心空間的呢？Linux的動態可載入核心模組機制解決了這個問題，模組是具有獨立功能的程式，它可以被單獨編譯，但不能獨立執行。這樣，Android系統可以通過新增一個核心模組執行在核心空間，使用者程序之間的通過這個模組作為橋樑，就可以完成通訊了。在Android系統中，這個執行在核心空間的，負責各個使用者程序通過Binder通訊的核心模組叫做Binder驅動

五、簡單的總結

將前面的所有概念連線起來理解就會非常好消化知識點：

  1. Linux的虛擬記憶體機制導致記憶體的隔離，進而導致程序隔離
  2. 程序隔離的出現導致對記憶體的操作被劃分為使用者空間和核心空間
  3. 使用者空間需要跨許可權去訪問核心空間，必須使用系統呼叫去實現
  4. 系統呼叫需要藉助核心模組/驅動去完成

前三步決定了程序間通訊需要藉助核心模組/驅動去實現，而Binder驅動就是核心模組/驅動中用來實現程序間通訊的

為什麼要用Binder

Linux提供有管道、訊息佇列、訊號量、記憶體共享、套接字等跨程序方式，那為什麼Android要選擇Binder另起爐灶呢？

一、傳輸效能好

  • Socket：是一個通用介面，導致其傳輸效率低，開銷大
  • 共享記憶體：雖然在傳輸時不需要拷貝資料，但其控制機制複雜
  • Binder：複雜資料型別傳遞可以複用記憶體，需要拷貝1次資料
  • 管道和訊息佇列：採用儲存轉發方式，至少需要拷貝2次資料，效率低

二、安全性高

  • 傳統的程序：通訊方式對於通訊雙方的身份並沒有做出嚴格的驗證，只有在上層協議上進行架設
  • Binder機制：從協議本身就支援對通訊雙方做身份校檢，因而大大提升了安全性

Binder通訊模型

首先在理解模型之前先熟悉這幾個概念：

  • Client程序：跨程序通訊的客戶端（執行在某個程序）
  • Server程序：跨程序通訊的服務端（執行在某個程序）
  • Binder驅動：跨程序通訊的介質
  • ServiceManager：跨程序通訊中提供服務的註冊和查詢（執行在System程序）

這裡寫圖片描述

這裡只是個簡單的模型而已，只需理解模型的通訊流程：

  1. Server端通過Binder驅動在ServiceManager中註冊
  2. Client端通過Binder驅動獲取ServiceManager中註冊的Server端
  3. Client端通過Binder驅動和Server端進行通訊

Binder通訊原理

這裡寫圖片描述

理解完模型流程之後，開始理解模型的通訊原理：

  1. Service端通過Binder驅動在ServiceManager的查詢表中註冊Object物件的add方法
  2. Client端通過Binder驅動在ServiceManager的查詢表中找到Object物件的add方法，並返回proxy物件的add方法，add方法是個空實現，proxy物件也不是真正的Object物件，是通過Binder驅動封裝好的代理類的add方法
  3. 當Client端呼叫add方法時，Client端會呼叫proxy物件的add方法，通過Binder驅動去請求ServiceManager來找到Service端真正物件，然後呼叫Service端的add方法

Binder物件和Binder驅動

  • Binder物件：Binder機制中進行程序間通訊的物件，對於Service端為Binder本地物件，對於Client端為Binder代理物件
  • Binder驅動：Binder機制中進行程序間通訊的介質，Binder驅動會對具有跨程序傳遞能力的物件做特殊處理，自動完成代理物件和本地物件的轉換

由於Binder驅動會對具有跨程序傳遞能力的物件做特殊處理，自動完成代理物件和本地物件的轉換，因此在驅動中儲存了每一個跨越程序的Binder物件的相關資訊，Binder本地物件（或Binder實體）儲存在binder_node的資料結構，Binder代理物件（或Binder引用/控制代碼）儲存在binder_ref的資料結構

Java層的Binder

  • Binder類：是Binder本地物件
  • BinderProxy類：是Binder類的內部類，它代表遠端程序的Binder物件的本地代理
  • Parcel類：是一個容器，它主要用於儲存序列化資料，然後可以通過Binder在程序間傳遞這些資料
  • IBinder介面：代表一種跨程序傳輸的能力，實現這個介面，就能將這個物件進行跨程序傳遞
  • IInterface介面：client端與server端的呼叫契約，實現這個介面，就代表遠端server物件具有什麼能力，因為IInterface介面的asBinder方法的實現可以將Binder本地物件或代理物件進行返回

Binder類和BinderProxy類都繼承自IBinder，因而都具有跨程序傳輸的能力，在跨越程序的時候，Binder驅動會自動完成這兩個物件的轉換。IBinder是遠端物件的基本介面，是為高效能而設計的輕量級遠端呼叫機制的核心部分，但它不僅用於遠端呼叫，也用於程序內呼叫。IBinder介面定義了與遠端物件互動的協議，建議不要直接實現這個介面，而應該從Binder派生。Binder實現了IBinder介面，但是一般不需要直接實現此類，而是跟據你的需要由開發包中的工具生成，這個工具叫aidi。你通過aidi語言定義遠端物件的方法，然後用aidi工具生成Binder的派生類，然後使用它

AIDL

由於編譯工具會給我們生成一個Stub的靜態內部類，這個類繼承了Binder, 說明它是一個Binder本地物件，它實現了IInterface介面，表明它具有遠端Server承諾給Client的能力

一、服務端

在服務端中，我們只要實現Stub抽象類，和實現其方法即可

private IBinder myS = new IMyAidlInterface.Stub() {  
    @Override  
    public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {  

    }  

    @Override  
    public int add(int num1, int num2) throws RemoteException {  
        Log.i("Hensen", "從客戶端發來的AIDL請求:num1->" + num1 + "::num2->" + num2);  
        return num1 + num2;  
    }  
};

二、客戶端

在客戶端中，可以通過bindService的回撥中獲取AIDL介面

private ServiceConnection conn = new ServiceConnection() {  
    @Override  
    public void onServiceConnected(ComponentName name, IBinder service) {  
        iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);  
    }  

    @Override  
    public void onServiceDisconnected(ComponentName name) {  
        iMyAidlInterface = null;  
    }  
};

public void add(View view) {  
    try {  
        int res = iMyAidlInterface.add(1, 2);  
        Log.i("Hensen", "從服務端呼叫成功的結果：" + res);  
    } catch (RemoteException e) {  
        e.printStackTrace();
    }
}

梳理客戶端的呼叫流程：

  1. 呼叫Stub.asInterface獲取BinderProxy物件
  2. 呼叫BinderProxy物件的add方法

三、分析原理

1、Stub

Stub類繼承自Binder，意味著這個Stub其實自己是一個Binder本地物件，然後實現了IMyAidlInterface介面，IMyAidlInterface本身是一個IInterface，因此他攜帶某種客戶端需要的能力（這裡是方法add)。此類有一個內部類Proxy，也就是Binder代理物件

/* 
 * This file is auto-generated.  DO NOT MODIFY. 
 * Original file: D:\\workspace5\\Boke\\app\\src\\main\\aidl\\com\\handsome\\boke\\IMyAidlInterface.aidl 
 */  
package com.handsome.boke;  
// Declare any non-default types here with import statements  

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

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

        /** 
         * Cast an IBinder object into an com.handsome.boke.IMyAidlInterface interface, 
         * generating a proxy if needed. 
         */  
        public static com.handsome.boke.IMyAidlInterface asInterface(android.os.IBinder obj) {  
            if ((obj == null)) {  
                return null;  
            }  
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);  
            if (((iin != null) && (iin instanceof com.handsome.boke.IMyAidlInterface))) {  
                return ((com.handsome.boke.IMyAidlInterface) iin);  
            }  
            return new com.handsome.boke.IMyAidlInterface.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_basicTypes: {  
                    data.enforceInterface(DESCRIPTOR);  
                    int _arg0;  
                    _arg0 = data.readInt();  
                    long _arg1;  
                    _arg1 = data.readLong();  
                    boolean _arg2;  
                    _arg2 = (0 != data.readInt());  
                    float _arg3;  
                    _arg3 = data.readFloat();  
                    double _arg4;  
                    _arg4 = data.readDouble();  
                    java.lang.String _arg5;  
                    _arg5 = data.readString();  
                    this.basicTypes(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5);  
                    reply.writeNoException();  
                    return true;  
                }  
                case TRANSACTION_add: {  
                    data.enforceInterface(DESCRIPTOR);  
                    int _arg0;  
                    _arg0 = data.readInt();  
                    int _arg1;  
                    _arg1 = data.readInt();  
                    int _result = this.add(_arg0, _arg1);  
                    reply.writeNoException();  
                    reply.writeInt(_result);  
                    return true;  
                }  
            }  
            return super.onTransact(code, data, reply, flags);  
        }  

        private static class Proxy implements com.handsome.boke.IMyAidlInterface {  
            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;  
            }  

            /** 
             * Demonstrates some basic types that you can use as parameters 
             * and return values in AIDL. 
             */  
            @Override  
            public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException {  
                android.os.Parcel _data = android.os.Parcel.obtain();  
                android.os.Parcel _reply = android.os.Parcel.obtain();  
                try {  
                    _data.writeInterfaceToken(DESCRIPTOR);  
                    _data.writeInt(anInt);  
                    _data.writeLong(aLong);  
                    _data.writeInt(((aBoolean) ? (1) : (0)));  
                    _data.writeFloat(aFloat);  
                    _data.writeDouble(aDouble);  
                    _data.writeString(aString);  
                    mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0);  
                    _reply.readException();  
                } finally {  
                    _reply.recycle();  
                    _data.recycle();  
                }  
            }  

            @Override  
            public int add(int num1, int num2) throws android.os.RemoteException {  
                android.os.Parcel _data = android.os.Parcel.obtain();  
                android.os.Parcel _reply = android.os.Parcel.obtain();  
                int _result;  
                try {  
                    _data.writeInterfaceToken(DESCRIPTOR);  
                    _data.writeInt(num1);  
                    _data.writeInt(num2);  
                    mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);  
                    _reply.readException();  
                    _result = _reply.readInt();  
                } finally {  
                    _reply.recycle();  
                    _data.recycle();  
                }  
                return _result;  
            }  
        }  

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

    /** 
     * Demonstrates some basic types that you can use as parameters 
     * and return values in AIDL. 
     */  
    public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException;  

    public int add(int num1, int num2) throws android.os.RemoteException;  
}

2、asInterface

當客戶端bindService的onServiceConnecttion的回撥裡面，通過asInterface方法獲取遠端的service的。其函式的引數IBinder型別的obj，這個物件是驅動給我們的，如果是Binder本地物件，那麼它就是Binder型別，如果是Binder代理物件，那就是BinderProxy型別。asInterface方法中會呼叫queryLocalInterface，查詢Binder本地物件，如果找到，說明Client和Server都在同一個程序，這個引數直接就是本地物件，直接強制型別轉換然後返回，如果找不到，說明是遠端物件那麼就需要建立Binder代理物件，讓這個Binder代理物件實現對於遠端物件的訪問

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

3、add

當客戶端呼叫add方法時，首先用Parcel把資料序列化，然後呼叫mRemote.transact方法，mRemote就是new Stub.Proxy(obj)傳進來的，即BinderProxy物件

@Override  
public int add(int num1, int num2) throws android.os.RemoteException {  
    android.os.Parcel _data = android.os.Parcel.obtain();  
    android.os.Parcel _reply = android.os.Parcel.obtain();  
    int _result;  
    try {  
        _data.writeInterfaceToken(DESCRIPTOR);  
        _data.writeInt(num1);  
        _data.writeInt(num2);  
        mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);  
        _reply.readException();  
        _result = _reply.readInt();  
    } finally {  
        _reply.recycle();  
        _data.recycle();  
    }  
    return _result;  
}

4、transact

BinderProxy的transact方法是native方法，它的實現在native層，它會去借助Binder驅動完成資料的傳輸，當完成資料傳輸後，會喚醒Server端，呼叫了Server端本地物件的onTransact函式

public native boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException;

5、onTransact

在Server程序裡面，onTransact根據呼叫code會呼叫相關函式，接著將結果寫入reply並通過super.onTransact返回給驅動，驅動喚醒掛起的Client程序裡面的執行緒並將結果返回

@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_add: {  
            data.enforceInterface(DESCRIPTOR);  
            int _arg0;  
            _arg0 = data.readInt();  
            int _arg1;  
            _arg1 = data.readInt();  
            int _result = this.add(_arg0, _arg1);  
            reply.writeNoException();  
            reply.writeInt(_result);  
            return true;  
        }  
    }  
    return super.onTransact(code, data, reply, flags);  
}

6、題外話

為什麼生成的檔案不直接分為1個介面，2個類，清晰明瞭。Android這樣子設計是有道理的，當有多個AIDL檔案時候，Stub和Proxy類就會重名，把它們放在各自的AIDL介面中，就區分開來了

AMS的Binder體系

這裡寫圖片描述

AMS是Android中最核心的服務，主要負責系統中四大元件的啟動、切換、排程及應用程序的管理和排程等工作，從圖中可以看出：

AMS Binder角色
IActivityManager IInterface
ActivityManagerNative Binder本地物件
ActivityManagerProxy Binder代理物件
ActivityManagerService Service端
ActivityManager 普通管理類

結語

這裡只是簡單的理解下Binder機制的基本原理，後續有時間會研究framework層的知識，如果有興趣的同學可以不依賴AIDL工具，手寫遠端Service完成跨程序通訊，這樣就可以加深對AIDL和Binder的理解，個人覺得這樣是最好的記憶方式，一起來寫吧

相關推薦

Android進階——Android跨程序通訊機制之Binder、IBinder、Parcel、AIDL

前言 Binder機制是Android系統提供的跨程序通訊機制，這篇文章開始會從Linux相關的基礎概念知識開始介紹，從基礎概念知識中引出Binder機制，歸納Binder機制與Linux系統的跨程序機制的優缺點，接著分析Binder的通訊模型和原理，而Bin

Android 進階9：程序通訊之 AIDL 解析

讀完本文你將瞭解： 在 Android 進階7：程序通訊之 AIDL 的使用 中我們使用 AIDL 實現了跨程序的通訊，但是不清楚 AIDL 幫我們做了什麼。 AIDL 的本質是簡化我們 IPC 開發，它使用的是 Binder 機制，於是在上篇文章

Android 進階7：程序通訊之 AIDL 的使用

讀完本文你將瞭解： 記得 2015 年實習面試，筆試題裡就有這道題：請介紹下 AIDL。 當時的我是懵逼的，只好老老實實空著。沒想到後來面試時面試官大哥嘿嘿一笑說他也沒用過這玩意，真是夠實誠的。 筆試完查了這個知識點，似懂非懂也沒深究。去年看《安卓開

Android 進階12：程序通訊之 Socket （順便回顧 TCP UDP）

不要害怕困難，這是你進步的機會！ 讀完本文你將瞭解： 前面幾篇文章我們介紹了 AIDL 、Binder、Messenger 以及 ContentProvider 實現程序通訊的方式，這篇文章將介紹“使用 Socket 進行跨程序通訊”。 在介紹

Android每天一個知識點+Demo—跨程序通訊機制AIDL入門

一 Why-為什麼要用AIDL 沙箱理念：在Android中，每個應用（Application）程式都執行在獨立的程序中，無法直接呼叫到其他應用的資源。當一個應用被執行時，一些操作是被限制的，比如訪問記憶體，訪問感測器等等。 好處：這也保證了當其中一個程式出現異常而不會影

圖文詳解 Android Binder跨程序通訊機制 原理

目錄 目錄 1. Binder到底是什麼？ 中文即 粘合劑，意思為粘合了兩個不同的程序 網上有很多對Binder的定義，但都說不清楚：Binder是跨程序通訊方式、它實現了IBinder介面，是連線 ServiceManager的橋樑blabla，估計大家都看暈了

Android進階——Android檢視工作機制之measure、layout、draw

前言 自定義View一直是初學者們最頭疼的事情，因為他們並沒有瞭解到真正的實現原理就開始試著做自定義View，碰到很多看不懂的程式碼只能選擇迴避，做多了會覺得很沒自信。其實只要瞭解了View的工作機制後，會發現是挺簡單的，自定義View就是藉助View的工作機

Android TV開發-桌面 跨程序通訊(IPC) 詳解

@[TOC] 1. 寫在前面 Android 程序間通訊 的 幾種方式： 四大元件間傳遞Bundle 使用檔案共享方式，多程序讀

【Android 進階】仿抖音系列之翻頁上下滑切換視訊（四）

大家好，我們又見面了。這是這個系列的第四篇，在這篇文章之前，建議可以先看下之前系列的文章，為了節省篇幅，之前詳細說過的地方，這裡就不再詳細描述了，下面是目錄： 【Android 進階】仿抖音系列之翻頁上下滑切換視訊（一） 【Android 進階】仿抖音系列之列表播放視訊

【Android 進階】仿抖音系列之列表播放視訊（三）

在上一篇【Android 進階】仿抖音系列之列表播放視訊（二）中，我們實現列表播放視訊，這一篇我們來對其做些優化。 【Android 進階】仿抖音系列之翻頁上下滑切換視訊（一） 【Android 進階】仿抖音系列之列表播放視訊（二） 【Android 進階】仿抖音

【Android 進階】仿抖音系列之列表播放視訊（二）

上一篇中，我們實現了仿抖音上下翻頁切換視訊的效果，詳見【Android 進階】仿抖音系列之翻頁上下滑切換視訊（一），這一篇，我們來實現抖音列表播放視訊。 【Android 進階】仿抖音系列之翻頁上下滑切換視訊（一） 【Android 進階】仿抖音系列之列表播放視訊（二）

【Android 進階】仿抖音系列之翻頁上下滑切換視訊（一）

最近公司在做個短視訊的專案，其中借鑑了很多抖音的設計，其中就有抖音的上下滑切換視訊。 【Android 進階】仿抖音系列之翻頁上下滑切換視訊（一） 【Android 進階】仿抖音系列之列表播放視訊（二） 【Android 進階】仿抖音系列之列表播放視訊（三）

【Android 進階】仿抖音系列之視訊預覽和錄製（五）

大家好，又見面了。在前幾篇中，我們通過2種方式實現了仿抖音的翻頁切換視訊，仿抖音列表播放視訊功能，這一篇，我們來說說視訊的錄製。 【Android 進階】仿抖音系列之翻頁上下滑切換視訊（一） 【Android 進階】仿抖音系列之列表播放視訊（二） 【Android

Regular進階： 跨元件通訊

本文由作者鄭海波授權網易雲社群釋出。 背景 在元件化不斷深入的大環境下，無論使用哪種 MDV 框架都最終會遇到一個頭疼的問題，就是「跨元件通訊」。 下圖是個簡單的例子 這裡包含「事件通訊」和「資料通訊」兩個維度。 事件傳遞 為了將事件 click 從 

Android進階---Android Webview重定向問題解決

專案中需要webview重定向，但是由於一個webveiw裡面有許多載入操作，因此在呼叫webview。goback()方法時，往往達不到我們需要的操作效果。 1.解決方法 WebBackForwardList webBackForwardList=we

Android進階——Material Design新控制元件之TabLayout製作可滾動的Tabs頁面（二）

引言 上一篇總結講解了下TabLayout的基本特點、屬性和簡單的應用步驟，相信大家已經對於TabLayout已經不再陌生，這篇就結合Fragment+ViewPager的架構開發一個主流App的主要框架，進一步學習下TabLayout的操作和監聽，同時分享一

Android 進階13：幾種程序通訊方式的對比總結

讀完本文你將瞭解： RPC 是什麼 IDL 是什麼 IPC 是什麼 Android 幾種程序通訊方式 如何選擇這幾種通訊方式 Thanks RPC 是什麼 RPC 即 Remote Procedure Call (遠端過程呼叫) 是一種計算機通訊協議，它為我們定義了計算機 C 中的程式如何呼叫另

Android跨程序通訊：binder機制原理

個人閱讀收穫 通過binder驅動我們可以減少一次io操作，從而減少了我們程序通訊的花費的資源，加快了程序間通訊的速度。我們使用到了Linux的mmap()操作，從而實現了程序間的接收快取區與程序的空間區的對映，從而少了一次io操作。我們的客戶端會發送資訊通過我們io操作講

Android-Messenger跨程序通訊

http://blog.csdn.net/lmj623565791/article/details/47017485   一.概述 我們可以在客戶端傳送一個Message給服務端，在服務端的handler中會接收到客戶端的訊息，然後進行對應的處理，處理完成後，再將結果等資

android進階3step1：Android元件通訊——Service基礎

轉：https://www.jianshu.com/p/95ec2a23f300 Android Service使用詳解   轉：https://www.jianshu.com/p/4c798c91a613 Android Service兩種啟動方式詳解（總結版