Android多进程之手动编写Binder类

简介:

Android多进程系列

分析系统生成的Binder类

package com.xxq2dream.aidl;

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

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

        /**
         * 用于将服务端的Binder对象转换成客户端所需要的AIDL接口类型的对象
         */
        public static com.xxq2dream.aidl.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            //这里通过instanceof方法判断是否是跨进程,如果客户端和服务端位于同一进程,则返回的是服务端的Stub对象本身,不会调用跨进程的transact方法
            if (((iin != null) && (iin instanceof com.xxq2dream.aidl.IBookManager))) {
                return ((com.xxq2dream.aidl.IBookManager) iin);
            }
            //如果客户端和服务端不在同一个进程中,那么返回的是系统封装好的Stub.Proxy代理对象,客户端调用会走transact方法发起跨进程请求
            return new com.xxq2dream.aidl.IBookManager.Stub.Proxy(obj);
        }

        //返回当前Binder对象
        @Override
        public android.os.IBinder asBinder() {
            return this;
        }

        /**
         * 运行在服务端的Binder线程池中
         *
         * @param code 要运行的方法标识
         * @param data 客户端传递过来的参数
         * @param reply 回传给客户端的数据
         * @param flags
         * @return true 表示执行成功;false,执行失败,客户端的请求失败
         * @throws RemoteException
         */
        @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_getBookList: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.xxq2dream.aidl.Book> _result = this.getBookList();
                    reply.writeNoException();
                    //将结果写入reply返回
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.xxq2dream.aidl.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.xxq2dream.aidl.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.xxq2dream.aidl.IBookManager {
            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;
            }

            /**
             * 运行在客户端的Binder线程池中
             * 当客户端和服务端不在同一个进程中时,通过上面的asInterface方法返回的就是这个Proxy对象
             * 调用服务端的方法就是调用这里对应的方法,最终走的是transact方法发起远程过程调用
             *
             * @return
             * @throws RemoteException
             */
            @Override
            public java.util.List<com.xxq2dream.aidl.Book> getBookList() throws android.os.RemoteException {
                //用于向服务端传递参数
                android.os.Parcel _data = android.os.Parcel.obtain();
                //用于接收服务端传回来的结果
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.xxq2dream.aidl.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    //发起远程过程调用请求,同时当前线程挂起,服务端的onTransact方法会被调用
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    //上述调用过程返回后,当前线程继续执行,从reply中取出结果返回
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.xxq2dream.aidl.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public void addBook(com.xxq2dream.aidl.Book book) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((book != null)) {
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

        //接口的标识
        static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    }
    
    //提供的接口
    public java.util.List<com.xxq2dream.aidl.Book> getBookList() throws android.os.RemoteException;

    public void addBook(com.xxq2dream.aidl.Book book) throws android.os.RemoteException;

}

动手编写Binder类

  • 从上面的分析可以看出Binder类主要可以分为2个部分,一个是Stub类,也就是真正的Binder类;另一个就是AIDL接口
抽取出AIDL接口
public interface IBookManager extends IInterface {

    static final String DESCRIPTOR = "com.xxq2dream.manualbinder.IBookManager";

    static final int TRANSACTION_getBookList = IBinder.FIRST_CALL_TRANSACTION + 0;
    static final int TRANSACTION_addBook = IBinder.FIRST_CALL_TRANSACTION + 1;
    <!--注释1-->
    <!--static final int TRANSACTION_registerListener= IBinder.FIRST_CALL_TRANSACTION + 2;-->
    <!--static final int TRANSACTION_unRegisterListener= IBinder.FIRST_CALL_TRANSACTION + 3;-->

    public List<Book> getBookList() throws RemoteException;
    public void addBook(Book book) throws RemoteException;
    <!--注释2-->
    <!--void registerListener(IOnNewBookArrivedListener listener) throws RemoteException;-->
    <!--void unRegisterListener(IOnNewBookArrivedListener listener) throws RemoteException;-->
}
实现Stub类和Stub类的代理类
  • 这个和上面自动生成的代码大部分都是一样的
public class BookManagerImpl extends Binder implements IBookManager {
    private static final String TAG = "BookManagerImpl";

    public BookManagerImpl() {
        Log.e(TAG, "attachInterface-->"+ System.currentTimeMillis());
        this.attachInterface(this,DESCRIPTOR);
    }

    /**
     * Cast an IBinder object into an com.xxq2dream.IBookManager interface,
     * generating a proxy if needed.
     */
    public static IBookManager asInterface(IBinder obj) {
        if ((obj == null)) {
            return null;
        }
        android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
        if (((iin != null) && (iin instanceof IBookManager))) {
            Log.e(TAG, "asInterface");
            return ((IBookManager) iin);
        }
        Log.e(TAG, "asInterface Proxy-->"+ System.currentTimeMillis());
        return new BookManagerImpl.Proxy(obj);
    }

    /**
     * 运行在服务端的Binder线程池中
     *
     * @param code 要运行的方法标识
     * @param data 客户端传递过来的参数
     * @param reply 回传给客户端的数据
     * @param flags
     * @return true 表示执行成功;false,执行失败,客户端的请求失败
     * @throws RemoteException
     */
    @Override
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
        Log.e(TAG, "onTransact-->"+System.currentTimeMillis());

        switch (code) {
            case INTERFACE_TRANSACTION: {
                Log.e(TAG, "INTERFACE_TRANSACTION-->"+ System.currentTimeMillis());
                reply.writeString(DESCRIPTOR);
                return true;
            }
            case TRANSACTION_getBookList: {
                Log.e(TAG, "TRANSACTION_getBookList-->"+ System.currentTimeMillis());

                data.enforceInterface(DESCRIPTOR);
                List<Book> result = this.getBookList();
                reply.writeNoException();
                reply.writeTypedList(result);
                return true;
            }
            case TRANSACTION_addBook: {
                Log.e(TAG, "TRANSACTION_addBook-->"+ System.currentTimeMillis());

                data.enforceInterface(DESCRIPTOR);
                Book arg0;
                if (0 != data.readInt()) {
                    arg0 = Book.CREATOR.createFromParcel(data);
                }else {
                    arg0 = null;
                }
                this.addBook(arg0);
                reply.writeNoException();
                return true;
            }
            <!--注释6-->
            <!--case TRANSACTION_registerListener: {-->
            <!--    Log.e(TAG, "TRANSACTION_registerListener-->" +System.currentTimeMillis());-->
            <!--    data.enforceInterface(DESCRIPTOR);-->
            <!--    IOnNewBookArrivedListener arg0;-->
            <!--    arg0 = OnNewBookArrivedListenerImpl.asInterface(data.readStrongBinder());-->
            <!--    this.registerListener(arg0);-->
            <!--    reply.writeNoException();-->
            <!--    return true;-->
            <!--}-->
            <!--case TRANSACTION_unRegisterListener: {-->
            <!--    Log.e(TAG, "TRANSACTION_unRegisterListener-->" +System.currentTimeMillis());-->
            <!--    data.enforceInterface(DESCRIPTOR);-->
            <!--    IOnNewBookArrivedListener arg0;-->
            <!--    arg0 = OnNewBookArrivedListenerImpl.asInterface(data.readStrongBinder());-->
            <!--    this.unRegisterListener(arg0);-->
            <!--    reply.writeNoException();-->
            <!--    return true;-->
            <!--}-->
        }
        return super.onTransact(code, data, reply, flags);
    }

    @Override
    public List<Book> getBookList() throws RemoteException {
        return null;
    }

    @Override
    public void addBook(Book book) throws RemoteException {

    }

    <!--注释5-->
    <!--@Override-->
    <!--public void registerListener(IOnNewBookArrivedListener listener) {-->

    <!--}-->

    <!--@Override-->
    <!--public void unRegisterListener(IOnNewBookArrivedListener listener) {-->

    <!--}-->

    /**
     * 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.
     */
    @Override
    public IBinder asBinder() {
        Log.e(TAG, "asBinder-->"+ System.currentTimeMillis());
        return this;
    }

    private static class Proxy implements IBookManager {

        private IBinder mRemote;

        Proxy(IBinder remote) {
            mRemote = remote;
        }

        public String getInterfaceDescriptor() {
            return DESCRIPTOR;
        }

        /**
         * 运行在客户端的Binder线程池中
         *
         * @return
         * @throws RemoteException
         */
        @Override
        public List<Book> getBookList() throws RemoteException {
            Log.e(TAG, "Proxy-->getBookList-->"+ System.currentTimeMillis());

            //用于向服务端传递参数
            Parcel data = Parcel.obtain();
            //用于接收服务端传回来的结果
            Parcel reply = Parcel.obtain();
            List<Book> result;
            try {
                data.writeInterfaceToken(DESCRIPTOR);
                //发起远程过程调用请求,同时当前线程挂起,服务端的onTransact方法会被调用
                mRemote.transact(TRANSACTION_getBookList, data, reply, 0);
                //上述调用过程返回后,当前线程继续执行,从reply中取出结果返回
                reply.readException();
                result = reply.createTypedArrayList(Book.CREATOR);
            } finally {
                reply.recycle();
                data.recycle();
            }
            return result;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            Log.e(TAG, "Proxy-->addBook-->"+ System.currentTimeMillis());

            //用于向服务端传递参数
            Parcel data = Parcel.obtain();
            //用于接收服务端传回来的结果
            Parcel reply = Parcel.obtain();
            try {
                data.writeInterfaceToken(DESCRIPTOR);
                if (book != null) {
                    data.writeInt(1);
                    book.writeToParcel(data,0);
                }else {
                    data.writeInt(0);
                }
                mRemote.transact(TRANSACTION_addBook, data, reply, 0);
                reply.readException();
            }finally {
                reply.recycle();
                data.recycle();
            }
        }
        
        <!--注释3-->
        <!--@Override-->
        <!--public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException{-->
        <!--    Log.e(TAG, "Proxy-->registerListener-->"+ System.currentTimeMillis());-->

        <!--    //用于向服务端传递参数-->
        <!--    Parcel data = Parcel.obtain();-->
        <!--    //用于接收服务端传回来的结果-->
        <!--    Parcel reply = Parcel.obtain();-->
        <!--    try {-->
        <!--        data.writeInterfaceToken(DESCRIPTOR);-->
        <!--        data.writeStrongBinder((listener != null)?(listener.asBinder()) : (null));-->
        <!--        mRemote.transact(TRANSACTION_registerListener, data, reply, 0);-->
        <!--        reply.readException();-->
        <!--    }finally {-->
        <!--        reply.recycle();-->
        <!--        data.recycle();-->
        <!--    }-->

        <!--}-->
        
        <!--注释4-->
        <!--@Override-->
        <!--public void unRegisterListener(IOnNewBookArrivedListener listener) throws RemoteException{-->
        <!--    Log.e(TAG, "Proxy-->unRegisterListener-->"+ System.currentTimeMillis());-->

        <!--    //用于向服务端传递参数-->
        <!--    Parcel data = Parcel.obtain();-->
        <!--    //用于接收服务端传回来的结果-->
        <!--    Parcel reply = Parcel.obtain();-->
        <!--    try {-->
        <!--        data.writeInterfaceToken(DESCRIPTOR);-->
        <!--        data.writeStrongBinder((listener != null)?(listener.asBinder()) : (null));-->
        <!--        mRemote.transact(TRANSACTION_unRegisterListener, data, reply, 0);-->
        <!--        reply.readException();-->
        <!--    }finally {-->
        <!--        reply.recycle();-->
        <!--        data.recycle();-->
        <!--    }-->
        <!--}-->

        /**
         * 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.
         */
        @Override
        public IBinder asBinder() {
            Log.e(TAG, "Proxy-->asBinder-->"+ System.currentTimeMillis());
            return mRemote;
        }
    }
}
  • 以上就是我们自己动手写的Binder类,没有使用系统的方法,也不用编写AIDL文件
扩展我们的Binder类
  • 比如我们要实现当服务端有新书时就通知客户端,也就是观察者模式。我们需要在客户端绑定服务端后绑定监听的接口,还要提供解绑的接口,上面的代码中标记的注释1-6就是扩展Binder类的步骤
  • 当然,由于AIDL中不支持普通的接口,只支持AIDL接口,我们要增加服务端的AIDL接口服务,像上面的代码里那样传递的接口肯定就是AIDL实现的接口,也就是
  • 所以我们还得增加AIDL接口,同样的我们可以通过编写AIDL文件然后由系统自动生成,也可以手动编写。这里我们还是以手动的方式编写
  • AIDL接口IOnNewBookArrivedListener
public interface IOnNewBookArrivedListener extends IInterface {
    static final String DESCRIPTOR = "com.xxq2dream.aidl.IOnNewBookArrivedListener";

    static final int TRANSACTION_onNewBookArrived = IBinder.FIRST_CALL_TRANSACTION + 0;

    void onNewBookArrived(Book book) throws RemoteException;
}
  • 对应的Binder类
public class OnNewBookArrivedListenerImpl extends Binder implements IOnNewBookArrivedListener {
    private static final String TAG = "NewBookArrivedListener";

    public OnNewBookArrivedListenerImpl() {
        Log.e(TAG, "attachInterface-->"+ System.currentTimeMillis());
        this.attachInterface(this,DESCRIPTOR);
    }

    public static IOnNewBookArrivedListener asInterface (IBinder obj) {
        if ((obj == null)) {
            return null;
        }
        android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
        if (((iin != null) && (iin instanceof IOnNewBookArrivedListener))) {
            Log.e(TAG, "asInterface");
            return ((IOnNewBookArrivedListener) iin);
        }
        Log.e(TAG, "asInterface Proxy-->"+ System.currentTimeMillis());
        return new OnNewBookArrivedListenerImpl.Proxy(obj);
    }

    /**
     * 运行在服务端的Binder线程池中
     *
     * @param code 要运行的方法标识
     * @param data 客户端传递过来的参数
     * @param reply 回传给客户端的数据
     * @param flags
     * @return true 表示执行成功;false,执行失败,客户端的请求失败
     * @throws RemoteException
     */
    @Override
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
        Log.e(TAG, "onTransact-->"+System.currentTimeMillis());

        switch (code) {
            case INTERFACE_TRANSACTION: {
                Log.e(TAG, "INTERFACE_TRANSACTION-->"+ System.currentTimeMillis());
                reply.writeString(DESCRIPTOR);
                return true;
            }
            case TRANSACTION_onNewBookArrived: {
                Log.e(TAG, "TRANSACTION_onNewBookArrived-->"+ System.currentTimeMillis());

                data.enforceInterface(DESCRIPTOR);
                Book _arg0;
                if ((0 != data.readInt())) {
                    _arg0 = Book.CREATOR.createFromParcel(data);
                } else {
                    _arg0 = null;
                }
                this.onNewBookArrived(_arg0);
                reply.writeNoException();
                return true;
            }
        }
        return super.onTransact(code, data, reply, flags);
    }

    @Override
    public void onNewBookArrived(Book book) {

    }

    /**
     * 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.
     */
    @Override
    public IBinder asBinder() {
        return this;
    }

    private static class Proxy implements IOnNewBookArrivedListener {

        private IBinder mRemote;

        Proxy(IBinder remote) {
            mRemote = remote;
        }

        public String getInterfaceDescriptor() {
            return DESCRIPTOR;
        }

        /**
         * 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.
         */
        @Override
        public IBinder asBinder() {
            Log.e(TAG, "Proxy-->asBinder-->"+ System.currentTimeMillis());
            return mRemote;
        }

        @Override
        public void onNewBookArrived(Book newBook) throws RemoteException{
            Log.e(TAG, "onNewBookArrived-->" + System.currentTimeMillis());
            android.os.Parcel _data = android.os.Parcel.obtain();
            android.os.Parcel _reply = android.os.Parcel.obtain();
            try {
                _data.writeInterfaceToken(DESCRIPTOR);
                if ((newBook != null)) {
                    _data.writeInt(1);
                    newBook.writeToParcel(_data, 0);
                } else {
                    _data.writeInt(0);
                }
                mRemote.transact(TRANSACTION_onNewBookArrived, _data, _reply, 0);
                _reply.readException();
            } finally {
                _reply.recycle();
                _data.recycle();
            }
        }
    }
}
Binder传递AIDL接口
  • 通过上面的代码我们可以看到,和传递普通的Parcelable序列化对象不同的是,在Proxy类中要通过writeStrongBinder方法将AIDL接口加入到参数中去
  • 在服务端的onTransact方法中要通过对应的Binder类的asInterface方法获得传递过来的接口参数
IOnNewBookArrivedListener arg0;
arg0 = OnNewBookArrivedListenerImpl.asInterface(data.readStrongBinder());
结语
  • 通过手动编写Binder类,可以让我们更好地理解Binder的工作机制
  • 扩展了Binder类以后,下一步我们还需要相应的改造客户端和服务端,以便增加注册监听的功能

欢迎关注我的微信公众号,和我一起学习一起成长!
AntDream

目录
相关文章
|
1月前
|
JSON 调度 数据库
Android面试之5个Kotlin深度面试题:协程、密封类和高阶函数
本文首发于公众号“AntDream”,欢迎微信搜索“AntDream”或扫描文章底部二维码关注,和我一起每天进步一点点。文章详细解析了Kotlin中的协程、扩展函数、高阶函数、密封类及`inline`和`reified`关键字在Android开发中的应用,帮助读者更好地理解和使用这些特性。
20 1
|
1月前
|
存储 Linux Android开发
Android底层:通熟易懂分析binder:1.binder准备工作
本文详细介绍了Android Binder机制的准备工作,包括打开Binder驱动、内存映射(mmap)、启动Binder主线程等内容。通过分析系统调用和进程与驱动层的通信,解释了Binder如何实现进程间通信。文章还探讨了Binder主线程的启动流程及其在进程通信中的作用,最后总结了Binder准备工作的调用时机和重要性。
Android底层:通熟易懂分析binder:1.binder准备工作
|
15天前
|
前端开发 Java 测试技术
android MVP契约类架构模式与MVVM架构模式,哪种架构模式更好?
android MVP契约类架构模式与MVVM架构模式,哪种架构模式更好?
23 0
|
1月前
|
前端开发 Java 测试技术
android MVP契约类架构模式与MVVM架构模式,哪种架构模式更好?
android MVP契约类架构模式与MVVM架构模式,哪种架构模式更好?
21 2
|
2月前
|
Java Android开发 数据安全/隐私保护
Android中多进程通信有几种方式?需要注意哪些问题?
本文介绍了Android中的多进程通信(IPC),探讨了IPC的重要性及其实现方式,如Intent、Binder、AIDL等,并通过一个使用Binder机制的示例详细说明了其实现过程。
312 4
|
3月前
|
API Android开发
Android P 性能优化:创建APP进程白名单,杀死白名单之外的进程
本文介绍了在Android P系统中通过创建应用进程白名单并杀死白名单之外的进程来优化性能的方法,包括设置权限、获取运行中的APP列表、配置白名单以及在应用启动时杀死非白名单进程的代码实现。
62 1
|
3月前
|
Android开发 开发者 Kotlin
Android 多进程情况下判断应用是否处于前台或者后台
本文介绍在多进程环境下判断Android应用前后台状态的方法。通过`ActivityManager`和服务信息`RunningAppProcessInfo`可有效检测应用状态,优化资源使用。提供Kotlin代码示例,帮助开发者轻松集成。
268 8
|
3月前
|
Java 测试技术 Android开发
Android项目架构设计问题之使用反射调用类的私有方法如何解决
Android项目架构设计问题之使用反射调用类的私有方法如何解决
29 0
|
4月前
|
缓存 安全 Java
Android深入Binder拦截问题分析
【7月更文挑战第1天】Android Binder 拦截可实现虚拟化、测试、SDK检测、逆向分析及ROM扩展。通过Java层aidl代理,利用IBinder接口规范来拦截通信。拦截步骤包括:替换Binder服务缓存对象,如ActivityManagerService;代理ServiceManager以控制服务获取。此操作需系统权限,可能涉及安全风险和版本差异,非必要时应谨慎。
|
5月前
|
安全 Android开发 Kotlin
Android面试题之Kotlin的几种常见的类
这篇文章探讨了Kotlin编程语言中的初始化顺序、延迟初始化、惰性初始化、`lateinit`与`by lazy`的区别、初始化注意事项、继承、嵌套类、数据类、单例类和枚举类的使用,以及密封类的概念。文中通过示例代码详细解释了各种特性,并提醒读者关注初始化顺序和线程安全问题。同时,鼓励读者关注作者的公众号“AntDream”获取更多相关文章。
43 1

相关实验场景

更多