Android 4 学习（19）：Services

参考《Professional Android 4 Development》

Services

Service是invisible的，因此其优先级不高于visible的Activity，之所以说不高于，是因为我们可以设置Service为在前台运行。

创建Service

Android提供了Service抽象类，继承它便可以创建一个Service类：

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class MyService extends Service {
　　@Override
　　public void onCreate() {
　　　　super.onCreate();
　　　　// TODO: Actions to perform when service is created.
　　}
　　@Override
　　public IBinder onBind(Intent intent) {
　　　　// TODO: Replace with service binding implementation.
　　　　return null;
　　}
}

创建Service类之后，还需要在Manifest里面注册：

<service android:enabled=”true” android:name=”.MyService” android:permission=”com.paad.MY_SERVICE_PERMISSION”/>

若要默认只有自己的程序可以使用这个Service，需要添加Android:permission属性。其他Application若要使用这个服务，需要加入这个permission。

执行Service

当Service由startService()方法调用时，即可引起onStartCommand方法的调用，因此需要重写Service中的onStartCommand方法，并且onStartCommand方法可能会被多次调用。onStartCommand()方法将返回一个int值，用于指定当Service被runtime杀掉又重启的时，系统该如何响应：

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
　　startBackgroundTask(intent, startId);
　　return Service.START_STICKY;
}

重启Service

onStartCommand()方法可以返回这些参数，它们的意义是：

START_STICKY：如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null。

START_NOT_STICKY：“非粘性的”。如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务。
START_REDELIVER_INTENT：使用这个返回值时，如果未执行完onStartCommand，服务在调用stopSelf之前被kill掉，系统会自动重启该服务，并将Intent的值传入。

参考：http://www.krislq.com/2013/05/android-class-return-value-of-onstartcommand/

启动和停止服务

调用startService方法可以启动服务：

private void explicitStart() {
　　// Explicitly start My Service
　　Intent intent = new Intent(this, MyService.class);
　　// TODO Add extras if required.
　　startService(intent);
}
private void implicitStart() {
　　// Implicitly start a music Service
　　Intent intent = new Intent(MyMusicService.PLAY_ALBUM);
　　intent.putExtra(MyMusicService.ALBUM_NAME_EXTRA, “United”);
　　intent.putExtra(MyMusicService.ARTIST_NAME_EXTRA, “Pheonix”);
　　startService(intent);
}

调用stopService方法可以停止服务：

// Stop a service explicitly.
stopService(new Intent(this, MyService.class));
// Stop a service implicitly.
Intent intent = new Intent(MyMusicService.PLAY_ALBUM);
stopService(intent);

服务自杀

服务内部调用stopSelf方法，可以停止该服务。

绑定Service到Activity

首先，Service要实现IBind接口：

@Override
public IBinder onBind(Intent intent) {
　　return binder;
}
public class MyBinder extends Binder {
　　MyMusicService getService() {
　　　　return MyMusicService.this;
　　}
}
private final IBinder binder = new MyBinder();

ServiceConnection类用于表示Service到Activity的绑定，每个绑定都需要创建一个ServiceConnection：

// Reference to the service
private MyMusicService serviceRef;
// Handles the connection between the service and activity
private ServiceConnection mConnection = new ServiceConnection() {
　　　　public void onServiceConnected(ComponentName className, IBinder service) {
　　　　　　// Called when the connection is made.
　　　　　　serviceRef = ((MyMusicService.MyBinder)service).getService();
　　　　}
　　　　public void onServiceDisconnected(ComponentName className) {
　　　　　　// Received when the service unexpectedly disconnects.
　　　　　　serviceRef = null;
　　　　}
};

最后，调用bindService方法，传入用于启动Service的Intent，ServiceConnection和标志位：

// Bind to the service
Intent bindIntent = new Intent(MyActivity.this, MyMusicService.class);
bindService(bindIntent, mConnection, Context.BIND_AUTO_CREATE);

通常情况下，Android应用在自己的内存空间中运行，并不共享内存。若要与其他进程通信，可以使用广播，或在Intent中添加Bundle参数启动其他Service的方法。如果需要更紧密的通信，可以使用Android Interface Defi nition Language（AIDL）。AIDL使用OS级别的简单变量定义了接口，可以跨应用传递对象。

创建前台服务

使用startForeground方法启动服务，可以使服务获得与Visible Activity相同的优先级，例如：

private void startPlayback(String album, String artist) {
　　int NOTIFICATION_ID = 1;
　　// Create an Intent that will open the main Activity if the notification is clicked.
　　Intent intent = new Intent(this, MyActivity.class);
　　PendingIntent pi = PendingIntent.getActivity(this, 1, intent, 0);
　　// Set the Notification UI parameters
　　Notification notification = new Notification(R.drawable.icon, “Starting Playback”, System.currentTimeMillis());
　　notification.setLatestEventInfo(this, album, artist, pi);
　　// Set the Notification as ongoing
　　notification.flags = notification.flags | Notification.FLAG_ONGOING_EVENT;
　　// Move the Service to the Foreground
　　startForeground(NOTIFICATION_ID, notification);
}

使用stopForeground方法可以取消Service的前台属性：

public void pausePlayback() {
　　// Move to the background and remove the Notification
　　stopForeground(true);
}

使用后台线程

Service和Activity一样，也是在主线程中运行的，为了更好地响应用户，我们需要使用后台线程的方式执行Service。Android提供了两个抽象类来帮助我们实现：AsyncTask和IntentService。

使用AsyncTask

AsyncTask不仅能帮助我们将费时操作放到后台执行，还可以实现和UI线程的同步。AsyncTask适合执行那些耗时比较短并且和UI线程有交互的任务，对于耗时较久的任务（例如下载），使用Service更为合适。需要注意的是AsyncTask在应用restart之后会被cancel掉。

private class MyAsyncTask extends AsyncTask<String, Integer, String> {
@Override
protected String doInBackground(String... parameter) {
// Moved to a background thread.
String result = “”;
int myProgress = 0;
int inputLength = parameter[0].length();
// Perform background processing task, update myProgress]
for (int i = 1; i <= inputLength; i++) {
myProgress = i;
result = result + parameter[0].charAt(inputLength-i);
try {
Thread.sleep(100);
} catch (InterruptedException e) { }
publishProgress(myProgress);
}
// Return the value to be passed to onPostExecute
return result;
}
@Override
protected void onProgressUpdate(Integer... progress) {
// Synchronized to UI thread.
// Update progress bar, Notification, or other UI elements
asyncProgress.setProgress(progress[0]);
}
@Override
protected void onPostExecute(String result) {
// Synchronized to UI thread.
// Report results via UI update, Dialog, or notifications
asyncTextView.setText(result);
}
}

使用AsyncTask，首先要创建一个AsyncTask的子类类并实现doInBackground，onProgressUpdate，onPostExecute方法。这三个方法的说明：

• doInBackground: 这个方法用于执行需要在后台线程中长期运行的操作，可以通过publishProgress方法传递参数给onProgressUpdate；在这个方法执行完毕之后，此方法将返回值传递给onProgressUpdate。
• onProgressUpdate: 接收publishProgress方法传入的参数，更新UI。
• onPostExecute: doInBackground执行结束后，将返回值传入此方法。

执行AsyncTask

String input = “redrum ... redrum”;
new MyAsyncTask().execute(input);

Intent Service简介

IntentService可以通过传入Intent参数调用，传入的Intent将进入一个队列中被异步执行。IntentService封装了消息的异步处理，后台线程创建以及与UI线程的同步。继承IntentService类并实现onHandleIntent方法，即可创建一个Intent Service：

import android.app.IntentService;
import android.content.Intent;
public class MyIntentService extends IntentService {
　　public MyIntentService(String name) {
　　　　super(name);
　　　　// TODO Complete any required constructor tasks.
　　}
　　@Override
　　public void onCreate() {
　　　　super.onCreate();
　　　　// TODO: Actions to perform when service is created.
　　}
　　@Override
　　protected void onHandleIntent(Intent intent) {
　　// This handler occurs on a background thread. TODO The time consuming task should be implemented here.
　　// Each Intent supplied to this IntentService will be processed consecutively here. When all incoming Intents have been processed the Service will terminate itself.
　　}
}

Loader简介

Loader是一个抽象类，封装了异步加载数据的最佳实践，最典型的就是CursorLoader了。Android中创建Loader类的简单方法是继承AsyncTaskLoader类，并实现这两个功能：

• 异步加载数据
• 监测数据源的变化并及时更新

手动创建线程及GUI线程同步

尽管AsyncTask和Intent Service提供了简单易用的异步类封装，但我们也可以创建自定义的异步线程：

// This method is called on the main GUI thread.
private void backgroundExecution() {
　　// This moves the time consuming operation to a child thread.
　　Thread thread = new Thread(null, doBackgroundThreadProcessing, “Background”);
　　thread.start();
}
// Runnable that executes the background processing method.
private Runnable doBackgroundThreadProcessing = new Runnable() {
　　　　public void run() {
　　　　　　backgroundThreadProcessing();
　　　　}
};
// Method which does some processing in the background.
private void backgroundThreadProcessing() {
// [ ... Time consuming operations ... ]
}

与GUI线程同步:

runOnUiThread方法会在UI线程执行：

runOnUiThread(new Runnable() {
　　public void run() {
　　// Update a View or other Activity UI element.
　　}
});

此外，可以使用Handler类更新UI线程：

//This method is called on the main GUI thread.
private void backgroundExecution() {
　　// This moves the time consuming operation to a child thread.
　　Thread thread = new Thread(null, doBackgroundThreadProcessing, “Background”);
　　thread.start();
}
// Runnable that executes the background processing method.
private Runnable doBackgroundThreadProcessing = new Runnable() {
　　public void run() {
　　　　backgroundThreadProcessing();
　　}
};
// Method which does some processing in the background.
private void backgroundThreadProcessing() {
// [ ... Time consuming operations ... ]
// Use the Handler to post the doUpdateGUI
// runnable on the main UI thread.
　　handler.post(doUpdateGUI);
}
//Initialize a handler on the main thread.
private Handler handler = new Handler();
// Runnable that executes the updateGUI method.
private Runnable doUpdateGUI = new Runnable() {
　　public void run() {
　　　　updateGUI();
　　}
};
// This method must be called on the UI thread.
private void updateGUI() {
// [ ... Open a dialog or modify a GUI element ... ]
}

Handler类还可以使用postDelayed和postAtTime实现推迟运行和推迟指定时间运行：

// Post a method on the UI thread after 1sec.
handler.postDelayed(doUpdateGUI, 1000);
// Post a method on the UI thread after the device has been in use for 5mins.
int upTime = 1000*60*5;
handler.postAtTime(doUpdateGUI, SystemClock.uptimeMillis()+upTime);

使用ALARMS

与Timer不太，Alarms属于系统服务，独立于应用程序。即使应用程序为启动，也可以使用Alarms启动应用程序并获取其服务，这样不仅减少了耦合，也减少了系统资源的占用。Android中Alarms常与Broadcast Receiver一起使用。创建Alarm之前，首先要创建AlarmManager：

AlarmManager alarmManager = (AlarmManager)getSystemService(Context.ALARM_SERVICE);

创建，设置和取消ALARMS

创建Alarm需要这些参数：alarm类型，触发时间，Alarm将要触发的Pending Intent。目前Alarm类型有这些：

• RTC_WAKEUP：在指定时间启动指定Pending Intent，可以唤醒sleep中的设备。
• RTC：在指定时间启动指定Pending Intent，但不能唤醒sleep中的设备。
• ELAPSED_REALTIME：在某段时间后启动指定的Pending Intent，某段时间是从设备启动但还没有唤醒设备算起。
• ELAPSED_REALTIME_WAKEUP： 这个和ELAPSED_REALTIME的区别没搞明白，以后遇到了再查吧。

下面是一个10秒后启动Pending Intent的Alarm示例：

AlarmManager alarmManager = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
// Set the alarm to wake the device if sleeping.
int alarmType = AlarmManager.ELAPSED_REALTIME_WAKEUP;
// Trigger the device in 10 seconds.
long timeOrLengthofWait = 10000;
// Create a Pending Intent that will broadcast and action
String ALARM_ACTION = “ALARM_ACTION”;
Intent intentToFire = new Intent(ALARM_ACTION);
PendingIntent alarmIntent = PendingIntent.getBroadcast(this, 0, intentToFire, 0);
// Set the alarm
alarmManager.set(alarmType, timeOrLengthofWait, alarmIntent);

取消Alarm

alarmManager.cancel(alarmIntent);

这里的alarmIntent是指使用Alarm启动的Pending Intent。

创建可重复的Alarm

使用setRepeating或setInexactRepeating方法替代前面的set方法，并传递响应的参数进去，就可以实现可重复的Alarm。

相比setRepeating，setInexactRepeating更省电，但不能指定某个具体的时间间隔。

setInexactRepeating可以接收的时间间隔参数：

• INTERVAL_FIFTEEN_MINUTES
• INTERVAL_HALF_HOUR
• INTERVAL_HOUR
• INTERVAL_HALF_DAY
• INTERVAL_DAY

下面这个例子指定半小时后启动Alarm，然后每隔半小时启动一次:

// Get a reference to the Alarm Manager
AlarmManager alarmManager = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
// Set the alarm to wake the device if sleeping.
int alarmType = AlarmManager.ELAPSED_REALTIME_WAKEUP;
// Schedule the alarm to repeat every half hour.
long timeOrLengthofWait = AlarmManager.INTERVAL_HALF_HOUR;
// Create a Pending Intent that will broadcast and action
String ALARM_ACTION = “ALARM_ACTION”;
Intent intentToFire = new Intent(ALARM_ACTION);
PendingIntent alarmIntent = PendingIntent.getBroadcast(this, 0, intentToFire, 0);
// Wake up the device to fire an alarm in half an hour, and every half-hour after that.
alarmManager.setInexactRepeating(alarmType, timeOrLengthofWait, timeOrLengthofWait, alarmIntent);