关于 AIDL 的一些注意事项

2020-01-15 本文已影响0人 Joseph_L

AIDL

服务端创建一个 Service 监听客户端的链接请求，将 AIDL 的实现回调给客户端；

客户端通过 aidl 就可以直接调用服务端的方法
AIDL 的声明注意点：
- C/S 两端必须完全一致，包名都不能错，否则找不到
- AIDL 中支持的数据类型不多：
  - 基本数据类型、String、char
  - List 只支持 ArrayList，Map 只支持 HashMap，且每个元素都必须被 AIDL 所支持
    - AIDL 支持的其实是抽象的 List 和 Map，并在最终返回 ArrayList 和 HashMap
    - 在 Server 方法中，可以使用其他数据类型，比如 CopyOnWriteArrayList 和 ConcurrentHashMap
  - parcelable 对象（必须显示 import）
    - 必须声明一个同样的 aidl 文件，声明其为 parcelable 对象
  - AIDL 接口本身（必须显示 import）
- 除基本类型外，所有入参必须标明 in / out / inout
  - in 代表输入型参数，out 代表输出型参数，inout 表示输入输出型参数
- 只支持方法，不支持静态常量
- AIDL 的方法是在 Binder 线程池中执行的，所以一般需要处理线程同步问题
  - 使用 CopyOnWriteArrayList、ConcurrentHashMap、AtomicBoolean
- 如果有接口回调，从 binder 回调到 app
  - 使用 aidl 而不是普通接口
  - 注册、解注册需要使用 RemoteCallbackListener，而不是常规方式
    - 注意 RemoteCallbackListener 的使用，begin & finish 成对使用
- 可以使用权限或者包名的方式，在 onTransact 或者 onBind 方法中校验连接者

AIDL 代码

// IBookManager.aidl
package com.test.testaidl_1;
import com.test.testaidl_1.Book;
import com.test.testaidl_1.IOnNewBookArrivedListener;
interface IBookManager {
    List<Book> getBookList();
    void addBook(in Book book);
    void registerListener(IOnNewBookArrivedListener l);
    void unregisterListener(IOnNewBookArrivedListener l);
}

// Book.aidl.aidl
package com.test.testaidl_1;
parcelable Book;

服务端代码

public class BookManagerService extends Service {

    private static final String TAG = "bms";

    // 线程安全的布尔对象
    private AtomicBoolean mIsServiceDestroyed = new AtomicBoolean(false);

    // 线程安全的 List
    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();

    private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList
            = new RemoteCallbackList<>();

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {

        int check = checkCallingOrSelfPermission("ACCESS_BALABALA");
        if (check == PackageManager.PERMISSION_DENIED) {
            Log.e(TAG, "permission denied");
            return null;
        } else {
            Log.e(TAG, "permission granted");
        }

        return mBinder;
    }

    private Binder mBinder = new IBookManager.Stub() {
        @Override
        public List<Book> getBookList() throws RemoteException {
//            SystemClock.sleep(5000);
            return mBookList;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            mBookList.add(book);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener l) throws RemoteException {
            mListenerList.register(l);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                Log.e(TAG, "register list size " + mListenerList.getRegisteredCallbackCount());
            }
        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener l) throws RemoteException {
            mListenerList.unregister(l);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                Log.e(TAG, "register list size " + mListenerList.getRegisteredCallbackCount());
            }
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        new Thread(new ServiceWorker()).start();
    }

    private class ServiceWorker implements Runnable {
        @Override
        public void run() {
            while (!mIsServiceDestroyed.get()) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                int bookId = mBookList.size() + 1;
                Book newBook = new Book(bookId, "new Book#" + bookId);
                onNewBookArrived(newBook);
            }
        }
    }

    private void onNewBookArrived(Book newBook) {
             // 运行在 binder 线程池中
        SystemClock.sleep(6000);

        mBookList.add(newBook);
        int size = mListenerList.beginBroadcast();
        for (int i = 0; i < size; i++) {
            try {
                IOnNewBookArrivedListener broadcastItem = mListenerList.getBroadcastItem(i);
                if (broadcastItem != null) {
                     // 客户端回调，如果更新 UI，需要使用 handler 切换线程，否则会报错
                    broadcastItem.onNewBookArrived(newBook);
                }
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        mListenerList.finishBroadcast();
    }

}

客户端代码

public class MainActivity extends AppCompatActivity {

    public static final String TAG = "MainActivity";

    private IBookManager mBookManager;

    private MyListener myListener = new MyListener();

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


        Intent intent = new Intent(this, BookManagerService.class);
        bindService(intent, mConn, Context.BIND_AUTO_CREATE);

    }

    private ServiceConnection mConn = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mBookManager = IBookManager.Stub.asInterface(service);

            try {
                List<Book> bookList = mBookManager.getBookList();
                Log.e(TAG, "query book list, type is " + bookList.getClass().getCanonicalName());
                Log.e(TAG, "query book list: " + Arrays.toString(bookList.toArray()));

                mBookManager.addBook(new Book(3, "这是本新书"));
                Log.e(TAG, "new book");
                bookList = mBookManager.getBookList();
                Log.e(TAG, "query book list: " + Arrays.toString(bookList.toArray()));

                // 这是 UI 线程
                mBookManager.registerListener(myListener);

            } catch (RemoteException e) {
                e.printStackTrace();
            }

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }

    };

    public void testBinder(View view) {

        Toast.makeText(this,"999",Toast.LENGTH_SHORT).show();

         //  mBookManager.getBookList(); 模拟耗时操作
        // 若不放在子线程中，就会 ANR
        new Thread(){
            @Override
            public void run() {
                super.run();

                try {
                    List<Book> bookList = mBookManager.getBookList();
                    Log.e(TAG, "query book list: " + Arrays.toString(bookList.toArray()));

                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }.start();

    }

    private class MyListener extends IOnNewBookArrivedListener.Stub {
        @Override
        public void onNewBookArrived(Book book) throws RemoteException {
            // 此方法运行在 Binder 线程的线程池中
            // 如果在这里做操作，就会抛异常，不是在 Looper 线程
            Toast.makeText(MainActivity.this,
                    "666",Toast.LENGTH_SHORT).show();
            mHandler.obtainMessage(-1, book).sendToTarget();
        }
    }

    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == -1) {
                Log.e(TAG, "收到新书：" + msg.obj.toString());
            }
        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mBookManager != null && mBookManager.asBinder().isBinderAlive()) {
            try {
                mBookManager.unregisterListener(myListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(mConn);
    }
}

以这个 AIDL 实现为例，简单分析一下代码走向。

客户端发起绑定远程服务的请求，经过源码走向，会走向指定的服务信息；
服务或者为本地服务，或者为其他应用（远端服务），都会通过 onBind 方法将实例化好的 Binder 对象返回给客户端；
```
// Stub extends Binder
private Binder mBinder = new IBookManager.Stub() {}
```

然后代码就会走到客户端的 onServiceConnected 回调：

private ServiceConnection mConn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
      mBookManager = IBookManager.Stub.asInterface(service);
    }
}

具体我们来看一下系统自动生成的 IBookManager 的 java 类：

public interface IBookManager extends android.os.IInterface {

    public static abstract class Stub extends Binder implements IBookManager {

        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

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

        @Override
        public boolean onTransact(... ...) {
            switch (code) {
                case TRANSACTION_getBookList: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.ljt.testaidl_1.Book> _result = this.getBookList();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.ljt.testaidl_1.IBookManager {
            private android.os.IBinder mRemote;

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

            @Override
            public java.util.List<com.ljt.testaidl_1.Book> getBookList()  {
                Parcel _data = Parcel.obtain();
                Parcel _reply = Parcel.obtain();
                java.util.List<com.ljt.testaidl_1.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.ljt.testaidl_1.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
           
        }

        static final int TRANSACTION_getBookList = ... ...;
    }

    public java.util.List<com.ljt.testaidl_1.Book> getBookList();

}

Stub 类实际上就是个 Binder，用来进行序列化、反序列化操作；Proxy 是服务端在客户端的远程代理，当服务端不在本地时，才会使用到。

如果服务在本地，那在 service connect 的时候，Binder 就会找到 aidl 对应的本地实现，并将该对象返回回去；

如果服务不在本地，就会使用代理对象：

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

如果服务在本地，那之后的交互就很简单了，因为对应的实现类已经找到，直接用引用进行调用即可，涉及不到 binder 通信；

如果服务在远端，当用户发起方法调用时，会进入到 Proxy 的方法中：

public java.util.List<com.ljt.testaidl_1.Book> getBookList()  {
    Parcel _data = Parcel.obtain();
    Parcel _reply = Parcel.obtain();
    java.util.List<com.ljt.testaidl_1.Book> _result;
    try {
      _data.writeInterfaceToken(DESCRIPTOR);
      mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
      _reply.readException();
      _result = _reply.createTypedArrayList(com.ljt.testaidl_1.Book.CREATOR);
    } finally {
      _reply.recycle();
      _data.recycle();
    }
    return _result;
}

根据代码来看，当客户端发起调用时，会先获取两个 Parcel 对象，并且通过 transact 方法传递给服务端。

同时，客户端线程挂起，等待服务端返回数据；

public final boolean transact(int code, Parcel data, Parcel reply,
                              int flags) throws RemoteException {
  boolean r = onTransact(code, data, reply, flags);
  return r;
}

根据 Binder 源码可知，会回调到 onTransact 方法，也就是 Proxy 的 onTransact 方法：

@Override
public boolean onTransact(... ...) {
  switch (code) {
    case TRANSACTION_getBookList: {
      data.enforceInterface(DESCRIPTOR);
      java.util.List<com.ljt.testaidl_1.Book> _result = this.getBookList();
      reply.writeNoException();
      reply.writeTypedList(_result);
      return true;
    }
  }
  return super.onTransact(code, data, reply, flags);
}

经过 onTransact 方法的处理，会像 reply 的 parcel 对象中写入返回值，之后该方法返回 true 唤醒客户端，继续执行，从而完成整个调用。

以上，大概就是使用 AIDL 进行 binder 通信的过程。

关于 AIDL 的一些注意事项

AIDL

猜你喜欢

热点阅读