Service的跨進程通信實戰

設想這麼一個場景，我們有2個APP(或者2個進程，均可)，其中一個APP需要提供一個Person相關的服務（該服務有一個名爲eat的接口），我們叫它PersonServer；另一個APP需要訪問PersonServer提供的服務，我們叫它Client。也就是現在有2個APP，一個作爲Server端，提供服務，另一個作爲Client端，使用服務。

我們來看如何在Android中實現？

PersonServer端實現

PersonServer端是服務的提供者，我們首先需要創建一個Service來提供該服務，並且需要該服務具備跨進程通信的能力，以便Client端進行調用。

實現AIDL

跨進行，我們首先想到的是使用AIDL來實現接口的跨進程能力。

首先我們需要定義一個名爲IPerson的AIDL接口，並提供eat方法：

package com.testaidl;
interface IPerson {
    boolean eat(String food);
}

我們看到，IPerson的實現非常簡單，我們使用IDE編譯一下，編譯器就會生成一個名爲IPerson.java的文件，即aidl所對應的java代碼。

實現Service

接下來我們定義一個Service：

public class PersionService extends Service
{
    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new IPerson.Stub() {
            @Override
            public boolean eat(String food) throws RemoteException {
                Log.d("PersionService", "this is Server");
                Log.d("PersionService", "Persion eat " + food);
                return true;
            }
        };
    }
}

這裏重點來看onBind方法，該方法返回一個IBinder對象，這裏也就是之前我們定義的IPerson.aidl的生成類IPerson.Stub，IPerson.Stub類有一個抽象方法eat()需要在這裏實現，這裏也就是該服務所提供的遠程服務所執行動作的具體實現。

別忘了在AndroidManifest中註冊：

        <service android:name=".PersionService">
            <intent-filter>
                <action android:name="com.example.simpledemo.PersionService"/>
            </intent-filter>
        </service>

Client端

Server端已經準備好了，那麼Client端如何訪問PersonServer所提供的服務呢？

我們來看Client端的實現：

public class MainActivity extends AppCompatActivity {
    private IPerson mService = null;
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) { //綁定Service成功後執行
            mService = IPerson.Stub.asInterface(iBinder);//獲取遠程服務的代理對象，一個IBinder對象
            try {
                mService.eat("banana"); //調用遠程服務的接口。
            } catch (RemoteException e) {
                e.printStackTrace();
            }

        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mService = null;
        }
    };

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

        Button bindService = findViewById(R.id.bind_service);
        bindService.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //調用bindService發送綁定遠程服務的請求
                Intent intent = new Intent();
                intent.setAction("com.example.simpledemo.PersionService");
                intent.setPackage("com.example.simpledemo");
                bindService(intent, mConnection, BIND_AUTO_CREATE);
            }
        });
    }
}

步驟分析：

調用bindService發送綁定遠程服務的請求。
ServiceConnection對象在綁定Service後執行回調函數onServiceConnected。
在onServiceConnected中，獲取遠程服務的代理對象，一個IBinder對象。
最後，通過上一步獲取的遠程服務代理對象，調用遠程服務的接口。

注意

別忘了需要在Client端的同樣位置，放置IPerson.aidl文件，包名，文件名等都保持一致。

Service/AIDL遠程調用過程解析

在Serivce的遠程通信過程中，最關鍵的點就是AIDL，它承擔了遠程通信訪問的任務，它的低層實現當然也是通過Binder機制來實現的，但是AIDL於Binder相比，簡化了我們的使用。

IPerson.aidl

我們首先來看IPerson.aidl：

package com.testaidl;
interface IPerson {
    boolean eat(String food);
}

它的實現非常簡單，那它是怎麼實現遠程通信的能力的呢？

我們知道，aidl文件經過編譯器編譯後，會生成一個.java文件，這個java文件纔是真正存放遠程通信實現邏輯代碼的地方。

IPerson.java：

package com.testaidl;
// Declare any non-default types here with import statements

public interface IPerson extends android.os.IInterface
{
  /** Local-side IPC implementation stub class. */
  public static abstract class Stub extends android.os.Binder implements com.testaidl.IPerson
  {
    private static final java.lang.String DESCRIPTOR = "com.testaidl.IPerson";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.testaidl.IPerson interface,
     * generating a proxy if needed.
     */
    public static com.testaidl.IPerson asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.testaidl.IPerson))) {
        return ((com.testaidl.IPerson)iin);
      }
      return new com.testaidl.IPerson.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
    {
      java.lang.String descriptor = DESCRIPTOR;
      switch (code)
      {
        case INTERFACE_TRANSACTION:
        {
          reply.writeString(descriptor);
          return true;
        }
        case TRANSACTION_eat:
        {
          data.enforceInterface(descriptor);
          java.lang.String _arg0;
          _arg0 = data.readString();
          boolean _result = this.eat(_arg0);
          reply.writeNoException();
          reply.writeInt(((_result)?(1):(0)));
          return true;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
    private static class Proxy implements com.testaidl.IPerson
    {
      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 eat(java.lang.String food) 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(food);
          boolean _status = mRemote.transact(Stub.TRANSACTION_eat, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().eat(food);
          }
          _reply.readException();
          _result = (0!=_reply.readInt());
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      public static com.testaidl.IPerson sDefaultImpl;
    }
    static final int TRANSACTION_eat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    public static boolean setDefaultImpl(com.testaidl.IPerson impl) {
      if (Stub.Proxy.sDefaultImpl == null && impl != null) {
        Stub.Proxy.sDefaultImpl = impl;
        return true;
      }
      return false;
    }
    public static com.testaidl.IPerson getDefaultImpl() {
      return Stub.Proxy.sDefaultImpl;
    }
  }
  public boolean eat(java.lang.String food) throws android.os.RemoteException;
}

我們定義aidl時，也只用了幾行代碼，而這個生成的java類裏面，代碼還是非常多的。

我們首先來看它的類結構：

它的結構可以分爲以下幾個部分；

接口IInterface。
抽象方法eat。
內部類Stub。
Stub的內部類Proxy。

我們分別來分析這幾個組成部分。

1. 接口IInterface

接口android.os.IInterface：

public interface IInterface
{
    /**
     * Retrieve the Binder object associated with this interface.
     * You must use this instead of a plain cast, so that proxy objects
     * can return the correct result.
     */
    public IBinder asBinder();
}

這裏只是提供了一個必須實現的方法asBinder()，它會返回與IInterface接口關聯的IBinder對象。

在IPerson.java中，asBinder方法仍然是抽象方法，不必去實現，IPerson的主要作用是提供接口的抽象類，真正的實現在它的子類Stub中。

2. 抽象方法eat

這個是一個待實現的抽象方法，最終是由Server端的調用者實現的，在該例中，實在PersionService中實現的：

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new IPerson.Stub() {
            @Override
            public boolean eat(String food) throws RemoteException {
                Log.d("PersionService", "this is Server");
                Log.d("PersionService", "Persion eat " + food);
                return true;
            }
        };
    }

3. 內部類Stub

這個內部類是實現IPC的主要邏輯，所有的外部使用，通常都是通過對它的調用來實現的。

Stub類繼承了Binder類，並實現了IPerson接口。

構造方法

Stub的實例對象實在PersonServer端創建的，即它是在Server端進行實例化的。

它的構造方法：

    private static final java.lang.String DESCRIPTOR = "com.testaidl.IPerson";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }

直接調用了父類Binder的attachInterface方法：

    public void attachInterface(@Nullable IInterface owner, @Nullable String descriptor) {
        mOwner = owner;
        mDescriptor = descriptor;
    }

這裏把當前對象和一個描述字符串賦值給相應變量，以便以後查找時使用。

asInterface方法

asInterface方法，返回一個IPerson對象，Client端獲取服務對象的時候，調用的就是該方法：

mService = IPerson.Stub.asInterface(iBinder);

asInterface方法實在Client端進行調用的，它返回一個PersonServer服務在Client端的一個代理對象。

我們來看它的邏輯實現：

    public static com.testaidl.IPerson asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.testaidl.IPerson))) {
        return ((com.testaidl.IPerson)iin);
      }
      return new com.testaidl.IPerson.Stub.Proxy(obj);
    }

邏輯解析：

如果參數obj爲null則return null。obj是一個IBinder對象，obj是onServiceConnected方法的參數，代表了連接服務成功後的返回參數，如果是同進程，則該對象就是IPerson這個服務的實例，如果是跨進程，則它是IPerson在Client的遠程代理對象。
如果參數obj不爲空，則嘗試通過obj.queryLocalInterface(DESCRIPTOR)獲取IPerson服務對象的實例，如果成功則直接返回該實例。此處不會真正跨進程。
最後，創建一個IPersion服務的代理對象（在客戶端的代理對象）IPerson.Stub.Proxy，然後返回它，作爲跨進程通信時，IPersion的代理引用。

queryLocalInterface的實現

queryLocalInterface方法用來查詢當前進程中是否存在對應的服務，如果當前進程中存在，則代表是本進程調用，不涉及跨進程，直接返回對應的服務引用即可。

    public @Nullable IInterface queryLocalInterface(@NonNull String descriptor) {
        if (mDescriptor != null && mDescriptor.equals(descriptor)) {
            return mOwner;
        }
        return null;
    }

mOwner是在Stub的構造方法中賦值的，如果PersonServer服務提供者和Client服務使用者都在同一個進程，則mOwner必然不爲空。

接下來就剩下跨進程的情況了，我們來分析Proxy這個內部類。

4. Stub的內部類Proxy

Proxy類在Client端創建，作爲遠程Service端在Client端的一個代理類，協助訪問遠程服務。Proxy類實現了IPerson接口。

Proxy的構造方法

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

這裏保存了，服務連接成功後由onServiceConnected方法傳遞過來的遠程Server的IBinder對象。

eat方法

當Client通過Proxy對象調用IPerson的eat方法時，eat方法內部會通過Proxy創建時保存的遠程IBinder對象來進行遠程調用。

      static final int TRANSACTION_eat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    
      @Override public boolean eat(java.lang.String food) 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(food);
          boolean _status = mRemote.transact(Stub.TRANSACTION_eat, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().eat(food);
          }
          _reply.readException();
          _result = (0!=_reply.readInt());
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      public static com.testaidl.IPerson sDefaultImpl;
    }

TRANSACTION_eat值在跨進程調用時會使用，這裏注意一下。

邏輯解析：

創建一個Parcel作爲eat遠程方法的輸入參數。
創建一個Parcel作爲eat遠程方法的返回值。
調用遠程IBinder對象（這裏其實也是一個代理對象，不過我們可以看做是遠程IBinder對象）的transact()方法，把遠程方法eat的唯一標識、參數、返回值引用、是否同步幾個對象作爲參數傳遞給transact()方法。
遠程調用完成後，獲取調用結果，處理錯誤等信息，最後取出遠程方法的返回值並直接返回。

遠程調用過程解析

經過以上分析，我們基本明白了遠程服務調用的整個過程，但是在這裏，還有一點是系統內部實現的，也就是遠程調用transact等相關邏輯的處理過程。我們接下來詳細分析一下。

boolean _status = mRemote.transact(Stub.TRANSACTION_eat, _data, _reply, 0);

調用遠程代理對象的transact方法，該方法是在Binder類中實現的，實現邏輯如下：

android.os.Binder

    public final boolean transact(int code, @NonNull Parcel data, @Nullable 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;
    }

到了這裏，當前的調用進程已經由Client端轉到了PersonServer端了，轉換過程由Binder底層幫我們實現了，這裏可以簡單的認爲是在遠程調用即可。

這裏調用了onTransact方法進行處理：
com.testaidl.IPerson#Stub

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

這裏讀取了由Client端傳來的參數，並調用真正的IPerson的eat方法實現，最終將結果返回。

eat實現代碼：
com.example.simpledemo.PersionService

    public IBinder onBind(Intent intent) {
        return new IPerson.Stub() {
            @Override
            public boolean eat(String food) throws RemoteException {
                Log.d("PersionService", "this is Server");
                Log.d("PersionService", "Persion eat " + food);
                return true;
            }
        };
    }

真正的遠程接口實現就是在PersionService類中的這個IPerson.Stub對象。

小結

本文從實踐的角度，詳細分析了Service實現跨進程調用的具體實現，以及調用過程、原理分析。

調用過程可概括爲：

Service跨進程提供服務需要通過AIDL來實現（底層實際上使用的是Binder）。
Client端通過PersionService綁定一個遠程Service。
綁定成功後Client通過ServiceConnection的onServiceConnected方法獲取到遠程服務的本地IBinder代理對象。
Client通過遠程服務IBinder代理對象獲得服務接口（IPerson）在Client端的代理對象（如果是同一個進程則直接返回IBidner服務對象）。
Client調用遠程代理對象的eat方法，底層通過Binder驅動，調用到Server端的transact方法。
Server端的transact方法又調用了IPerson.Stub的onTransact方法。
Server端的onTransact方法調用了eat方法的最終實現——PersionService類中的創建的IPerson.Stub對象。

Android Service的跨進程通信實戰&Service/AIDL遠程調用過程解析（Android Q）

Service的跨進程通信實戰

PersonServer端實現

實現AIDL

實現Service

Client端

步驟分析：

注意

Service/AIDL遠程調用過程解析

IPerson.aidl

1. 接口IInterface

2. 抽象方法eat

3. 內部類Stub

構造方法

asInterface方法

邏輯解析：

queryLocalInterface的實現

4. Stub的內部類Proxy

Proxy的構造方法

eat方法

邏輯解析：

遠程調用過程解析

小結

SQL優化-20231016

AOSP源碼同步過程（完整教程）

移動零（Java的2種算法實現）

兩數之和 II - 輸入有序數組（Java實現）

Java、Android的異常處理原理&Android Crash捕獲、分發及處理原理+實戰詳解

移除元素（Java算法實現）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結