Android IPC進程通信——Messager方式

本文轉自：http://blog.csdn.net/chenfeng0104/article/details/7010244

 

Android IPC通信有兩種方式，上一篇文章深入分析AIDL原理講解了AIDL方式，這篇文章講解另一種IPC通信方式——Messager方式。

Messager實現IPC通信，底層也是使用了AIDL方式。和AIDL方式不同的是，Messager方式是利用Handler形式處理，因此，它是線程安全的，這也表示它不支持併發處理；而AIDL方式是非線程安全的，支持併發處理，因此，我們使用AIDL方式時需要保證代碼的線程安全。

大部分情況下，我們應用中不需要併發處理。因此，我們通常只需要使用Messager方式。

思想：在進程A中創建一個Message，將這個Message對象通過IMessenger.send(message)方法傳遞到進程B（當然，Message對象本身是無法被傳遞到進程B的，send(message)方法會使用一個Parcel對象對Message對象編集，再將Parcel對象傳遞到進程B中，然後解編集，得到一個和進程A中Message對象內容一樣的對象），再把Message對象加入到進程B的消息隊列裏，Handler會去處理它。

先看下面這個例子

進程B中代碼

 

public class RemoteService extends Service {
    public static final int GET_RESULT = 1;
    private final Messenger mMessenger = new Messenger(new Handler() {
        private int remoteInt = 1;//返回到進程A的值
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == GET_RESULT) {
                try {
                    msg.replyTo.send(Message.obtain(null, GET_RESULT, remoteInt++, 0));
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            } else {
                super.handleMessage(msg);
            }
        }
    });

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

 

進程A中代碼

private Messenger mService;
private boolean isBinding = false;
private ServiceConnection mConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        mService = new Messenger(service);
        isBinding = true;
    }

    @Override public void onServiceDisconnected(ComponentName name) {
        mService = null;
        isBinding = false;
    } };

//綁定進程B的服務
bindService(new Intent(this, RemoteService.class), mConnection, BIND_AUTO_CREATE);

//處理來自進程B回覆的消息
private Messenger mMessenger = new Messenger(new Handler() {
    @Override
    public void handleMessage(Message msg) {
        if (msg.what == RemoteServiceProxy.GET_RESULT) {
             Log.i("TAG", "Int form process B is "+msg.arg1);//msg.arg1就是remoteInt
        } else {
             super.handleMessage(msg);
        }
    }
});

//向進程B發一條消息，並接收來自進程B回覆過來的消息
Message message = Message.obtain(null, RemoteServiceProxy.GET_RESULT);
message.replyTo = mMessenger;
try {
    mService.send(message);
} catch (RemoteException e) {
    e.printStackTrace();
}

上面這個例子很簡單，目的就是從進程A向進程B的RemoteService發一個消息，進程B再把處理結果發給進程A。

下面來深入分析一下Messenger的實現過程

Messenger類的方法：

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

public IBinder getBinder() {
    return mTarget.asBinder();
}

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

Handler類的方法：

final IMessenger getIMessenger() {
    synchronized (mQueue) {
        if (mMessenger != null) {
            return mMessenger;
        }
        mMessenger = new MessengerImpl();
        return mMessenger;
    }
}

private final class MessengerImpl extends IMessenger.Stub {
    public void send(Message msg) {
        Handler.this.sendMessage(msg);
    }
}

從上面代碼可知，當進程A的Activity綁定進程B的RemoteService時，onBind方法返回一個MessengerImpl對象，它是IBinder類的子類。這個對象會被傳遞到進程A中，在進程A與進程B建立鏈接時，傳到ServiceConnection.onServiceConnected(ComponentName name, IBinder service)方法中，IBinder service就是進程B返回的MessengerImpl對象。然後用service構建一個Messager對象

mService = new Messenger(service);

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

IMessenger.Stub.asInterface(target)方法會在進程A中創建一個IMessenger的代理類Proxy，看過AIDL的朋友會對這個很熟悉。

當使用mService發送一條消息時，實際調用的是代理類Proxy的send(Message msg)方法。

public void send(android.os.Message msg) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((msg!=null)) {
_data.writeInt(1);
msg.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_send, _data, null, android.os.IBinder.FLAG_ONEWAY);
}
finally {
_data.recycle();
}
}
}

上面方法是將Message msg的內容寫到Parcel _data對象中，然後調用進程B返回的MessengerImpl對象的transact方法。這個方法把_data對象傳遞到進程B中，看下這個方法

public final boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        if (Config.LOGV) Log.v("Binder", "Transact: " + code + " to " + this);
        if (data != null) {
            data.setDataPosition(0);
        }
        boolean r = onTransact(code, data, reply, flags);
        if (reply != null) {
            reply.setDataPosition(0);
        }
        return r;
    }

在進程B中調用onTransact方法

public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException

{
switch (code)
{

........

case TRANSACTION_send:
{
data.enforceInterface(DESCRIPTOR);
android.os.Message _arg0;
if ((0!=data.readInt())) {
_arg0 = android.os.Message.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
this.send(_arg0);
return true;
}

.......

}
}

這個方法在進程B中恢復進程A傳遞過來的消息，然後調用this.send(_arg0);。再來看看send(_arg0)這個方法

private final class MessengerImpl extends IMessenger.Stub {
    public void send(Message msg) {
        Handler.this.sendMessage(msg);
    }
}

把它加到進程B的消息隊列中了，由Handler處理。

http://blog.csdn.net/chenfeng0104/article/details/6989217