Android12_IPC方式之AIDL

Messenger是以串行的方式处理客户端发来的消息；

如果大量消息同时发送到服务端，服务端仍然只能一个个处理；

如果有大量的并发请求，用Messenger就不合适了；

Messenger主要作用是传递消息，有时候我们需要跨进程调用服务端的方法；

这就需要AIDL来实现跨进程调用服务端的方法；

1、服务端

创建一个Service来监听服务端的连接请求；

创建一个AIDL文件，将暴露给客户端的接口在这个AIDL文件中声明；

最后在Service中实现这个AIDL接口；

2、客户端

首先需要绑定服务端的Service，绑定成功之后，将服务端返回的Binder对象转成AIDL接口所属的类型；

接着就可以调用AIDL中的方法了；

3、AIDL接口的创建

为了方便AIDL的开发，建议把所有和AIDL相关的类和文件全部放入同一个包中；

这样做的好处是：当客户端要用时，可以直接把整个包复制到客户端工程中；

 

package com.example.aidltest_server;

import android.os.Parcel;
import android.os.Parcelable;

public class Book implements Parcelable {
    private String name;

    public Book(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    @Override
    public String toString(){
        return "book name: "+name;
    }

    @Override
    public int describeContents(){
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest,int flags){
        dest.writeString(this.name);
    }

    public void readFromParcel(Parcel dest){
        name = dest.readString();
    }

    protected Book(Parcel in){
        this.name = in.readString();
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel source) {
            return new Book(source);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };
}

AIDL经常要用到Parcelable对象，除了定义一个类，比如Book类去实现Parcelable接口之外；

还需要创建一个和它同名的AIDL文件，并在其中声明为Parcelable类型；如上面所示；

服务端还要声明一个BookController.aidl

其具体实现放在了Service中；

// BookController.aidl
package com.example.aidltest_server;
import com.example.aidltest_server.Book;
import com.example.aidltest_server.AIDLCallBack;
// Declare any non-default types here with import statements

interface BookController {
    List<Book> getBookList();
    void addBookInOut(inout Book book);
    void registerCallback(in AIDLCallBack cb);
    void unregisterCallBack(in AIDLCallBack cb);
}

AIDLCallBack.aidl

这个是客户端提供给服务端的回调接口，在服务端中声明，但其具体实现由客户端提供；

// AIDLCallBack.aidl
package com.example.aidltest_server;

// Declare any non-default types here with import statements

interface AIDLCallBack {
    void OnReply();
}

4、服务端的实现

package com.example.aidltest_server;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

public class AIDLService extends Service {

    private static final String TAG = "Server";
    private static final String SERVICE_ACTION = "com.example.aidltest_server.AIDLTEST";
    private List<Book> bookList;
    //远程回调函数注册机制，首先定义一个回调函数列表；
    private RemoteCallbackList<AIDLCallBack> mCallBackList = new RemoteCallbackList<>();

    public AIDLService() {
        Log.d(TAG, "AIDLService: ");
    }

    @Override
    public void onCreate(){
        super.onCreate();
        Log.d(TAG, "onCreate: ");
        bookList = new ArrayList<>();
        initData();
    }

    @Override
    public IBinder onBind(Intent intent) {    //一旦服务端和客户端建立连接，返回BookController AIDL的实现类stub
        Log.d(TAG, "onBind: ");
        if(intent.getAction().equals(SERVICE_ACTION )){
            Log.d(TAG, "onBind Return ibinder: ");
            return stub;
        }
        Log.d(TAG, "onBind Return null: ");
        return null;
    }

    @Override
    public void onDestroy(){
        Log.d(TAG, "onDestroy: ");
    }

    private void initData(){
        Book book1 = new Book("或者");
        Book book2 = new Book("活着");
        Book book3 = new Book("火者");
        bookList.add(book1);
        bookList.add(book2);
        bookList.add(book3);
    }

    private final BookController.Stub stub = new BookController.Stub() {   //这里是AIDL接口的实现
        @Override
        public List<Book> getBookList() throws RemoteException{
            return bookList;
        }

        @Override
        public void addBookInOut(Book book) throws RemoteException{
            if(book != null){
                bookList.add(book);
                sendResponse();
            }
            else
            {
                Log.e(TAG,"接收到空对象");
            }
        }

        @Override
        public void registerCallback(AIDLCallBack cb){   //客户端会调用该接口注册回调函数
            if(cb != null){
                mCallBackList.register(cb);
            }
        }

        @Override
        public void unregisterCallBack(AIDLCallBack cb){  //客户端调用该接口去注册回调函数
            if(cb != null){
                mCallBackList.unregister(cb);
            }
        }
    };

    private void sendResponse(){              //服务端调用回调函数的封装函数
        int len = mCallBackList.beginBroadcast();
        for(int i = 0; i<len; i++){
            try{
                mCallBackList.getBroadcastItem(i).OnReply();
            }catch(RemoteException e){
                e.printStackTrace();
            }
        }
        mCallBackList.finishBroadcast();
    }
}

5、客户端的实现

package com.example.aidltest_client;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;

import com.example.aidltest_server.AIDLCallBack;
import com.example.aidltest_server.Book;
import com.example.aidltest_server.BookController;

import java.util.List;

public class MainActivity extends AppCompatActivity {

    private final String TAG = "Client";

    private BookController bookController;

    private boolean connected;

    private List<Book> bookList;
    private AIDLCallBack callback = new AIDLCallBack.Stub() {   //AIDLCallBack  AIDL接口的实现
        @Override
        public void OnReply() throws RemoteException {
            Log.e(TAG,"CallBack from Server");
        }
    };

    private ServiceConnection serviceConnection = new ServiceConnection() {  //服务连接类，客户端必须重写一些回调函数
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {   //连接-回调函数
            Log.e(TAG,"回调了onServiceConnected");
            bookController = BookController.Stub.asInterface(service);
            try {
                bookController.registerCallback(callback);         //建立连接时，注册回调函数
            }catch(RemoteException e){
                e.printStackTrace();
            }
            connected = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {             //断开连接-回调函数
            connected = false;
        }
    };

    private View.OnClickListener clickListener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            switch (v.getId()){
                case R.id.btn_getBookList:
                    if(connected){
                        try{
                            bookList = bookController.getBookList();
                        }catch (RemoteException e){
                            e.printStackTrace();
                        }
                        log();
                    }
                    break;
                case R.id.btn_addBook_inout:
                    if(connected){
                        Book book = new Book("new Book");
                        try{
                            bookController.addBookInOut(book);
                            Log.e(TAG,"向服务器以Inout的方式添加了一本新书");
                            Log.e(TAG,"新书名:"+book.getName());
                        }catch(RemoteException e){
                            e.printStackTrace();
                        }
                    }
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.btn_getBookList).setOnClickListener(clickListener);
        findViewById(R.id.btn_addBook_inout).setOnClickListener(clickListener);
        bindService();
    }

    @Override
    protected void onDestroy(){
        super.onDestroy();
        if(connected){
            try {
                bookController.unregisterCallBack(callback);     //申请断开连接前，先去注册回调函数
            }catch (RemoteException e){
                e.printStackTrace();
            }
            unbindService(serviceConnection);                //断开连接
        } 
    }

    private void bindService(){
        Intent intent = new Intent();
        intent.setPackage("com.example.aidltest_server");
        intent.setAction("com.example.aidltest_server.AIDLTEST");
        bindService(intent,serviceConnection, Context.BIND_AUTO_CREATE);  //对服务端发起连接请求
    }

    private void log(){
        for(Book book:bookList){
            Log.e(TAG,book.toString());
        }
    }
}

6、一些问题：

如果通过AIDL方式远程调用耗时任务，可能会导致客户端产生ANR；所以要注意客户端如果要调用耗时任务时，可以把调用放在非UI线程中进行；

还有一种情况，Binder可能意外死亡，往往是由于服务端进程意外停止了；这时候我们需要重新连接服务，有两种方法：

1、给Binder设置DeathRecipient监听，当Binder死亡时，我们会收到binderDied回调；->在Binder的线程池中被回调

　　onServiceConnected函数中，当客户端绑定远程服务时，给binder设置死亡代理，当Binder死亡时，客户端会收到通知，可以在该通知中重连远程服务；

        private IBinder.DeathRecipient mBinderPoolDeathRecipient = new IBinder.DeathRecipient() {
            @Override
            public void binderDied() {
                Log.w(TAG, "binderDied: ");
                mBinderPool.asBinder().unlinkToDeath(mBinderPoolDeathRecipient, 0);
                mBinderPool = null;
                connectBinderPoolService();
            }
        };
    };

2、在onServiceDisconnected中重连远程服务；->在客户端的UI线程被回调