本文介绍了Android中Activity和Service之间通信的四种方法：Binder类、内部类广播、Messenger和AIDL。通过这些方法，Activity能直接调用Service中的方法，Service也能向Activity发送消息。对于跨应用和多线程通信，AIDL提供了更强大的解决方案。
在Android中，Activity和Service分别管理着应用的前台和后台，他们都是相当重要的四大组件之一，那么Activity和Service之间是如何通信的呢？以下总结了四种可行的方法：
方法一：Binder类
该方法要求我们构造一个Binder类来封装Service实例，并在Service类中重写onBind方法返回该binder对象：
package com.example.test;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
public class MyService extends Service {
@Override
public IBinder onBind(Intent intent) {
return new MyBinder();
}
class MyBinder extends Binder {
/**
* 获取service实例
* @return
*/
public MyService getService() {
return MyService.this;
}
}
}
package com.example.test;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
public class MyActivity extends Activity{
// 服务实例
private MyService myService = null;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// 获取服务实例
myService = ((MyService.MyBinder)service).getService();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent(this, MyService.class);
bindService(intent, connection, BIND_AUTO_CREATE);
}
}方法二：通过内部类广播
我们可以分别在Service和Activity中实现两个广播内部类，当两个组件需要互相通信的时候只要发送适当的广播即可：
package com.example.test;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
public class MyService extends Service {
@Override
public IBinder onBind(Intent intent) {
return null;
}
class MyServiceBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
// do something
}
}
}
package com.example.test;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
public class MyActivity extends Activity{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent(this, MyService.class);
startService(intent);
}
class MyActivityBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
// do something
}
}
}
上面两种方法适用于同一个进程中的Activity和Service组件，那么对于不在同一个进程中的Activity和Service我们该如何通信呢？
方法三：Messenger
Messenger类的官方注释如下：/**
* Reference to a Handler, which others can use to send messages to it.
* This allows for the implementation of message-based communication across
* processes, by creating a Messenger pointing to a Handler in one process,
* and handing that Messenger to another process.
*/Messenger的使用方法如下：
Service类：
package com.example.test;
import android.app.Service;
import android.content.Intent;
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;
public class MyRemoteService extends Service {
private final String TAG = "MyService";
@Override
public IBinder onBind(Intent intent) {
// 返回Messenger的Binder对象
return messenger.getBinder();
}
@Override
public void onCreate() {
super.onCreate();
Log.v(TAG, "onCreate");
}
// 传入一个Handler参数用来处理消息，Handler默认构造方法绑定主线程
private Messenger messenger = new Messenger(new Handler() {
public void handleMessage(android.os.Message msg) {
// 收到消息打印Log
Log.v(TAG, "Get Message from remote activity : " + ((Bundle)msg.obj).getString("String"));
// 回复服务端消息
Message msgReply = Message.obtain();
<span style="white-space:pre"> </span>// 使用Bundle类包装信息
Bundle bundle = new Bundle();
bundle.putString("String", "From Remote Service");
msgReply.obj = bundle;
try {
msg.replyTo.send(msgReply);
} catch (RemoteException e) {
e.printStackTrace();
}
};
});
}
<service android:name="com.example.test.MyRemoteService"
android:enabled="true"
android:exported="true">
<intent-filter>
<action android:name="com.example.test.messenger"/>
<category android:name="android.intent.category.DEFAULT"/>
</intent-filter>
</service>接下来我们来看看另一个应用中Activity的代码：
package com.example.test2;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
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.widget.Toast;
public class MyActivity extends Activity {
private final String TAG = "MyActivity";
// 用于发送消息
private Messenger messengerSender = null;
// 用于接收消息
private Messenger messengerReceiver = new Messenger(new Handler() {
public void handleMessage(android.os.Message msg) {
// 收到消息打印Log
Log.v(TAG, "Get Message from remote Service : " + ((Bundle)msg.obj).getString("String"));
};
});
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// 获取来自Service的Binder对象，构造MessengerSender用于发送消息
messengerSender = new Messenger(service);
// 发送消息
Message message = new Message();
// 设置消息返回的Messenger
message.replyTo = messengerReceiver;
// 设置消息内容
Bundle bundle = new Bundle();
bundle.putString("String", "From Activity");
message.obj = bundle;
try {
messengerSender.send(message);
} catch (RemoteException e) {
e.printStackTrace();
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 绑定远程Service
Intent intent = new Intent();
intent.setAction("com.example.test.messenger");
bindService(intent, connection, Context.BIND_AUTO_CREATE);
}
}
在Activity中我们构造了两个Messenger，一个传入Handler参数构造用于处理接收到的Message，一个传入在ServiceConnection中获取的IBinder对象用于发送Message。在Activity中我们通过指定Action，使用bindService方法完成Activity与Service的绑定。此处我们在与Service建立连接后发送了一条消息给Service，并把Service返回的消息给打印出来。
从Logcat信息中我们可以看出Activity和Service通信成功了，并且是在两个应用，各自的进程当中（PID不同）。
值的注意的是，通信过程中Message的obj对象必须是实现了Parcelable接口的，否则系统会报RuntimeException:Can't marshal non-Parcelable objects across processes.一般而言我们只需要使用Bundle类包装要传输的数据即可。
方法四：AIDL
AIDL：Android Interface Definition Language，即Android接口定义语言。要是使用Messenger还不能满足你的需求，我们就必须使出AIDL这项工具来实现进程间通信了。那么AIDL适用于什么场景呢？我们来看看官方的解释：
Using AIDL is necessary only if you allow clients from different applications to access your service for IPC and want to handle multithreading in your service. If you do not need to perform concurrent IPC across different
applications, you should create your interface by implementing a Binder or, if you want to perform IPC, but do not need to handle multithreading, implement your interface using a Messenger. Regardless, be sure that you understand Bound Services before implementing
an AIDL.
上面最重要的就是第一句话：只有当你允许来自不同的客户端访问你的服务并且需要处理多线程问题时你才必须使用AIDL。在其他情况下你都可以选择其他方法，如使用Messager，也能跨进程通讯。可见AIDL是处理多线程、多客户端并发访问的。
那么接下来我们就来看看如何使用AIDL吧：
首先我们在src下面编写.aidl文件定义接口，其语法与java类似：
package com.example.aidl;
interface IRemoteService {
String sendMessage(String s);
}
注意，在Activity和Service所在的应用中都必须有完全相同的aidl文件，包名称也必须相同，否则会报java.lang.SecurityException: Binder invocation to an incorrect interface的错误。
接下来我们就可以利用aidl定义的接口编写Service和Activity了：
package com.example.test;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import com.example.aidl.IRemoteService;
public class MyRemoteService extends Service {
private final String TAG = "MyService";
@Override
public IBinder onBind(Intent intent) {
// 返回IRemoteService.Stub对象
return binder;
}
@Override
public void onCreate() {
super.onCreate();
Log.v(TAG, "onCreate");
}
private final IRemoteService.Stub binder = new IRemoteService.Stub() {
@Override
public String sendMessage(String s) throws RemoteException {
// 通过Log打印传入的字符串
Log.v(TAG, "String from Activity : "+s);
return "Service Message!";
}
};
}
Service的xml代码与Messenger相比没有什么改动，故不再贴出来。
接下来是Activity的代码：
package com.example.test2;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import com.example.aidl.IRemoteService;
public class MyActivity extends Activity {
private final String TAG = "MyActivity";
private IRemoteService mRemoteService;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mRemoteService = IRemoteService.Stub.asInterface(service);
try {
Log.v(TAG, mRemoteService.sendMessage("Activity Message!"));
} catch (RemoteException e) {
e.printStackTrace();
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
<span style="white-space:pre"> Log.v(TAG, "onCreate");</span>
// 绑定远程Service
Intent intent = new Intent();
intent.setAction("com.example.test.aidl");
bindService(intent, connection, Context.BIND_AUTO_CREATE);
}
}
通过Logcat我们可以发现，在两个进程中的Activity和Service通信成功了（PID不同）：
值的注意的是Activity是在主线程中与Service通信，而Service却并没有在主线程通信，而是新开启了一个线程和Activity通信（TID不同）。这也印证了官方对于AIDL工具的定位，当我们需要在不同进程中实现组件通信，并且需要处理多线程问题时，才使用AIDL，不然我们还是用回简单方便的Messenger吧。
总结:
- Activity调用bindService方法，通过IBinder对象得到Service的实例，这样Activity可以直接调用到Service中的方法，如果需要Service主动通知Activity，我们还可以为其添加回调方法。
- Service向Activity发送消息，可以使用广播，当然Activity要注册相应的接收器。比如Service要向多个Activity发送同样的消息的话，用这种方法就更好。
- 当Activity和Service分别处在不同的应用之中时，我们可以通过使用Messenger类来完成两组件之间的基于Message机制的交流通信，使用Handler来处理发送接收的消息。
- 当不仅Activity和Service所处应用不同，而且我们还需要处理多线程通信问题时，我们就需要使用AIDL来进行通信了。
扫一扫
1113
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
