码迷,mamicode.com
首页 > 移动开发 > 详细

Android进程通信之Messenger&AIDL使用详解

时间:2016-12-30 17:28:11      阅读:489      评论:0      收藏:0      [点我收藏+]

标签:markdown   拓展   过程   debug   and   dog   mmu   其他   成功   

1. 前言

提到的进程间通信(IPC:Inter-Process Communication),在Android系统中,一个进程是不能直接访问另一个进程的内存的,需要提供一些机制在不同的进程之间进行通信,Android官方推出了AIDL(Android Interface Definition Language),它是基于Binder机制的,至于官方为什么要采用Binder,查看为什么Android要采用Binder作为IPC机制,分析很全面。

上篇Android之Service的细枝末节提到组件在与Service通信方法有三种。

  • 实现IBinder
  • Messenger
  • AIDL

后面两种可以跨进程通信,是基于Binder机制的通信方式。

2. 使用时机

在确定使用什么机制之前,首先了解应用场景。Android系统中,如果组件与服务通信是在同一进程,就使用第一种方式;如果是跨进程通信,使用第二种和第三种,两者不同在于,Messenger不能处理多线程并发请求。

3. AIDL使用

AIDL是可以处理多线程访问的请求的,所以实现AIDL首先要保证线程安全。

  • 创建.aidl文件,定义接口
  • 在代码中实现接口,Android SDK会根据aidl文件,生成接口,接口内部有一个名为Stub内部抽象类,这个类用于继承了Binder类并实现aidl文件中定义的接口,我们需要拓展Stub类并实现里面的抽象方法
  • 复写Service的onBind(),返回Stub类的实现

3.1 创建.aidl文件

在Android Studio中工程目录下,反键new -> AIDL -> AIDL FIle,可以新建aidl文件,编译器会自动在app(壳工程)/src/main/目录下新建aidl文件,同时也会新建文件夹,默认以工程包名作为aidl文件所在的目录。

目录结构如下:

技术分享
图-1 aidl文件目录结构

也可以手动创建,aidl接口定义的包名也可以和工程包名不同,aidl文件语法和Java语法相似,aidl定义的接口名必须和文件名一致,而且支持传递自定义的数据类型,需要实现parcelable接口。

IRemoteService.aidl

package com.demo.aidl;

import com.demo.aidl.ParcelableData;

interface IRemoteService {
    /**
     * 获取当前进程的pid
     */
    int getPid();
    /**
     * 获取当前服务名称
     */
    String getServiceName();
    /**
     * 处理客户端传过来的数据
     */
    void handleData(in ParcelableData data);
}

ParcelableData.aidl

package com.demo.aidl;

/**
 * 声明支持传递的类
 */
parcelable ParcelableData;

IRemoteServiceCallBack.aidl

package com.demo.aidl;

oneway interface IRemoteServiceCallBack {
    void valueChanged(int value);
}

aidl文件定义的接口支持的数据类型如下:

  • Java的八种基本数据类型(byte,int,short,long,float,double,char,boolean)
  • String
  • CharSequence
  • List,List中所有的元素必须是aidl文件支持的数据类型,例如,List< String >
  • Map,Map中所有的元素必须是aidl文件支持的数据类型,
  • 其他aidl定义的接口,要手动添加import
  • 其他aidl文件中申明的类,要手动添加import

aidl文件中定义的方法接受的参数,除了Java的基本数据类型和aidl定义的接口之外,其他参数都需要标记数据的走向,in/out/inout,基本数据类型和aidl定义的接口作为参数,默认是in。

  • in表示输入参数,客户端把参数传递给服务端使用。
  • out表示输出参数,客户端将参数传递给服务端填充,然后自己使用处理。
  • inout标书输入输出参数,传送相应的值并接收返回。

关键字oneway表示用户请求相应功能时不需要等待响应可直接调用返回,非阻塞效果,该关键字可以用来声明接口或者声明方法,如果接口声明中用到了oneway关键字,则该接口声明的所有方法都采用oneway方式

新建完毕aidl文件后,rebuild工程或者使用gradle assembleDebug(或gradle assembleRelease)指令编译工程,生成具体的java代码,在壳工程/build/generated/aidl/目录下的debug或者release文件夹下,根据build的类型而定,如图:

技术分享
图-2 adil生成代码目录图

AIDL接口首次公布后对其的任何修改都必须保持向后兼容性,避免中断客户端对服务的使用,因为需要将.aidl文件复制给其他应用,才能使其他应用能够访问服务,所以必须保持对原始接口的支持。

3.2 实现接口

Android SDK会根据.aidl文件生成同名.java文件,生成的接口中有一个Stub的抽象子类,这个类实现(implements)aidl定义的接口,同时继承了Binder

具体代码如下:

private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {
    @Override
    public int getPid() throws RemoteException {
        return Process.myPid();
    }

    @Override
    public String getServiceName() throws RemoteException {
        return RemoteService.this.getClass().getSimpleName();
    }

    @Override
    public void handleData(ParcelableData data) throws RemoteException {
        Toast.makeText(RemoteService.this, "num is " + data.num, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void registerCallback(IRemoteServiceCallBack cb) throws RemoteException {
        if(cb != null) {
            mCallBacks.register(cb);
        }
    }

    @Override
    public void unregisterCallback(IRemoteServiceCallBack cb) throws RemoteException {
        if(cb != null) {
            mCallBacks.unregister(cb);
        }
    }
};

现在mBinder是Stub类的一个实例,同时也是一个Binder,用于服务定义的RPC服务,作为onBind()方法的返回对象实例。

实现AIDL接口注意事项:

  • 因为AIDL可以处理多线程并发,在实现过程中要保证线程安全
  • 默认情况下,RPC调用是同步的,但是服务端可能有耗时操作,客户端最好不要在主线程调用服务
  • 服务端引发的任何异常不会返回给客户端

3.3 向客户端暴露接口

实现接口后,需要向客户端将接口暴露出来,以便客户端使用。将Stub的实例化对象作为Service中onBind()方法的返回对象。

public class RemoteService extends Service {
    /**
     * 回调容器
     */
    private final RemoteCallbackList<IRemoteServiceCallBack> mCallBacks = new RemoteCallbackList<>();
    /**
     * aidl接口具体实现
     */
    private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {
        @Override
        public int getPid() throws RemoteException {
            return Process.myPid();
        }

        @Override
        public String getServiceName() throws RemoteException {
            return RemoteService.this.getClass().getSimpleName();
        }

        @Override
        public void handleData(ParcelableData data) throws RemoteException {
            Toast.makeText(RemoteService.this, "num is " + data.num, Toast.LENGTH_SHORT).show();
        }

        @Override
        public void registerCallback(IRemoteServiceCallBack cb) throws RemoteException {
            if(cb != null) {
                mCallBacks.register(cb);
            }
        }

        @Override
        public void unregisterCallback(IRemoteServiceCallBack cb) throws RemoteException {
            if(cb != null) {
                mCallBacks.unregister(cb);
            }
        }
    };

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

    @Override
    public void onDestroy() {
        // 注销所有回调
        mCallBacks.kill();
    }
}

3.4 客户端调用

服务提供给第三方应用使用,其他应用就必须要有接口类,在客户端创建相同的aidl文件(可以直接拷贝过去)。

核心连接远端服务的代码:

/**
 * 远端服务
 */
private IRemoteService mService;

private ServiceConnection mConnection = new ServiceConnection() {
    /**
     * 连接服务器成功回调
     * 
     * @param className
     * @param service
     */
    public void onServiceConnected(ComponentName className, IBinder service) {
        mService = IRemoteService.Stub.asInterface(service);
    }

    /**
     * 服务器因为一场情况断开连接时候回调
     * 
     * @param className
     */
    public void onServiceDisconnected(ComponentName className) {
        mService = null;
    }
};

/**
 * 绑定服务
 */
private void doBindService() {
    isBound = true;
    Intent intent = new Intent(BindRemoteServiceActivity.this, RemoteService.class);
    bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}

/**
 * 解除绑定
 */
private void doUnbindService() {
    if(isBound && mService != null) {
        isBound = false;
        try {
            mService.unregisterCallback(mCallback);
        } catch (RemoteException e) {
            e.printStackTrace();
        }

        unbindService(mConnection);
    }
}

/**
 * 向服务端发送信息
 */
private void doSendMsg() {
    if(!isBound || mService == null) {
        return;
    }
    ParcelableData data = new ParcelableData(1);
    try {
        mService.handleData(data);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}

/**
 * 调用服务端方法获取信息
 */
private void doGetServiceInfo() {
    if(!isBound || mService == null) {
        return;
    }
    try {
        String info = mService.getServiceName();

        mInfoTv.setText("Service info :" + info);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}

详情代码贴上来比较长,贴上工程地址,点我呀!!!

4. Messenger的使用

Messenger的使用相对于AIDL方便好多,因为Messenger是Android系统中自带的类,服务端和客户端都不用创建AIDL文件。

Messenger会持有一个Handler,这个Handler用于处理接受到的信息,在服务端和乘客通过Messenger实现双方通信。

4.1 服务端

代码实例:

public class MessengerService extends Service {

    public static final int MSG_REGISTER_CLIENT = 0X001;
    public static final int MSG_UNREGISTER_CLIENT = 0X010;
    public static final int MSG_HANDLE = 0X100;

    private ArrayList<Messenger> mClients = new ArrayList<>();

    private final Messenger mMessenger = new Messenger(new IncomingHandler());

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }

    @Override
    public void onDestroy() {
        Toast.makeText(this, "Remote Service Destroy", Toast.LENGTH_SHORT).show();
    }

    private class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_REGISTER_CLIENT:
                    mClients.add(msg.replyTo);
                    break;
                case MSG_UNREGISTER_CLIENT:
                    mClients.remove(msg.replyTo);
                    break;
                case MSG_HANDLE:
                    for (Messenger mClient : mClients) {
                        try {
                            mClient.send(Message.obtain(null, MSG_HANDLE, msg.arg1, 0));
                        } catch (RemoteException e) {
                            e.printStackTrace();
                            mClients.remove(mClient);
                        }
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    };
}

4.2 客户端

核心代码:

/**
 * 关联远端服务的messenger
 */
private Messenger mServiceWrapper;
/**
 * 用于处理服务端发送的信息
 */
final Messenger mMessenger = new Messenger(new IncomingHandler());

private ServiceConnection mConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        mServiceWrapper = new Messenger(service);

        mInfoTv.setText("Connected Service");


        try {
            // 添加监听注册
            Message msg = Message.obtain(null, MessengerService.MSG_REGISTER_CLIENT);
            msg.replyTo = mMessenger;
            mServiceWrapper.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        mServiceWrapper = null;
        mInfoTv.setText("Disconnected");
    }
};

/**
 * 绑定服务
 */
private void doBindService() {
    if(!isBound) {
        bindService(new Intent(this, MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);

        isBound = true;

        mInfoTv.setText("Binding...");
    }
}

/**
 * 移除监听并解绑服务
 */
private void doUnbindService() {
    if(isBound) {
        if(mServiceWrapper != null) {
            try {
                Message msg = Message.obtain(null, MessengerService.MSG_UNREGISTER_CLIENT);
                msg.replyTo = mMessenger;
                mServiceWrapper.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        unbindService(mConnection);
        isBound = false;
        mInfoTv.setText("Unbinding...");
    }
}

/**
 * 向服务端发送信息
 */
private void doSendMsg() {
    if(mServiceWrapper != null) {
        try {
            Message msg = Message.obtain(null,
                    MessengerService.MSG_HANDLE, this.hashCode(), 0);
            mServiceWrapper.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

4.3 客户端发送信息

使用Messenger向服务端发送信息,使用的是Messenger.send(Message)方法,这个方法具体实现如下:

public void send(Message message) throws RemoteException {
    mTarget.send(message);
}

方法内部调用mTarget.send(Message)方法,在Messenger中,mTarget是在构造方法里面被赋值的,有两个构造函数。

public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}

public Messenger(IBinder target) {
    mTarget = IMessenger.Stub.asInterface(target);
}

第一个构造函数好理解,mTarget.send(Message)实际上是将Message加入了构造函数传入的Handler的消息队列,Demo工程中服务端向乘客端发送信息就是使用的这种方法

第二个构造函数是不是很眼熟,这不就是获取AIDL定义的接口嘛!!!转了一圈回到了上面的AIDL,客户端向服务端发送信息实际上还是通过AIDL,只不过Android系统帮我们做了一层封装。

5. 总结

到此,从Android之Service的细枝末节到Android中常用的进程通信都已经总结完毕,算是2016的一个完结,撒花!!

最后附上Demo工程地址:https://github.com/Kyogirante/AIDLDemo

Android进程通信之Messenger&AIDL使用详解

标签:markdown   拓展   过程   debug   and   dog   mmu   其他   成功   

原文地址:http://blog.csdn.net/xiaohanluo/article/details/53911529

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!