Android 的进程间通信 Binder——AIDL的入门使用(三)

进程间通信系列

AIDL的入门使用(一)
AIDL的入门使用(二)
AIDL的入门使用(三)
Messenger的入门使用

序言:

1、AIDL的大致使用流程:首先是创建一个AIDL接口文件声明需要在客户端调用的接口,再创建一个Service,接着创建一个类继承自AIDL接口中的Stub类并实现Stub中的抽象方法,在Service 的onBind方法中返回这个类的对象,然后在客户端就可以绑定服务端的Service,建立连接后就可以访问远程服务端的方法了;
2、思考:当有多个AIDL接口文件时怎么办呢?按照以前的思路,只有创建多个Service了,或者将多个AIDL接口的方法放在一个AIDL中了,这回造成代码耦合程度高,这篇我们主要就是解决这个问题的。解决思路:在服务端统一返回一个AIDL文件的binder,这个binder对象只有一个query方法,可以根据传入的值去创建其他对应的AIDL接口的Binder对象在进行返回,这样客户端就可以单独调用服务端的AIDL接口中的方法了,并且只需要一个Service。

多个AIDL接口通信服务端:

1、新建三个AIDL接口文件,分别为:IStringComputface、IIntComputInterface 和IBinderInterface ,前两个提供给客户端具体的调用方法,IBinderInterface 提供给客户端查询调用的Binder对象。然后Make Project。

// IStringComputface.aidl
package com.ljp.moreaidl_server;
//计算字符串的AIDL接口
interface IStringComputInterface {
    String comput(String str);
}
// IBinderInterface.aidl
package com.ljp.moreaidl_server;
interface IBinderInterface {
    IBinder quary(int binderCode);//根据binder码查询Binder对象
}
// IBinderInterface.aidl
package com.ljp.moreaidl_server;
interface IBinderInterface {
    IBinder quary(int binderCode);//根据binder码查询Binder对象
}

2、创建3个类分别继承对应AIDL接口的Stub类并实现未实现的方法。

package com.ljp.moreaidl_server;
import android.os.RemoteException;
import android.text.TextUtils;
public class StringComputImp extends IStringComputInterface.Stub {
    @Override
    public String comput(String str) throws RemoteException {
        if (TextUtils.isEmpty(str)) {
            return null;
        }
        char[] charArray = str.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            charArray[i] += 1;
        }
        return new String(charArray);
    }
}
package com.ljp.moreaidl_server;
import android.os.RemoteException;
public class IntComputImp extends IIntComputInterface.Stub {
    @Override
    public int addComput(int x, int y) throws RemoteException {
        return x + y;
    }
}
package com.ljp.moreaidl_server;
import android.os.IBinder;
import android.os.RemoteException;
public class BinderImp extends IBinderInterface.Stub {
    public static final int ComputString = 0;
    public static final int ComputInt = 1;
    @Override
    public IBinder quary(int binderCode) throws RemoteException {
        IBinder binder = null;
        switch (binderCode) {
            case ComputString:
                binder = new StringComputImp();
                break;
            case ComputInt:
                binder = new IntComputImp();
                break;
        }
        return binder;
    }
}

3、创建一个Service,并在onBinder方法中返回IBinderInterface的实现类BinderImp的对象,并在注册Service。服务端的代码就完成了。

package com.ljp.moreaidl_server;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class MyServerService extends Service {
    BinderImp mBinderImp = new BinderImp();
    @Override
    public IBinder onBind(Intent intent) {
        return mBinderImp;
    }
}

在AndroidMainfest文件中注册Service。

        <service
            android:name=".MyServerService"
            android:enabled="true"
            android:exported="true">
            <!-- 程序的包名:com.ljp.moreaidl_server 绑定服务端时使用服务端程序的包名。-->
            <intent-filter>
                <action android:name="com.ljp.moreAidl.server.action"/>
            </intent-filter>
        </service>

多个AIDL接口通信客户端:

1、这里写一个Binder连接池类,采用单例模式,在创建对象时就去绑定服务端,绑定成功后会回调ServiceConnection对象的onServiceConnected方法,在onServiceConnected方法中给binder设置死亡代理,当服务端的binder对象死亡时系统回调mDeathRecipient.binderDied()方法从而进行重连。并暴露一个quaryBinder的方法,

package com.ljp.moreaidl_client;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import com.ljp.moreaidl_server.IBinderInterface;
public class BinderPool {
    private static final String TAG = "moreAidl";
    public static final int ComputString = 0;
    public static final int ComputInt = 1;
    private static volatile BinderPool instance;
    private Context mContext;
    private BinderPool(Context context) {
        mContext = context.getApplicationContext();
        connectService();
    }
    public static BinderPool getInstance(Context context) {
        if (instance == null) {
            synchronized (BinderPool.class) {
                if (instance == null) {
                    instance = new BinderPool(context);
                }
            }
        }
        return instance;
    }
    IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            //当Binder死亡时,系统会回调该方法,在此移除之前绑定的Binder代理并重新绑定远程服务
            Log.e(TAG, "binderDied: 与服务端连接的Binder对象死亡。请求重连!");
            mIBinderInterface.asBinder().unlinkToDeath(mDeathRecipient, 0);
            mIBinderInterface = null;
            connectService();
        }
    };
    IBinderInterface mIBinderInterface = null;
    ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mIBinderInterface = IBinderInterface.Stub.asInterface(service);//返回一个可以查询其他AIDL接口的Binder。
            try {
                //给binder设置死亡代理,当服务端的binder对象死亡时系统回调mDeathRecipient.binderDied()方法
                mIBinderInterface.asBinder().linkToDeath(mDeathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            Log.e(TAG, "onServiceConnected: 与服务端连接成功");
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e(TAG, "onServiceDisconnected: 与服务端断开连接");
            mDeathRecipient.binderDied();
        }
    };
    private synchronized void connectService() {
        Intent intent = new Intent();
        intent.setPackage("com.ljp.moreaidl_server");
        intent.setAction("com.ljp.moreAidl.server.action");
        boolean success = mContext.bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
        Log.e(TAG, "connectService: 绑定服务端=" + success);
    }
    public synchronized void unConnect() { //断开与服务端的连接
        if (mIBinderInterface != null) {
            mContext.unbindService(mConnection);//不会回调onServiceDisconnected()
            mIBinderInterface.asBinder().unlinkToDeath(mDeathRecipient, 0);
        }
        mIBinderInterface = null;
        instance = null;
    }
    public IBinder quaryBinder( int binderCode) { //AIDL的调用都是耗时操作,建议放在子线程中
        IBinder binder = null;
        if (mIBinderInterface != null) {
            try {
                binder = mIBinderInterface.quary(binderCode); //调用服务端的查询
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        return binder;
    }
}

2、在客户端中调用服务端的方法时,先调用BinderPool对象的quaryBinder( int ),然后在使用对应的AIDL接口.Stub.asInterface(binder)进行转换为相应的AIDL接口对象,这时就可以调用该AIDL接口服务端的方法了,由于AIDL的调用都是耗时操作,建议都放在子线程中处理。这里第一次绑定时并不会立即连接成功,需要等待一小段时间,因此建议在Application中获取一次BinderPool的对象进行绑定连接,后面就可以直接使用了。

    public void StringComput(View view) {
        IBinder binder = BinderPool.getInstance(this).quaryBinder(BinderPool.ComputString);
        if (binder == null) {
            return;
        }
        IStringComputInterface anInterface = IStringComputInterface.Stub.asInterface(binder);
        try {
            String comput = anInterface.comput("abcdefg"); //AIDL的调用都是耗时操作,建议放在子线程中
            Log.e(TAG, "StringComput: comput=" + comput);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    public void IntComput(View view) {
        IBinder binder = BinderPool.getInstance(this).quaryBinder(BinderPool.ComputInt);
        if (binder == null) {
            return;
        }
        IIntComputInterface anInterface = IIntComputInterface.Stub.asInterface(binder);
        try {
            int addComput = anInterface.addComput(10, 20);//AIDL的调用都是耗时操作,建议放在子线程中
            Log.e(TAG, "StringComput: addComput=" + addComput);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    @Override
    protected void onDestroy() {
        BinderPool.getInstance(this).unConnect();
        super.onDestroy();
    }

测试结果:

12-02 21:16:04.176 27386-27386/com.ljp.moreaidl_client E/moreAidl: connectService: 绑定服务端=true
12-02 21:16:04.186 27386-27386/com.ljp.moreaidl_client E/moreAidl: onServiceConnected: 与服务端连接成功
12-02 21:16:05.976 27386-27386/com.ljp.moreaidl_client E/moreAidl: StringComput: comput=bcdefgh
12-02 21:16:07.536 27386-27386/com.ljp.moreaidl_client E/moreAidl: StringComput: addComput=30

更多参考:
- Android中的Service:默默的奉献者 (1)
- Android中的Service:Binder,Messenger,AIDL(2)
- Android:学习AIDL,这一篇文章就够了(上)
- Android:学习AIDL,这一篇文章就够了(下)
- 你真的理解AIDL中的in,out,inout么?

展开阅读全文

Git 实用技巧

11-24
这几年越来越多的开发团队使用了Git,掌握Git的使用已经越来越重要,已经是一个开发者必备的一项技能;但很多人在刚开始学习Git的时候会遇到很多疑问,比如之前使用过SVN的开发者想不通Git提交代码为什么需要先commit然后再去push,而不是一条命令一次性搞定; 更多的开发者对Git已经入门,不过在遇到一些代码冲突、需要恢复Git代码时候就不知所措,这个时候哪些对 Git掌握得比较好的少数人,就像团队中的神一样,在队友遇到 Git 相关的问题的时候用各种流利的操作来帮助队友于水火。 我去年刚加入新团队,发现一些同事对Git的常规操作没太大问题,但对Git的理解还是比较生疏,比如说分支和分支之间的关联关系、合并代码时候的冲突解决、提交代码前未拉取新代码导致冲突问题的处理等,我在协助处理这些问题的时候也记录各种问题的解决办法,希望整理后通过教程帮助到更多对Git操作进阶的开发者。 本期教程学习方法分为“掌握基础——稳步进阶——熟悉协作”三个层次。从掌握基础的 Git的推送和拉取开始,以案例进行演示,分析每一个步骤的操作方式和原理,从理解Git 工具的操作到学会代码存储结构、演示不同场景下Git遇到问题的不同处理方案。循序渐进让同学们掌握Git工具在团队协作中的整体协作流程。 在教程中会通过大量案例进行分析,案例会模拟在工作中遇到的问题,从最基础的代码提交和拉取、代码冲突解决、代码仓库的数据维护、Git服务端搭建等。为了让同学们容易理解,对Git简单易懂,文章中详细记录了详细的操作步骤,提供大量演示截图和解析。在教程的最后部分,会从提升团队整体效率的角度对Git工具进行讲解,包括规范操作、Gitlab的搭建、钩子事件的应用等。 为了让同学们可以利用碎片化时间来灵活学习,在教程文章中大程度降低了上下文的依赖,让大家可以在工作之余进行学习与实战,并同时掌握里面涉及的Git不常见操作的相关知识,理解Git工具在工作遇到的问题解决思路和方法,相信一定会对大家的前端技能进阶大有帮助。
©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值