1interface TestInterface {2 3      void add(in int value,in MethodCallback methodCallback);4 5      int send(in String msg);6 7      int registerReceiveMessageCallback(in ReceiveMessageCallback callback);8 9      int unregisterReceiveMessageCallback(in ReceiveMessageCallback callback);10      11			// 用来反向监听服务是否死亡12      oneway void registerServiceCallback(in ServiceConnectCallback callback);13 14      oneway void unregisterServiceCallback(in ServiceConnectCallback callback);15 16}

1class TestService : Service() {2    private var count = 03    private var autoIncreaseNum = 04    private val receiveMessageCallbacks: HashMap<Int, ReceiveMessageCallback> = HashMap()5    private val deathRecipientMap: HashMap<Int, ClientDeathRecipient> = HashMap()6 7    override fun onCreate() {8        super.onCreate()9        initTimer()10    }11 12    private fun initTimer() {13        Timer().schedule(object : TimerTask() {14            override fun run() {15                autoIncreaseNum += 1016                dealDispatchMsg("count:${count} autoIncreaseNum:${autoIncreaseNum}")17            }18        }, 0, 5000)19    }20 21    /**22	   * TODO: 注意事项 ①23     * 处理 DeadObjectException 问题，当遍历到已死亡 client 的引用，从列表中删除24     * 虽然在 ClientDeathRecipient 已经做了监听删除（遍历先于删除发生，依然会有问题），更安全的方式，在遍历过程中再处理一次25     */26    private fun dealDispatchMsg(msg: String?) {27        val iterator: Iterator<Int> = receiveMessageCallbacks.keys.toList().iterator()28        while (iterator.hasNext()) {29            val key = iterator.next()30            val receiveMessageCallback = receiveMessageCallbacks[key]31            try {32                receiveMessageCallback?.onReceive(msg)33            } catch (e: Exception) {34                if (e is DeadObjectException) {35                    receiveMessageCallbacks.remove(key)36                }37                error(e.message ?: "")38            }39        }40    }41 42    override fun onBind(intent: Intent): IBinder {43        return TestStub()44    }45 46    /**47	   * TODO: 注意事项 ③48     * 没有客户端与其绑定时，便会销毁49     */50    override fun onDestroy() {51        super.onDestroy()52        debug("onDestroy()")53    }54 55    inner class TestStub : TestInterface.Stub() {56        /**57         * methodCallback 依然有可能发生 DeadObjectException 异常，对此做 try catch 处理58         */59        override fun add(value: Int, methodCallback: MethodCallback?) {60            // 模拟耗时操作61            Thread.sleep(500 + Random().nextInt(1500).toLong())62            // TODO: 注意事项 ②63            try {64                if (System.currentTimeMillis() % 2 == 0L) {65                    count += value66                    methodCallback?.onSuccess(count.toString())67                } else {68                    methodCallback?.onFailure("add exec fail")69                }70            } catch (e: Exception) {71                error(e.message ?: "")72            }73        }74 75        override fun send(msg: String?): Int {76            debug("msg.length:${msg?.length}")77            return 078        }79 80        override fun registerReceiveMessageCallback(callback: ReceiveMessageCallback?): Int {81            callback ?: return -182            receiveMessageCallbacks[getCallingPid()] = callback83            return 084        }85 86        override fun unregisterReceiveMessageCallback(callback: ReceiveMessageCallback?): Int {87            callback ?: return -188            receiveMessageCallbacks.remove(getCallingPid())89            return 090        }91 92        override fun registerServiceCallback(callback: ServiceConnectCallback?) {93            callback ?: return94            val deathRecipient = ClientDeathRecipient(getCallingPid(), callback)95            deathRecipientMap[getCallingPid()] = deathRecipient96            callback.asBinder().linkToDeath(deathRecipient, 0)97        }98 99        override fun unregisterServiceCallback(callback: ServiceConnectCallback?) {100            if (deathRecipientMap.containsKey(getCallingPid())) {101                val deathRecipient: ClientDeathRecipient? = deathRecipientMap.remove(getCallingPid())102                deathRecipient?.callBack?.asBinder()?.unlinkToDeath(deathRecipient, 0)103            }104        }105    }106 107    inner class ClientDeathRecipient(private val pid: Int, val callBack: ServiceConnectCallback) :108        IBinder.DeathRecipient {109        override fun binderDied() {110            debug("receive client death recipient")111            deathRecipientMap.remove(pid)112            // 移除对应死亡客户端的回调，否则会触发 DeadObjectException113            receiveMessageCallbacks.remove(pid)114        }115    }116}

1// 服务端的 applicationId2private const val SERVICE_PKG_NAME = "com.dafay.demo.aidl.server"3 4// 服务端的 Service5private const val SERVICE_CLASS_NAME = "com.dafay.demo.aidl.service.TestService"6 7abstract class BaseServiceConnect {8    private var application: Application = ApplicationUtils.getApp()9    private var intent: Intent = Intent().apply { component = ComponentName(SERVICE_PKG_NAME, SERVICE_CLASS_NAME) }10    @Volatile11    protected var remoteServiceProxy: TestInterface? = null12    protected var receiveListeners = CopyOnWriteArrayList<ReceiveListener>()13 14    private val receiveMessageCallback: ReceiveMessageCallback = object : ReceiveMessageCallback.Stub() {15        @Throws(RemoteException::class)16        override fun onReceive(payload: String) {17            debug("onReceive:$payload")18            HandlerUtils.mainHandler.post {19                receiveListeners.forEach { it.onReceive(payload) }20            }21        }22    }23    private val serviceConnectCallback: ServiceConnectCallback = object : ServiceConnectCallback.Stub() {24        @Throws(RemoteException::class)25        override fun onConnectReply(message: String) {26        }27    }28 29    private val serviceConnection = object : ServiceConnection {30        override fun onServiceConnected(name: ComponentName, service: IBinder) {31		        // TODO: 注意事项 ①32            debug("onServiceConnected")33            remoteServiceProxy = TestInterface.Stub.asInterface(service)34            // TODO: 注意事项 ②35            service.linkToDeath(object : IBinder.DeathRecipient {36                override fun binderDied() {37                    debug("binderDied")38                    release()39                }40            }, 0)41            remoteServiceProxy!!.registerServiceCallback(serviceConnectCallback)42            remoteServiceProxy!!.registerReceiveMessageCallback(receiveMessageCallback)43        }44 45        override fun onServiceDisconnected(name: ComponentName) {46            debug("onServiceDisconnected")47            release()48            autoReconnect()49        }50    }51 52    fun bindToService(): Boolean {53        if (remoteServiceProxy != null && remoteServiceProxy!!.asBinder().isBinderAlive) {54            return true55        }56        // bindService 的 ServiceConnection 回调是在主线程中57        application.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)58        // TODO: 注意事项 ③59        return remoteServiceProxy != null60    }61 62    /**63     * 自动重连机制64     */65    private fun autoReconnect() {66        HandlerUtils.mainHandler.postDelayed({67            bindToService()68        }, 5 * 1000)69    }70 71    protected fun isServiceConnected(): Boolean {72        return bindToService()73    }74 75    private fun release() {76        remoteServiceProxy = null77    }78}79 

1// 服务端的 applicationId2private const val SERVICE_PKG_NAME = "com.dafay.demo.aidl.server"3 4// 服务端的 Service5private const val SERVICE_CLASS_NAME = "com.dafay.demo.aidl.service.TestService"6 7abstract class BaseServiceConnect {8    private var application: Application = ApplicationUtils.getApp()9    private var intent: Intent = Intent().apply { component = ComponentName(SERVICE_PKG_NAME, SERVICE_CLASS_NAME) }10 11    @Volatile12    protected var remoteServiceProxy: TestInterface? = null13    protected var receiveListeners = CopyOnWriteArrayList<ReceiveListener>()14 15    private val connectedSingleThreadExecutor = Executors.newSingleThreadExecutor()16    protected val funCachedThreadPool = Executors.newCachedThreadPool()17    protected val mainHandler = Handler(Looper.getMainLooper())18 19    private val receiveMessageCallback: ReceiveMessageCallback = object : ReceiveMessageCallback.Stub() {20        @Throws(RemoteException::class)21        override fun onReceive(payload: String) {22            debug("onReceive:$payload")23            mainHandler.post {24                receiveListeners.forEach { it.onReceive(payload) }25            }26        }27    }28    private val serviceConnectCallback: ServiceConnectCallback = object : ServiceConnectCallback.Stub() {29        @Throws(RemoteException::class)30        override fun onConnectReply(message: String) {31        }32    }33 34		/**35		 * TODO：注意事项 ① 36		 * 绑定服务成功或失败，添加对应的回调，注意 ServiceConnection 回调在主线程，其它在当前线程37		 */38    protected fun bindToService(onSuccess: () -> Unit, onFail: () -> Unit) {39        if (remoteServiceProxy != null && remoteServiceProxy!!.asBinder().isBinderAlive) {40            onSuccess.invoke()41            return42        }43 44        val serviceConnection = object : ServiceConnection {45            override fun onServiceConnected(name: ComponentName, service: IBinder) {46                debug("onServiceConnected")47                remoteServiceProxy = TestInterface.Stub.asInterface(service)48                remoteServiceProxy!!.registerServiceCallback(serviceConnectCallback)49                remoteServiceProxy!!.registerReceiveMessageCallback(receiveMessageCallback)50                onSuccess.invoke()51            }52 53            override fun onServiceDisconnected(name: ComponentName) {54                debug("onServiceDisconnected")55                release()56                autoReconnect()57            }58        }59        connectedSingleThreadExecutor.submit {60            // bindService 的 ServiceConnection 回调是在主线程中61            val bindResult = application.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)62            if (!bindResult) {63                onFail.invoke()64            }65        }66    }67 68    /**69     * 自动重连机制70     */71    private fun autoReconnect() {72        HandlerUtils.mainHandler.postDelayed({73            bindToService({}, {})74        }, 5 * 1000)75    }76 77    private fun release() {78        remoteServiceProxy = null79    }80}

1/**2 * 回调的方式3 */4object TestServiceProxy : BaseServiceConnect() {5    /**6     * 连接后执行7     */8    private fun connectedExec(onSuccess: () -> Unit, onFail: (Throwable) -> Unit) {9        bindToService(onSuccess) {10            onFail.invoke(RuntimeException("service connecte failure"))11        }12    }13 14    fun bindService(callback: FunCallback<Boolean>) {15        connectedExec({ callback.onSuccess(true) }, {16            callback.onFail(it)17        })18    }19		/**20     * TODO：注意事项 ②21     * 调用 add 函数时，如果服务未连接，先进行服务连接22     * MethodCallback 回调在所调用它的线程23     */24    fun add(value: Int, callback: FunCallback<Int>) {25        connectedExec({26            funCachedThreadPool.submit {27                remoteServiceProxy!!.add(value, object : MethodCallback.Stub() {28                    override fun onSuccess(resultJson: String?) {29                        mainHandler.post {30                            debug("add result:${resultJson}")31                            callback.onSuccess(resultJson?.toInt() ?: 0)32                        }33                    }34 35                    override fun onFailure(errorJson: String?) {36                        mainHandler.post {37                            debug("add result:${errorJson}")38                            callback.onFail(RuntimeException(errorJson))39                        }40                    }41                })42            }43        }) {44            callback.onFail(it)45        }46    }47 48    fun send(msg: String, callback: FunCallback<Boolean>) {49        connectedExec({50            funCachedThreadPool.submit {51                val result = remoteServiceProxy!!.send(msg)52                mainHandler.post {53                    if (result == 0) {54                        callback.onSuccess(true)55                    } else {56                        callback.onFail(RuntimeException("send fail"))57                    }58                }59            }60        }) {61            callback.onFail(it)62        }63    }64 65    fun registerReceiverListener(listener: ReceiveListener?) {66        if (!receiveListeners.contains(listener)) {67            receiveListeners.add(listener)68        }69    }70 71    interface FunCallback<T> {72        fun onSuccess(t: T)73        fun onFail(e: Throwable)74    }75}

1private const val SERVICE_PKG_NAME = "com.dafay.demo.aidl.server"2private const val SERVICE_CLASS_NAME = "com.dafay.demo.aidl.service.TestService"3 4/**5 * 使用协程，包装服务先连接，再执行远程方法6 */7abstract class BaseServiceConnect {8    private var application: Application = ApplicationUtils.getApp()9    private var intent: Intent = Intent().apply { component = ComponentName(SERVICE_PKG_NAME, SERVICE_CLASS_NAME) }10 11    protected var remoteServiceProxy: TestInterface? = null12    protected var receiveListeners = CopyOnWriteArrayList<ReceiveListener>()13    protected val mainHandler = Handler(Looper.getMainLooper())14    private val receiveMessageCallback: ReceiveMessageCallback = object : ReceiveMessageCallback.Stub() {15        @Throws(RemoteException::class)16        override fun onReceive(payload: String) {17            debug("onReceive:$payload")18            mainHandler.post {19                receiveListeners.forEach { it.onReceive(payload) }20            }21        }22    }23    private val serviceConnectCallback: ServiceConnectCallback = object : ServiceConnectCallback.Stub() {24        @Throws(RemoteException::class)25        override fun onConnectReply(message: String) {26        }27    }28 29    private fun bindToService(callback: ((Boolean) -> Unit)) {30        if (remoteServiceProxy != null && remoteServiceProxy!!.asBinder().isBinderAlive) {31            callback.invoke(true)32            return33        }34        val serviceConnection = object : ServiceConnection {35            override fun onServiceConnected(name: ComponentName, service: IBinder) {36                debug("bindToService onServiceConnected")37                remoteServiceProxy = TestInterface.Stub.asInterface(service)38                remoteServiceProxy!!.registerServiceCallback(serviceConnectCallback)39                remoteServiceProxy!!.registerReceiveMessageCallback(receiveMessageCallback)40                callback.invoke(true)41            }42 43            override fun onServiceDisconnected(name: ComponentName) {44                debug("bindToService onServiceDisconnected")45                release()46            }47        }48        val result = application.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)49        if (!result) {50            callback.invoke(false)51        }52    }53		/**54		 * TODO: 注意事项 ①55		 * 把回调转成流式写法56		 */57    suspend fun bindToService(): Boolean = withContext(Dispatchers.Default) {58        return@withContext suspendCoroutine { continuation ->59            bindToService { continuation.resume(it) }60        }61    }62 63    private fun release() {64        remoteServiceProxy = null65    }66}

1object TestServiceProxy : BaseServiceConnect() {2		/**3		 * TODO: 注意事项 ②4		 * 用 async 方式，保证连接服务先执行完成5		 */6    private suspend fun checkConnectedService(): Boolean {7        val job = CoroutineScope(Dispatchers.Default).async {8            bindToService()9        }10        return job.await()11    }12 13    suspend fun bindService() {14        bindToService()15    }16 17    suspend fun add(value: Int): Int {18        if (!checkConnectedService()) {19            return -120        }21        val job = CoroutineScope(Dispatchers.Default).async {22            doAdd(value)23        }24        try {25            return job.await()26        } catch (e: Exception) {27            error(e.message ?: "")28        }29        return -130    }31 32    /**33     * 回调转同步34     */35    private suspend fun doAdd(value: Int): Int = withContext(Dispatchers.Default) {36        return@withContext suspendCoroutine { continuation ->37            remoteServiceProxy!!.add(value, object : MethodCallback.Stub() {38                override fun onSuccess(resultJson: String?) {39                    debug("add result:${resultJson}")40                    continuation.resume(resultJson?.toInt() ?: 0)41                }42 43                override fun onFailure(errorJson: String?) {44                    debug("add result:${errorJson}")45                    continuation.resumeWithException(RuntimeException("add fail"))46                }47            })48        }49    }50 51    suspend fun send(msg: String): Int {52        if (!checkConnectedService()) {53            return -154        }55        return remoteServiceProxy!!.send(msg)56    }57 58    fun registerReceiverListener(listener: ReceiveListener?) {59        if (!receiveListeners.contains(listener)) {60            receiveListeners.add(listener)61        }62    }63}

1    /**2     * Same as {@link #bindService(Intent, ServiceConnection, int)3     * bindService(Intent, ServiceConnection, int)} with executor to control ServiceConnection4     * callbacks.5     *6     * @param executor Callbacks on ServiceConnection will be called on executor. Must use same7     *      instance for the same instance of ServiceConnection. （ServiceConnection 将在 executor 定义的线程执行）8	   * 9     * @return The result of the binding as described in10     *      {@link #bindService(Intent, ServiceConnection, int)11     *      bindService(Intent, ServiceConnection, int)}.12     */13    public boolean bindService(@RequiresPermission @NonNull Intent service,14            @BindServiceFlags int flags, @NonNull @CallbackExecutor Executor executor,15            @NonNull ServiceConnection conn) {16        throw new RuntimeException("Not implemented. Must override in a subclass.");17    }

1abstract class BaseServiceConnect {2    private var application: Application = ApplicationUtils.getApp()3    private var intent: Intent = Intent().apply { component = ComponentName(SERVICE_PKG_NAME, SERVICE_CLASS_NAME) }4 5    @Volatile6    protected var remoteServiceProxy: TestInterface? = null7    protected var receiveListeners = CopyOnWriteArrayList<ReceiveListener>()8    protected val mainHandler = Handler(Looper.getMainLooper())9 10    private val receiveMessageCallback: ReceiveMessageCallback = object : ReceiveMessageCallback.Stub() {11        @Throws(RemoteException::class)12        override fun onReceive(payload: String) {13            debug("onReceive:$payload")14            mainHandler.post {15                receiveListeners.forEach { it.onReceive(payload) }16            }17        }18    }19    private val serviceConnectCallback: ServiceConnectCallback = object : ServiceConnectCallback.Stub() {20        @Throws(RemoteException::class)21        override fun onConnectReply(message: String) {22        }23    }24 25    fun bindToService(): Boolean {26        if (remoteServiceProxy != null && remoteServiceProxy!!.asBinder().isBinderAlive) {27            return true28        }29        // TODO: 注意事项 ①30        val countDownLatch = CountDownLatch(1)31        val serviceConnection = object : ServiceConnection {32            override fun onServiceConnected(name: ComponentName, service: IBinder) {33                debug("bindToService onServiceConnected")34                remoteServiceProxy = TestInterface.Stub.asInterface(service)35                remoteServiceProxy!!.registerServiceCallback(serviceConnectCallback)36                remoteServiceProxy!!.registerReceiveMessageCallback(receiveMessageCallback)37                countDownLatch.countDown()38            }39 40            override fun onServiceDisconnected(name: ComponentName) {41                debug("bindToService onServiceDisconnected")42                release()43                countDownLatch.countDown()44            }45        }46        val result = application.bindService(47            intent,48            Context.BIND_AUTO_CREATE,49            Executors.newSingleThreadExecutor(), // 使回调在子线程50            serviceConnection51        )52        if (!result) {53            countDownLatch.countDown()54        }55        debug("countDownLatch start")56        countDownLatch.await(10 * 1000, TimeUnit.SECONDS)57        debug("countDownLatch end")58        return remoteServiceProxy != null59    }60 61    protected fun isServiceConnected(): Boolean {62        return bindToService()63    }64 65    private fun release() {66        remoteServiceProxy = null67    }68}

1object TestServiceProxy : BaseServiceConnect() {2 3    fun bindService() {4        bindToService()5    }6 7    fun add(value: Int) {8        if (!isServiceConnected()) {9            return10        }11        return remoteServiceProxy!!.add(value, null)12    }13 14    fun send(msg: String): Int {15        if (!isServiceConnected()) {16            return -117        }18        return remoteServiceProxy!!.send(msg)19    }20 21    fun registerReceiverListener(listener: ReceiveListener?) {22        if (!receiveListeners.contains(listener)) {23            receiveListeners.add(listener)24        }25    }26}

1/**2     *  1MB 减去 8KB（即 1024KB - 8KB），binder 这个限制是二进制数据的长度限制3     *  1 一个字符 2B ？4     *  通过日志测算一下 字符串 到 二进制 的转换5     *  测试 1024*170=174080   3482526     *  测试 1024*180=184320   3687327     *  计算出来 92 + (string.length*2)8     *  推算能传输的最大 String 长度为 (1024*1024-8*1024-92)/2 =5201469     */10    private fun generateString(length: Int): String {11        val charArray = CharArray(length)12        for (i in 0 until length) {13            charArray[i] = if (i % 2 == 0) 'a' else 'b'14        }15        return String(charArray)16    }