Android的一些基本常识

最新推荐文章于 2021-04-21 15:44:30 发布

红心地瓜

最新推荐文章于 2021-04-21 15:44:30 发布

阅读量1.8k

点赞数

分类专栏： android

本文链接：https://blog.csdn.net/dlmu2001/article/details/51823564

版权

android 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.Message

1.1 主要成员

public final class Message implements Parcelable{
    public int what;//user-defined message code
    public int arg1;
    public int arg2;
    public Object obj;//arbitrary object to send to recipient
    /**
      *一个可选的Messenger对象，表示这个消息的回复要发给谁，AsynChannel类就
      * 用到了这个成员
    **/
    public Messenger replyTo;
    Handler target;//处理这个消息的Handler
    public static Message obtain();
    public static Message obtain(Message orig);
    public static Message obtain(Handler h) ;
    public static Message obtain(Handler h, int what);
    public static Message obtain(Handler h, int what, Object obj) ;
    public static Message obtain(Handler h, int what, int arg1, int arg2);
    public static Message obtain(Handler h, int what, 
            int arg1, int arg2, Object obj);
            
     public void sendToTarget();
}

1.2 说明

Message类定义了消息结构体，里面包含了arg1,arg2用以携带基本的信息，这样大部分情况下可以不用分配内存。如果arg1，arg2满足不了要求，还可以使用obj和setData来传递更丰富的信息。

通常情况下，使用obtain()函数或者Handler::obtainMessage来构造Message类实例

2.Hanlder

2.1Handler类的作用

Hanlder类，主要用来实现消息处理函数。

简单地说，Looper是一个循环，它有一个Message que，会不停地读Message que，读出来的message，就调用改message对应的Handler（也就是message的target成员变量）的handleMessage或者message的callback进行处理。这个Looper通常运行在一个Thread上，但是Thread缺省并不带Looper，一般调用Looper.prepare()和Looper.loop()将循环运行起来。调用Handler.::sendMessage主要做两件事，一是将该Handler的值赋给message.target，而是将message enque到Looper的Message que中。下面一个简单例子展示这种关系。


class LoopThread extends Thread{
    public Handler mHandler;
    public void run(){
        Looper.prepare();
        
        mHandler =new Handler(){
            public void handleMessage(Message msg){
                //process incoming message
            }
        };
        Looper.loop();
    }
}

//somewhere
LoopThread thread=new LooperThead();
thread.run()

//somewhere
mHandler.sendMessage(msg)

2.2 HandlerThread

为了简化Hanlder,Loop,Thread之间的处理，Android定义了一个HanlderThread类，派生自Thread，特别的是，默认就带有一个looper

Class SampleHandler extends Handler{
    SampleHandler(android.os.Looper looper){
        super(looper);
    }
    public void handlerMessage(Message msg){
        //handler incoming mssage
    }
}

HandlerThread sampleThread = new HandlerThread("SampleService");
sampleThread.start();
mSampleHandler = new SampleHandler(sampleThread.getLooper());


//somewhere
mSampleHandler.sendMessage(msg)；

2.3 官方文档对Handler的说明

Handler允许你发送和处理和thread的MessageQue关联的消息和Runnable objects。每个Handler实例都同一个单独的Thread和那个Thread的MessageQue关联。当你创建了一个Handler，它就绑定到创建它的thread和thread的MessageQue上，它deliver messages和Runnables到那个MessageQue，当它们从MessageQue取出时执行他们。

There are two main uses for a Handler: (1) to schedule messages and runnables to be executed as some point in the future; and (2) to enqueue an action to be performed on a different thread than your own.

schedule messages通过post,postAtTime,postDelayed,sendEmptyMessage,sendMessage,sendMessageAtTime,sendMessageDelayed等方法来完成。

其中，post系列的函数用来schedule Runnables。而sendMessage系列的函数用来enqueue message ,该message可以包含a bundle of data，传递给handleMessage。

2.4 其它

Handler类还声明了一个成员变量

IMessenger mMessenger;

并提供了接口

final IMessenger getIMessenger()

通过这个可以将可跨进程传递的IMessager同进程内部的Handler联系起来，Messenger类利用了这个实现了跨进程通信。

3.Messenger

3.1 介绍

Messenger类是Handler的一个索引，但是它通过Binder的一个简单封装，实现了Handler无法实现的进程间通信。

public final class Messenger implements Parcelable{
    private final IMessenger mTarget;
    
    /**
     * 创建一个指向target的Messenger，任何发给这个Messenger的
     * 消息就会像Handler::sendMessage一样，被target这个Handler
     * 处理
     * */
    public Messenger(Handler target);
    /**
     * 通过一个raw IBinder来创建Messenger,比如client端连接service的时候，
     * 通过onServiceConnected获取到IBinder对象，就可以构建出service的
     * Messenger，从而可以像service发送消息
     * */
    public Messenger(IBinder target);
    
    /*注意因为是跨进程通信，要catch exception*/
    public void send(Message message) throws RemoteException;
    
    /**
     * 获取messenger用来同对应Handler通信的IBinder对象，比如service在onBind
     * 接口可以调用这个接口返回IBinder对象给client，也就是client在
     * onServiceConnected获取到的IBinder
     * */
    public IBinder getBinder();
    
}

3.2 实例

下面以一个实例展示如何利用Messenger来实现client和bound service之间的通信，可以简单分为如下几个步骤

Service实现一个Handler来处理消息
Service利用这个Handler来创建Messenger
Service在onBind接口中，利用Messenger::getBinder()将IBinder对象返回
Client在ServiceConnection::onServiceConnect中接收到这个IBinder对象，利用这个IBinder对象，构建出远端Messenger
client端利用这个远端Messenger向service发送消息(Messenger::send)
sercie在Handler里面处理消息

public class MessengerService extends Service {
    /** Command to the service to display a message */
    static final int MSG_SAY_HELLO = 1;
    /**
     * Handler of incoming messages from clients.
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */
    @Override
    public IBinder onBind(Intent intent) {
         return mMessenger.getBinder();
    }
}

public class ActivityMessenger extends Activity {
    /** Messenger for communicating with the service. */
    Messenger mService = null;

    /** Flag indicating whether we have called bind on the service. */
    boolean mBound;

    /**
     * Class for interacting with the main interface of the service.
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // This is called when the connection with the service has been
            // established, giving us the object we can use to
            // interact with the service.  We are communicating with the
            // service using a Messenger, so here we get a client-side
            // representation of that from the raw IBinder object.
            mService = new Messenger(service);
            mBound = true;
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            mService = null;
            mBound = false;
        }
    };

    public void sayHello(View v) {
        if (!mBound) return;
        // Create and send a message to the service, using a supported 'what' value
        Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to the service
        bindService(new Intent(this, MessengerService.class), mConnection,
            Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }
}

几点讨论

这种方式client只能向service发送消息，不能像LocalBinder或者AIDL那样通过client直接调用远端service的method
因为MessageQue是串行处理的，这种方式一次只能处理一个请求，不像aidl可以同时处理多个请求，相应地也没有multi-thread的问题
上个例子中，这种通信是单向的，只能client向service发送消息，如果想service也可以主动向client发消息，可以设置message的replyTo，也可以使用AsyncChannel。其实AsyncChannel就是利用利用两个Messenger来实现双工通信。
因为是Remote Process Call，所以Messenger::send调用要注意catch exception

3.3 补充

Messenger这种进程间通信的本质就是获得另一端Handler对应的Messenger，所以除了在Service::onBind中返回IBinder对象外，只要能获取Messenger对象就可以，比如结合AIDL，可以利用AIDL的函数调用来获得远端的Messenger.

4.AIDL

4.1 什么是AIDL

AIDL（Android Interface Definition Language）用来帮助实现跨进程通信。仅在需要从不同的应用通过IPC同时访问service（需要处理multi-thread)的情况下使用AIDL通信，如果不需要跨进程，可以使用LocalBinder，如果不需要同时处理请求（多线程），可以使用messenger。AIDL通常用于实现Bounding Service。

4.2 AIDL的实现

4.2.1 Service端

创建.aidl文件xxx.aidl
实现aidl文件中的interface
Android SDK工具会根据第一步的.aidl，自动生成xxx.java，在这个xxx里面有个.Stub抽象类，这个.Stub抽象类派生自Binder，负责实现aidl中的接口。所以你要做的工作就是继承这个抽象类，实现它。
那个自动生成的抽象类.stub
public static abstract class Stub extends Binder implements DataService;
将interface expose给client
在Service::onBind中返回你实现的.stub类的实例

实例：

DataService.aidl

Interface DataService{
    double getData(String arg);
}

实现接口并expose给client

public class AIDLExampleService extends Service{
    private final DataService.Stub mBinder = new DataService.Stub(){
        public double getData(String arg) {
            /*implement your operation,it should be thread safe*/
            return 0;
        }
    }
    /*expose the interface*/
    public IBinder onBind(Intent intent){
        return mBinder;
    }
}

4.2.2 Client端

include .aidl文件到src目录
声明一个IBinder接口实例
实现ServiceConnection
调用context.bindService,传入ServiceConnection实现
在ServiceConnection::onServiceConnected()接口中接收IBinder实例，调用xxx.Stub.asInterface()接口进行类型转换
利用IBinder接口实例来调用远端方法，注意catch RemoteException
调用unbindService disconnect

实例

public class AIDLExampleActivity extends Activity{
    private Button button;//按钮触发调用
    
    private DataService mService=null;
    private boolean mBound;
    
    private ServiceConnection = new ServiceConnection(){
        public void onServiceDisconnected(ComponentName name){
            mService=null;
            mBound=false;
        }
        public void onServiceConnected(ComponentName name,IBinder service){
            mBound=true;
            mService=DataService.stub.asInterface(service);
        }
    }
    protected void onCreate(Bundle savedInstanceState){
        //onCreate的一些normal implementation
        
        //bind service
        Intent intent=new Intent("***.DataService");
        bindService(intent,connection,BIND_AUTO_CREATE);
        
        button.setOnClickListener(new View.onClickListener(){
           public void onClick(View v){
               if(mBound && mService!=null){
                   double result=mService.getData("a");
                   /**desplay in ui***/
               }
           } 
        });
    }
    
}