Android开发如何跨进程接收与发送广播安卓跨线程通信

转载

mob64ca140ac564 2023-11-08 10:58:31

文章标签 android跨线程通信 android 发送消息客户端 文章分类 Android 移动开发

如果你需要在不同进程间通信，你可以在Service中使用Messenger来实现进程中通信。

如果使用这种方式，Service中需要定义一个Handler对象(负责对客户端发送过来的Message进行响应)。

Messenger可以共享给client一个IBinder对象，client通过这个IBinder对象向Service发送Message，而前面提到的Handler对象是这一切的基础。

注：使用这种方式进行通信是不支持多线程的。

那就让我们来看看使用这种方式进行通信吧！

注：Service在声明时必须对外开放，即android:exported="true"，且本文是通过Intent启动的Service，所以在声明时该Service可以接收特定的Action。

1、在Service中创建一个Handler对象，来处理从client发过来的Message

2、根据创建的Handler对象创建一个Messenger对象

3、使用Messenger的getBinder方法得到一个IBinder对象，并在Service的onBind方法中将其反出去

4、client在onServiceConnected中根据IBinder参数创建一个Messenger对象(可参考Messenger的构造函数)

5、client可以使用上一步得到的Messenger对象来给Service发送Message了

经过上面的五部我们就能让client与Service进行通信。client使用Messenger对象给Service发送Message后，Service中的Handler将会对消息作出响应。

上面实现的仅仅是单向通信，即client给Service发送消息，如果我需要Service给client发送消息又该怎样做呢？

其实，这也是很容易实现的，下面就让我们接着上面的步骤来实现双向通信吧~

6、在client中创建一个Handler对象，用于处理Service发过来的消息

7、根据client中的Handler对象创建一个client自己的Messenger对象

8、我们在第5步的时候获得了Service的Messenger对象，并通过它来给Service发送消息。这时候，我们将client的Messenger对象赋给待发送的Message对象的replyTo字段

9、在Service的Handler处理Message时将client的Messenger解析出来，并使用client的Messenger对象给client发送消息

这样我们就实现了client和Service的双向通信。client和Service都有自己的Handler和Messenger对象，使得对方可以给自己发送消息，值得注意的是client的Messenger是通过Message的replyTo传递给Service的。

Messenger:信使

官方文档解释：它引用了一个Handler对象，以便others能够向它发送消息(使用mMessenger.send(Message

msg)方法)。该类允许跨进程间基于Message的通信(即两个进程间可以通过Message进行通信)，在服务端使用Handler创建一个Messenger，客户端持有这个Messenger就可以与服务端通信了。

以前我们使用Handler+Message的方式进行通信，都是在同一个进程中，从线程持有一个主线程的Handler对象，并向主线程发送消息。

而Android既然可以使用bindler机制进行跨进行通信，所以我们当然可以将Handler与bindler结合起来进行跨进程发送消息。

查看API就可以发现，Messenger就是这种方式的实现。

一般使用方法如下：

１。远程通过

mMessenger = new Messenger(mHandler)

创建一个信使对象

２。客户端使用bindlerService请求连接远程

３。远程onBind方法返回一个bindler

return mMessenger.getBinder();

4.客户端使用远程返回的bindler得到一个信使(即得到远程信使)

public void onServiceConnected(ComponentName name, IBinder service) {
rMessenger = new Messenger(service);
......
}

这里虽然是new了一个Messenger，但我们查看它的实现

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

发现它的mTarget是通过Aidl得到的，实际上就是远程创建的那个。

５。客户端可以使用这个远程信使对象向远程发送消息：rMessenger.send(msg);

这样远程服务端的Handler对象就能收到消息了，然后可以在其handlerMessage(Message

msg)方法中进行处理。(该Handler对象就是第一步服务端创建Messenger时使用的参数mHandler).

经过这５个步骤貌似只有客户端向服务端发送消息，这样的消息传递是单向的，那么如何实现双向传递呢？

首先需要在第５步稍加修改，在send(msg)前通过msm.replyTo =

mMessenger将自己的信使设置到消息中，这样服务端接收到消息时同时也得到了客户端的信使对象了，然后服务端可以通过/得到客户端的信使对象，并向它发送消息 cMessenger = msg.replyTo; cMessenger.send(message);

即完成了从服务端向客户端发送消息的功能，这样客服端可以在自己的Handler对象的handlerMessage方法中接收服务端发送来的message进行处理。

双向通信宣告完成。

下面改写ApiDemos工程实现Messenger通信
MessengerService.java
Java代码 
package com.xwangly.apidemo.app;
import java.util.Random;
import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
public class MessengerService extends Service {
private String TAG = "MessengerService";
@Override
public void onDestroy() {
// TODO Auto-generated method stub
Log.i(TAG, "onDestroy");
cMessenger = null;
super.onDestroy();
}
@Override
public boolean onUnbind(Intent intent) {
// TODO Auto-generated method stub
Log.i(TAG, "onUnbind");
return super.onUnbind(intent);
}
static final int MSG_REGISTER_CLIENT = 1;
static final int MSG_UNREGISTER_CLIENT = 2;
static final int MSG_SET_VALUE = 3;
private Random random = new Random();
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
Log.i(TAG, "handleMessage");
switch (msg.what) {
case MSG_SET_VALUE:
try {
Message message = Message.obtain(null,
MessengerService.MSG_SET_VALUE);
message.arg1 = random.nextInt(100);
//得到客户端的信使对象，并向它发送消息
cMessenger = msg.replyTo;
cMessenger.send(message);
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
};
private Messenger mMessenger = new Messenger(mHandler);
private Messenger cMessenger;
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
Log.i(TAG, "onBind");
//返回自己信使的bindler,以供客户端通过这个bindler得到服务端的信使对象(通过new Messenger(bindler))
return mMessenger.getBinder();
}
@Override
public void onRebind(Intent intent) {
// TODO Auto-generated method stub
Log.i(TAG, "onRebind");
}
}
MessengerServiceActivities.java
Java代码 
package com.xwangly.apidemo.app;
import com.xwangly.apidemo.R;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
public class MessengerServiceActivities {
public static class Binding extends Activity implements
View.OnClickListener {
private String TAG = "Binding";
TextView mCallbackText;
private boolean isBound;
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.messenger_service_binding);
findViewById(R.id.bind).setOnClickListener(this);
findViewById(R.id.unbind).setOnClickListener(this);
mCallbackText = (TextView) findViewById(R.id.callback);
mCallbackText.setText("Not attached.");
}
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
Log.i(TAG, "handleMessage");
switch (msg.what) {
case MessengerService.MSG_SET_VALUE:
mCallbackText.setText("Received from service: " + msg.arg1);
break;
default:
super.handleMessage(msg);
}
}
};
private Messenger mMessenger;
private Messenger rMessenger;
private ServiceConnection connection = new ServiceConnection() {
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
Log.i(TAG, "onServiceConnected");
rMessenger = new Messenger(service);
mMessenger = new Messenger(mHandler);
sendMessage();
}
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
rMessenger = null;
}
};
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent = new Intent(
"com.xwangly.apidemo.app.messenger_service");
switch (v.getId()) {
case R.id.bind:
if (!isBound) {
isBound = bindService(intent, connection, BIND_AUTO_CREATE);
//isBound = true;
}else {
sendMessage();
}
break;
case R.id.unbind:
if (isBound) {
unbindService(connection);
isBound = false;
}
break;
default:
break;
}
}
private void sendMessage() {
// TODO Auto-generated method stub
Message message = Message.obtain(null, MessengerService.MSG_SET_VALUE);
message.replyTo = mMessenger;
try {
rMessenger.send(message);
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
AndroidManifest.xml相关配置如下：
Xml代码 
<service android:name=".app.MessengerService" >
<intent-filter>
<action android:name="com.xwangly.apidemo.app.messenger_service" />
intent-filter>
service>
<activity android:name=".app.MessengerServiceActivities$Binding"
android:label="@string/activity_messenger_service_binding"
android:launchMode="singleTop">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
intent-filter>
activity>

至于layout就不帖了，两个按钮一个文本域。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。