參考《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

@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的值傳入。

啟動和停止服務

呼叫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);