Android编程-IntentService使用广播与Activity通信

Android编程过程中，经常涉及到后台程序，一个长时间运行的后台程序使用Android提供的Service将是一个很好的选择，然而在众多Service中，IntentService最为常用，也最为简单，但是在使用IntentService时，将服务产生的结果反馈给Activity却不是一件容易的事情。一般情况下，Activity与Service通信有两种方法，其一是通过绑定Binder对象，其二是通过broadcast(广播)的形式。本文将介绍一种属于第二种方案的特例，该方法使用IntentService作为后台Service，使用动态注册broadcast接收器作为通信桥梁，这样将可以省去很大一部分代码量，并且将通信变得更简单。

 
1.继承IntentService实现onHandleIntent方法
 

public class DownloadService extends IntentService {
public static final String SERVICE_KEY_WORDS =
"com.art.zok.DownloadService";

public DownloadService() {
super("***");
}

@Override
protected void onHandleIntent(Intent intent) {
String url = intent.getStringExtra("***");
downMethods(url);
}
}

继承IntentService至少需要做两件事，第一，实现一个没有参数的默认构造器，并且在构造函数内调用含有String参数的父类（IntentService）构造器；第二，也是最重要的地方，就是实现OnHandleIntent(Intent
intent)方法，该方法是IntentService的一个虚函数，当后台服务启动后，它将在后台服务的新线程调用，而不是主线程。我们实现该方法完成我们需要在后台完成的任务，如下载任务，其中intent参数将在启动服务时由我们创建并传递进来，这样在OnHandleIntent方法中我们就可以根据Intent的参数内容做出不同的后台响应。
启动IntentService可以使用Activity的startService方法：

 

public class MainClass extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
Intent i = new Intent(this, DownloadService.class);
/*i.putExtra(****)此处可以添加相应的参数*/
startService(i);
}
}

2.实现广播和动态注册广播 

广播接收器动态注册与XML注册的最大区别是作用范围的大小，XML定义方法可以在整个系统范围内进行广播并接收，而动态注册仅当在本应用可以使用。因此在特定的Activity与Service之间通信，使用动态注册广播接收更为方便。

public class MainClass extends Activity {
public  String SERVICE_RECEIVER = "com.art.zok.receiver";
private Intent intent;
private MsgReceiver msgReceiver;

public void onCreate(Bundle savedInstanceState) {
// 动态注册广播接收器
msgReceiver = new MsgReceiver();
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(SERVICE_RECEIVER);
registerReceiver(msgReceiver, intentFilter);

//启动后台服务
intent = new Intent(this, DownloadService.class);
/*intent.putExtra(****)此处可以添加相应的参数*/
startService(intent);
}

@Override
public void onDestroy() {

// 停止服务
stopService(intent);

// 注销广播
unregisterReceiver(msgReceiver);

super.onDestroy();
}

public class MsgReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
/*处理接收到的广播内容*/
}
}
}

动态注册广播接收器的过程，首先需要实现一个广播接收器，如MsgReceiver，重写OnReceive方法，该方法的intent参数是后台Service发送广播时提供的反馈内容。接下来，注册接收器可以使用Activity的registerReceiver方法，该方法接收一个BroadcastReceiver对象和一个IntentFilter对象，这里我们使用MsgReceiver的实例作为BroadcastReceiver对象参数，而IntentFilter
对象是用来标记(关联)接收器的，以便在发送广播后系统的正确找到接收器。这里我们实例一个IntentFilter对象，并调用addAction方法传递一个SERVICE_RECEIVER常量，表示我们接受具有SERVICE_RECEIVER常量表示的操作(Action)的广播，最后我们需要在onDestroy方法中停止服务和注销接收器。
当后台服务的(下载)任务完成时，我们就可以发送相应的广播来通知Activity，然后广播接收器就可以在OnReceive方法对接收到的Intent参数作出相应的响应，如UI更新。如下：

public class DownloadService extends IntentService {

***

@Override
protected void onHandleIntent(Intent intent) {
***
downMethods(url);
***
// 发送广播通知Activity
Intent sendIntent = new Intent(MainClass.SERVICE_RECEIVER);
***
getApplicationContext().sendBroadcast(sendIntent);
}
}

这里我们创建一个具有SERVICE_RECEIVER常量表示的操作(Action)的Intent对象，然后使用Context.SendBroadcast方法发送该Intent对象代表的广播。
到现在为止，使用上述方法已经完全可以做到Activity与Service通信了，但是有一个问题，这里通信采用的是Intent进行数据内容传输，如果我们是下载任务的话，很有可以需要传递一个自定义的类，那么怎么进行传输呢？这就需要使用到Parcelable接口，实现该接口可以将你的自定义类序列化，然后放入Intent中进行传输。

3.实现Parcelable接口

假设我们下载任务完成后得到的是如下Item类的一组对象，那么我们将要怎么样将其传递给广播接收器呢？

public class Item {
long id;
String title;
String img;
int gallertClass;
int count;
int rcount;
int fcount;
long time;
int size;
*****
}

首先，必须要实现Item的序列化，序列化是通过实现Parcelable接口而实现的，这里我们将上面的类改造为ItemParcelable类，并实现Parcelable接口：
 

public class ItemParcelable implements Parcelable {
long    id;
String  title;
String  img;
int     gallertClass;
int     count;
int     rcount;
int     fcount;
long    time;
int     size;

public ItemParcelable() {}

public long getId() {
return id;
}

public long setId(long id) {
this.id = id;
}

public String getTitle() {
return title;
}

@Override
public int describeContents() {
return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeLong(id);
dest.writeString(title);
dest.writeString(img);
dest.writeInt(gallertClass);
dest.writeInt(count);
dest.writeInt(rcount);
dest.writeInt(fcount);
dest.writeLong(time);
dest.writeInt(size);
}

/**
*实现Parcelable接口的类中，
*必须有一个实现了Parcelable.Creator
*接口的静态常量成员字段,并且它的名
*字必须为CREATOR
**/
public static final Parcelable.Creator<ItemParcelable> CREATOR =
new Parcelable.Creator<ItemParcelable>() {
@Override
public ItemParcelable createFromParcel(Parcel in) {
// 从包裹中读出数据
ItemParcelable item = new ItemParcelable();
item.setId(in.readLong());
item.setTitle(in.readString());
item.setImg(in.readString());
item.setGallertClass(in.readInt());
item.setCount(in.readInt());
item.setRcount(in.readInt());
item.setFcount(in.readInt());
item.setTime(in.readLong());
item.setSize(in.readInt());
return item;
}

@Override
public ItemParcelable[] newArray(int size) {
return new ItemParcelable[size];
}
};
}

首先重写writeToParcel方法，将你的对象(ItemParcelable)序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包需要传递的数据到Parcel容器保存，以便从Parcel容器获取数据。接下来，重写describeContents方法，内容接口描述，默认返回0就可以。最后实例化静态内部对象CREATOR实现Parcelable.Creator
publicstatic final Parcelable.Creator CREATOR接口。注意，其中public static final一个都不能少，内部对象CREATOR的名称也不能改变，必须全部大写。需重写本接口中的两个方法：createFromParcel(Parcelin)实现从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层，newArray(int
size) 创建一个类型为T，长度为size的数组，仅一句话即可（return
new T[size]），供外部类反序列化本类数组使用，这里的T就是ItemParcelable。还需要注意的是writeToParcel和createFromParcel方法中序列化的顺序必须相同。

4.最后通过ItemParcelable传递数据

发送数据

@Override
protected void onHandleIntent(Intent intent) {
***
ArrayList<ItemParcelable> items = downMethods(***);

// 发送广播通知Activity
Intent sendIntent = new Intent(MainClass.SERVICE_RECEIVER);
sendIntent.putParcelableArrayListExtra(SERVICE_KEY_WORDS, items);
getApplicationContext().sendBroadcast(sendIntent);
}

接收数据

@Override
public void onReceive(Context context, Intent intent) {
ArrayList<ItemParcelable> items = intent
.getParcelableArrayListExtra(DownloadService.SERVICE_KEY_WORDS);
/**
*for(ItemParcelable item : items) {
*  item.getId();
*	***
*}
**/
****
}

到现在为止，我们已经成功的完成Activity与Service的通信任务，最后还需要弄清楚一个概念，IntentService在第一次调用startService时创建服务，如果在IntentService还没有完成后台任务(onHandleIntent函数)时再次调用startService函数，那么不再创建服务，而是在任务队列添加一个任务(也可以理解为消息，其实就是将Intent包含的信息添加到一个队列中等待调用OnHandleIntent调用)，等待上次任务完成后再继续完成任务队列的下一条任务，当任务队列所有任务执行完毕后，则销毁服务，所以Service并不是自始至终都在后台运行，而只在有任务输入的时候才运行，这也保证了设备内存的充分利用。