AIDL详解

最新推荐文章于 2022-02-08 16:45:42 发布
最新推荐文章于 2022-02-08 16:45:42 发布
阅读量1k 收藏
点赞数 1
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gangjindianzi/article/details/83512961
简单的AIDL实现

main文件夹下新建aidl包，注意包名一定要相同，定义接口
在这里插入图片描述

package com.example.aidldemo.aidl;
parcelable Book;
//~~~~~~~~~~~~~~~~~~~~~~~~
package com.example.aidldemo.aidl;
import  com.example.aidldemo.aidl.Book;//注意此处到导包
interface IBookManager {
    List<Book>getBookList();
    void addBook(in Book book);
}

同步一下，自动生成java文件
在这里插入图片描述

//服务端
public class BookMangerService extends Service {

    private static final String TAG = "BookMangerService";
    CopyOnWriteArrayList<Book> mBookList= new CopyOnWriteArrayList<Book>();

   private Binder mBinder= new IBookManager.Stub(){

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

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

       }
   };

    @Override
    public void onCreate() {
        super.onCreate();
        mBookList.add(new Book(1,"android"));
        mBookList.add(new Book(1,"ios"));
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

}
//~~~~~~~~~~设为远程
<service
            android:name=".aidl.BookMangerService"
            android:process=":remote"/>



//客户端
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private ServiceConnection conn=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IBookManager bookManager=IBookManager.Stub.asInterface(service);
            try {
                List<Book> bookList = bookManager.getBookList();
                Log.e(TAG, "onServiceConnected: getBookList type"
                        +bookList.getClass().getCanonicalName() );
                Log.e(TAG, "onServiceConnected: "+bookList.toString() );

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

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(this, BookMangerService.class);
        bindService(intent,conn,Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        unbindService(conn);
        super.onDestroy();

    }
}
Binder机制详解

binder是android中的一个类，实现Ibinder接口，从IPC角度来说，Binder是Android中的一种跨进程通信方式，从Framework角度看，Binder是ServiceManager连接各种Manager（ActivityManager，WindowManager）的桥梁，从应用层来说，Binder是客户端和服务端通信的媒介，Binder底层细节复杂，暂时不深入研究。Android开发中，Binder主要用在Service中。包括AIDL和Messenger。Service很简单，不跨进程，binderService，Service的Onbinder里面返会一个binder对象，activity的onServiceConnect方法可以获取这个binder

所有可以在binder中传输的借口都要继承Interface接口 通过上面这个类可以了解binder的工作机制。
内部类Stub继承binder实现接口。当客户端服务端同一个进程时，方法调用不会走transact，跨进程时，就需要这个transact了，这个逻辑由Stub内部代理Proxy完成。下面说明几个主要方法

asInterface
将服务端binder对象转换成客户端aidl接口类型的对象。如果同一个进程，返回Stub，如果跨进程，返回系统封装后的Stub.proxy

asBinder
返回当前Binder对象
onTransact
Proxy#getBookList
Proxy#addBook

稍复杂的aidl实现&& aidl难点 线程相关

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private static final int MESSAGE_BOOK_ARRIVED = 1;

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mRemoteBookManager = IBookManager.Stub.asInterface(service);
            try {
                /**
                 * 难点，客户端调用远程服务的方法时，被调用的方法运行在服务端的binder线程池中，
                 * 同时，客户端线程挂起，如果服务端方法耗时，可能会导致anr，
                 * 服务端方法若耗时，也不必开线程
                 *
                 */
                List<Book> bookList = mRemoteBookManager.getBookList();
                Log.e(TAG, "onServiceConnected: getBookList type"
                        + bookList.getClass().getCanonicalName());
                Log.e(TAG, "onServiceConnected: " + bookList.toString());
                mRemoteBookManager.addBook(new Book(3, "android 进阶"));
                Log.e(TAG, "onServiceConnected: " + mRemoteBookManager.getBookList().toString());
                mRemoteBookManager.registerListener(mOnBookArrivedListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }


        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };
    IOnNewBookArrivedListener.Stub mOnBookArrivedListener =
            new IOnNewBookArrivedListener.Stub() {
                /**
                 * 服务端调用客户端listener方法，被调用方法运行在binder线程池中，
                 * 只不过是客户端的线程池，因此主线程更新ui
                 * 如果此方法耗时，要确保服务端运行在非ui线程
                 * @param newBook
                 * @throws RemoteException
                 */
                @Override
                public void onNewBookArrived(Book newBook) throws RemoteException {
                    mHandler.obtainMessage(MESSAGE_BOOK_ARRIVED, newBook);

                }
            };
    @SuppressLint("HandlerLeak")
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_BOOK_ARRIVED:
                    Log.e(TAG, "handleMessage: " + msg.obj);
                    break;
                default:
                    break;
            }
        }
    };
    private IBookManager mRemoteBookManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(this, BookMangerService.class);
        bindService(intent, conn, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        unbindService(conn);
        super.onDestroy();

    }
}
//~~~~~~~~~~~~~~~~~~~~
public class BookMangerService extends Service {

    private static final String TAG = "BookMangerService";

    private AtomicBoolean mIsServiceDestroyed = new AtomicBoolean(false);
    CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<Book>();
//    CopyOnWriteArrayList<IOnNewBookArrivedListener> mListenerList =
//            new CopyOnWriteArrayList<IOnNewBookArrivedListener>();
    /**
     * RemoteCallbackList内部有个map结构专门用来保存所有aidl回调，
     * key是IBinder，value是callback
     */
    private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList =
            new RemoteCallbackList<IOnNewBookArrivedListener>();


    private Binder mBinder = new IBookManager.Stub() {

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

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

        @Override
        public void registerListener(IOnNewBookArrivedListener listener) {
//            if (!mListenerList.contains(listener)) {
//                mListenerList.add(listener);
//            } else {
//                Log.e(TAG, "registerListener: alread exists");
//            }
            mListenerList.register(listener);
            final int N = mListenerList.beginBroadcast();
            Log.e(TAG, "registerListener:current size:" + N);

        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener) {
//            if (mListenerList.contains(listener)) {
//                mListenerList.remove(listener);
//                Log.e(TAG, "unregisterListener: unregister succeed");
//            } else {
//                Log.e(TAG, "unregisterListener: not found,can not unregister");
//            }
            boolean success = mListenerList.unregister(listener);

            if (success) {
                Log.d(TAG, "unregister success.");
            } else {
                Log.d(TAG, "not found, can not unregister.");
            }
            final int N = mListenerList.beginBroadcast();
            mListenerList.finishBroadcast();
            Log.d(TAG, "unregisterListener, current size:" + N);
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        mBookList.add(new Book(1, "android"));
        mBookList.add(new Book(1, "ios"));

    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    private class ServiceWorker implements Runnable {

        @Override
        public void run() {
            while (!mIsServiceDestroyed.get()) {
                try {
                    Thread.sleep(5000);
                } 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) {
        mBookList.add(newBook);
    }

    @Override
    public void onDestroy() {
        mIsServiceDestroyed.set(true);

        super.onDestroy();
    }
}

代码
https://github.com/gangjin1991/AndroidLearn/tree/master/aidldemo

MrPeng1991
关注
从零掌握Android应用间通信：AIDL使用详解
移动开发前沿的博客
06-16 732
在Android开发中，有时候一个应用需要和另一个应用进行数据交互，这就涉及到应用间通信。AIDL是Android提供的一种强大工具，能让不同应用间实现通信。本文的目的就是教大家如何使用AIDL来实现Android应用间通信，范围涵盖AIDL的基本概念、原理、代码实现以及实际应用等方面。本文首先会介绍AIDL的核心概念，用通俗易懂的语言解释相关术语；接着阐述核心概念之间的关系，并给出原理和架构的示意图；然后详细讲解AIDL的算法原理和具体操作步骤，给出代码示例；之后通过项目实战来进一步说明AIDL的使用；
Android基础-AIDL的实现
最新发布
层楼终究误少年
06-09 1323
AIDL允许开发者定义跨进程通信的接口，从而在不同的进程间进行方法调用和数据交换。，用于声明一个接口，该接口描述了可以跨进程通信的方法。Binder类需要继承自AIDL接口生成的抽象类，并实现其中的方法。在Android项目中，AIDL文件会被Android SDK中的aidl工具编译成Java接口文件。通过AIDL，开发者可以定义跨进程通信的接口，并在不同的进程间进行方法调用和数据交换。在客户端，可以通过绑定Service的方式获取到AIDL接口的实例，然后调用其中的方法实现跨进程通信。
aidl最全讲解
10-25
aidl最全讲解文档。
AIDL详解，尝试自己动手实现 AIDL 机制
Guang_Mang 的博客
09-30 2276
AIDL（Android Interface definition language，安卓接口定义语言）是Android中IPC（Inter-process Communication）方式的一种，简单来说，AIDL的作用就是你可以在自己的APP绑定另一个APP的service，这样两个APP就可以进行交互。
Android AIDL使用详解
04-21
NULL 博文链接：https://iaiai.iteye.com/blog/1928276
AIDL简单实现
11-07
一个简单的aidl实现案例，简单易懂，配合博客--AIDL理解解析
android之AIDL详解demo1
02-23
在"android之AIDL详解demo1"中，我们看到了如何定义、实现和使用AIDL，这只是一个基础示例，实际应用中可能会涉及更复杂的接口定义和数据类型，以及错误处理等高级特性。通过不断实践，开发者可以更好地理解和利用...
android之AIDL详解demo2
02-23
AIDL（Android Interface Definition Language）是Android提供的一种强大的工具，专门用于处理跨进程通信。本篇将深入探讨AIDL的详细知识，并通过一个具体的"ClientAIDLDemo"示例来演示其使用方法。 首先，理解AIDL...
android aidl编译,Android AIDL详解
weixin_30891153的博客
05-26 947
概述AIDL是一个缩写，全称是Android Interface Definition Language，也就是Android接口定义语言。是的，首先我们知道的第一点就是：AIDL是一种语言。既然是一种语言，那么相应的就很自然的衍生出了一些问题：为什么要设计出这么一门语言？它有哪些语法？我们应该如何使用它？PS：在研究AIDL的时候首先需要熟悉service和序列化的一些知识。为什么要设计这门语言...
AIDL的原理实现
Yo.o
02-08 2102
​ 前言 Binder 驱动是基于 CS 模型设计的跨进程通信驱动, 想要使用 Binder 驱动进行通信, 需要三个步骤 定义交互规范 服务端实现 客户端实现 一、 定义交互规范 public interface IService extends IInterface { /* 跨进程提供服务的接口描述 */ String DESCRIPTOR = IService.class.getName(); /* 跨进程提供服务的接口中 getServic
AIDL的简单实现(一个应用开启了2个进程)
05-14
关于aidl的简单实现 程序中开启了两个进程 进行通信 所以不需要复制aidl文件到另一个程序中 比较简单 详情可参考我的这篇博客 http://blog.youkuaiyun.com/u012760183/article/details/51397014
Android aidl实现传递对象
01-10
不同App间通过AIDL传递处理对象
Android AIDL（接口定义语言）简单理解和基本使用方法
落岑博客
01-17 3589
一、概述      AIDL意思即Android  Interface Definition Language,翻过来就是Android接口定义语言，是用于定义服务端和客户端通信接口的一种描述语言，可以拿来生产IPC代码，从某种意义上说AIDL其实就是一个模板，因为在使用过程中，实际起作用的并不是AIDL文件，而是据此生产的一个Interface的实例代码，AIDL其实是为了避免我们重复写代码而出
aidl 详解
weixin_30719711的博客
08-31 181
aidl 是 android interface define language 的缩写，主要是作为进程间通讯的一个接口规范，这种通讯是一种普通的 client-server 的模式，对于 client 来说只需知道 aidl 即可，无需知道实现细节就能实现调用，之所以用 aidl 是因为系统可以自动完成 decompose/marshal 或者 serialize/unserializ...
Android AIDL 详解
天行健，君子以自强不息。
09-23 609
为了使其他的应用程序也可以访问本应用程序提供的服务，Android系统采用了远程过程调用（Remote Procedure Call，RPC）方式来实现。与很多其他的基于RPC的解决方案一样，Android使用一种接口定义语言（Interface Definition Language，IDL）来公开服务的接口。我们知道4个Android应用程序组件中的3个（Activity、Broadcas
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值