Android binder连接中，服务端如何知道客户端断开情况详解手机开发

在IPC 利用 binder连接过程中，客户端断连，服务端如何知道呢？

这里的客户端和服务端都运行在不同的进程。

一般来说，我们使用Android的binder，都直接用aidl帮我们生成java代码，再利用service进行ServiceConnection连接。

也许你会说，利用ServiceConnection的onServiceDisconnected()就可以知道断开连接了。

可是回想一下，onServiceDisconnected()是回调到Client端，也就是说，Client端可以知道自己跟Server断开的情况，但是Server端却永远都不知道什么时候跟Client端断开。

回忆一下，我们知道，binder有一个方法，可以传入一个死亡代理，即binder.linkToDeath(IBinder.DeathRecipient)。

这样做的好处就是当对应的跟服务端连接的binder断开的时候，就可以收到DeathRecipient的binderDied()方法回调了。

在《Android艺术开发探索》里，作者把DeathRecipient使用在了ServiceConnection收到对应的service的binder上面，这样达到的效果跟ServiceConnection的onServiceDisconnected()一样，就是Client知道binder断开了，然后Server端依然还是不知道，下面是举例代码：

//在ServiceConnection中抽出的代码 
override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
    
    mProxy = RemoteService.Stub.asInterface(binder) 
    binder?.linkToDeath(object: IBinder.DeathRecipient {
    //加上死亡代理 
        override fun binderDied() {
    
            Log.e(TAG, "remote Server is died") // binder已经died了 
        } 
    }, 0) 
} 

虽然上面都是客户端知道binder断开的情况，但是可以推出，只要服务端拿到客户端的任意一个binder，也就可以通过binder.linkToDeath(IBinder.DeathRecipient)，让服务端知道binder断开的情况了。

这样引申的问题就是：服务端怎么拿到客户端的binder？

服务端怎么拿到客户端的binder

很显然，我们可以通过Service的onBind(Intent intent)方法，把客户端的binder放在intent中传给Service就好了。

哈哈，这样就错了。

不同的客户端连接同一个Service，onBind() 会触发多少次？

答案是一次。不同的进程的Activity对同一个Service进行bindService()返回IBinder，根据直觉肯定是都会调用Service的onBind()方法，事实上并不是这样的。

因为，在对应的Service进程的ActivityManagerService的ActivityServices中，所以当有外部需要的时候直接返回binder，不需要每次都调用Service的onBind()方法。

可以见 《Android中bindService的细节之三：多次调用bindService()，为什么onBind()只执行一次？》

Service对应的onBind只会走一次，那么之后如果调用bindService()之后，其实走的都是onRebind()方法，前提是onUnbind()的返回为true。

所以，可以通过service端提供的binder接口，将client端的binder传过去，以下定义的是客户端和服务端实现的binder接口：

// MyRemoteService.aidl 服务端 
package com.my.remoteserver; 
 
import com.my.remoteserver.Token; 
 
interface RemoteService {
    
    void register(Token token); 
} 
 
// IRemoteCallback.aidl 客户端 
package com.js.remoteserver; 
 
interface Token {
    
} 

服务端怎么知道区分哪个客户端来的呢？

第一个方法就是在上面的RemoteService的register的token来辨别是哪个客户端连接。

第二个方法就是利用Binder的static方法，Binder.getCallingPid()来拿到调用端的pid。

附带部分源码

部分server端代码：

// Server端 
class InnerRemoteService : Service() {
    
    private lateinit var mBinder: RemoteServiceImpl 
     
    override fun onCreate() {
    
        super.onCreate() 
        mBinder = RemoteServiceImpl() 
    } 
 
    override fun onBind(intent: Intent): IBinder {
    
        return mBinder 
    } 
 
    inner class RemoteServiceImpl : RemoteService.Stub() {
    
        @Throws(android.os.RemoteException::class) 
        override fun register(token: Token) {
    
            var pid = Binder.getCallingPid() 
            var binder = token.asBinder() 
            binder.linkToDeath(RemoteDeathRecipient(pid, binder), 0) 
            Log.d(TAG, "register " + pid.toString()) 
        } 
    } 
 
    override fun onRebind(intent: Intent?) {
    
        super.onRebind(intent) 
    } 
 
    inner class RemoteDeathRecipient(var pid: Int, var binder: IBinder) : IBinder.DeathRecipient {
    
        override fun binderDied() {
    
            Log.e(TAG, "binderDied " + pid.toString()) 
            binder.unlinkToDeath(this@RemoteDeathRecipient, 0) 
        } 
    } 
} 

部分客户端代码：

 
class InnerRemoteActivity : AppCompatActivity() {
    
    private val TAG = "InnerRemoteService" 
    private var mProxy : RemoteService? = null 
    private var mConnection: ServiceConnection? = null 
 
    override fun onCreate(savedInstanceState: Bundle?) {
    
        super.onCreate(savedInstanceState) 
        setContentView(R.layout.activity_remote) 
 
        var mIntent = Intent(this@InnerRemoteActivity, InnerRemoteService::class.java) 
        mConnection = object: ServiceConnection {
    
            override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
    
                mProxy = RemoteService.Stub.asInterface(binder) 
                mProxy?.register(object : Token.Stub(){
   }) 
                binder?.linkToDeath(object: IBinder.DeathRecipient {
    
                    override fun binderDied() {
    
                        Log.e(TAG, "remote Service is died") 
                    } 
                }, 0) 
            } 
            override fun onServiceDisconnected(name: ComponentName?) {
    
                Log.e(TAG, "onServiceDisconnected") 
                mProxy = null 
            } 
        } 
        bindService(mIntent, mConnection, Context.BIND_AUTO_CREATE) 
    } 
}