Android IntentService

特點

• 它本質是一種特殊的Service,繼承自Service並且本身就是一個抽象類
• 它可以用於在後臺執行耗時的非同步任務，當任務完成後會自動停止
• 它擁有較高的優先順序，不易被系統殺死（繼承自Service的緣故），因此比較適合執行一些高優先順序的非同步任務
• 它內部通過HandlerThread和Handler實現非同步操作
• 建立IntentService時，只需實現onHandleIntent和構造方法，onHandleIntent為非同步方法，可以執行耗時操作

使用例項

public  class MyIntentService extends IntentService {
    public static final String DOWNLOAD_URL="download_url";
    public static final String INDEX_FLAG="index_flag";
    public static UpdateUI updateUI;


    public static void setUpdateUI(UpdateUI updateUIInterface){
        updateUI=updateUIInterface;
    }

    public MyIntentService(){
        super("MyIntentService");
    }

    /**
     * 實現非同步任務的方法
     * @param intent Activity傳遞過來的Intent,資料封裝在intent中
     */
    @Override
    protected void onHandleIntent(Intent intent) {

        //在子執行緒中進行網路請求
        Bitmap bitmap=downloadUrlBitmap(intent.getStringExtra(DOWNLOAD_URL));
        Message msg1 = new Message();
        msg1.what = intent.getIntExtra(INDEX_FLAG,0);
        msg1.obj =bitmap;
        //通知主執行緒去更新UI
        if(updateUI!=null){
            updateUI.updateUI(msg1);
        }
        //mUIHandler.sendMessageDelayed(msg1,1000);

        LogUtils.e("onHandleIntent");
    }
    //----------------------重寫一下方法僅為測試------------------------------------------
    @Override
    public void onCreate() {
        LogUtils.e("onCreate");
        super.onCreate();
    }

    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
        LogUtils.e("onStart");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        LogUtils.e("onStartCommand");
        return super.onStartCommand(intent, flags, startId);

    }

    @Override
    public void onDestroy() {
        LogUtils.e("onDestroy");
        super.onDestroy();
    }

    @Override
    public IBinder onBind(Intent intent) {
        LogUtils.e("onBind");
        return super.onBind(intent);
    }


    public interface UpdateUI{
        void updateUI(Message message);
    }


    private Bitmap downloadUrlBitmap(String urlString) {
        HttpURLConnection urlConnection = null;
        BufferedInputStream in = null;
        Bitmap bitmap=null;
        try {
            final URL url = new URL(urlString);
            urlConnection = (HttpURLConnection) url.openConnection();
            in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
            bitmap= BitmapFactory.decodeStream(in);
        } catch (final IOException e) {
            e.printStackTrace();
        } finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            try {
                if (in != null) {
                    in.close();
                }
            } catch (final IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }

}

通過程式碼可以看出，我們繼承了IntentService，這裡有兩個方法是必須實現的，一個是構造方法，必須傳遞一個執行緒名稱的字串，另外一個就是進行非同步處理的方法onHandleIntent(Intent intent) 方法，其引數intent可以附帶從activity傳遞過來的資料。這裡我們的案例主要利用onHandleIntent實現非同步下載圖片，然後通過回撥監聽的方法把下載完的bitmap放在message中回撥給Activity（當然也可以使用廣播完成），最後通過Handler去更新UI。下面再來看看Acitvity的程式碼：

public class IntentServiceActivity extends Activity implements MyIntentService.UpdateUI{
    /**
     * 圖片地址集合
     */
    private String url[] = {
            "https://img-blog.csdn.net/20160903083245762",
            "https://img-blog.csdn.net/20160903083252184",
            "https://img-blog.csdn.net/20160903083257871",
            "https://img-blog.csdn.net/20160903083257871",
            "https://img-blog.csdn.net/20160903083311972",
            "https://img-blog.csdn.net/20160903083319668",
            "https://img-blog.csdn.net/20160903083326871"
    };

    private static ImageView imageView;
    private static final Handler mUIHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            imageView.setImageBitmap((Bitmap) msg.obj);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_intent_service);
        imageView = (ImageView) findViewById(R.id.image);

        Intent intent = new Intent(this,MyIntentService.class);
        for (int i=0;i<7;i++) {//迴圈啟動任務
            intent.putExtra(MyIntentService.DOWNLOAD_URL,url[i]);
            intent.putExtra(MyIntentService.INDEX_FLAG,i);
            startService(intent);
        }
        MyIntentService.setUpdateUI(this);
    }

    //必須通過Handler去更新，該方法為非同步方法，不可更新UI
    @Override
    public void updateUI(Message message) {
        mUIHandler.sendMessageDelayed(message,message.what * 1000);
    }
}

程式碼比較簡單，通過for迴圈多次去啟動IntentService，然後去下載圖片，注意即使我們多次啟動IntentService，但IntentService的例項只有一個，這跟傳統的Service是一樣的，最終IntentService會去呼叫onHandleIntent執行非同步任務。這裡可能我們還會擔心for迴圈去啟動任務，而例項又只有一個，那麼任務會不會被覆蓋掉呢？其實是不會的，因為IntentService真正執行非同步任務的是HandlerThread+Handler，每次啟動都會把下載圖片的任務新增到依附的訊息佇列中，最後由HandlerThread+Handler去執行.

原始碼解析

IntentService的onCreate方法：

@Override
public void onCreate() {
   // TODO: It would be nice to have an option to hold a partial wakelock
   // during processing, and to have a static startService(Context, Intent)
   // method that would launch the service & hand off a wakelock.

   super.onCreate();
   HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
   thread.start();

   mServiceLooper = thread.getLooper();
   mServiceHandler = new ServiceHandler(mServiceLooper);
}

當第一啟動IntentService時，它的onCreate方法將會被呼叫，其內部會去建立一個HandlerThread並啟動它，接著建立一個ServiceHandler（繼承Handler），傳入HandlerThread的Looper物件，這樣ServiceHandler就變成可以處理非同步執行緒的執行類了（因為Looper物件與HandlerThread繫結，而HandlerThread又是一個非同步執行緒，我們把HandlerThread持有的Looper物件傳遞給Handler後，ServiceHandler內部就持有非同步執行緒的Looper，自然就可以執行非同步任務了），那麼IntentService是怎麼啟動非同步任務的呢？其實IntentService啟動後還會去呼叫onStartCommand方法，而onStartCommand方法又會去呼叫onStart方法，我們看看它們的原始碼：

@Override
public void onStart(Intent intent, int startId) {
    Message msg = mServiceHandler.obtainMessage();
    msg.arg1 = startId;
    msg.obj = intent;
    mServiceHandler.sendMessage(msg);
}

/**
 * You should not override this method for your IntentService. Instead,
 * override {@link #onHandleIntent}, which the system calls when the IntentService
 * receives a start request.
 * @see android.app.Service#onStartCommand
 */
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    onStart(intent, startId);
    return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}

從原始碼我們可以看出，在onStart方法中，IntentService通過mServiceHandler的sendMessage方法傳送了一個訊息，這個訊息將會傳送到HandlerThread中進行處理（因為HandlerThread持有Looper物件，所以其實是Looper從訊息佇列中取出訊息進行處理，然後呼叫mServiceHandler的handleMessage方法），我們看看ServiceHandler的原始碼：

private final class ServiceHandler extends Handler {
   public ServiceHandler(Looper looper) {
       super(looper);
   }

   @Override
   public void handleMessage(Message msg) {
       onHandleIntent((Intent)msg.obj);
       stopSelf(msg.arg1);
   }
}

這裡其實也說明onHandleIntent確實是一個非同步處理方法（ServiceHandler本身就是一個非同步處理的handler類），在onHandleIntent方法執行結束後，IntentService會通過 stopSelf(int startId)方法來嘗試停止服務。這裡採用stopSelf(int startId)而不是stopSelf()來停止服務，是因為stopSelf()會立即停止服務，而stopSelf(int startId)會等待所有訊息都處理完後才終止服務。最後看看onHandleIntent方法的宣告：

protected abstract void onHandleIntent(Intent intent);

到此我們就知道了IntentService的onHandleIntent方法是一個抽象方法，所以我們在建立IntentService時必須實現該方法，通過上面一系列的分析可知，onHandleIntent方法也是一個非同步方法。這裡要注意的是如果後臺任務只有一個的話，onHandleIntent執行完，服務就會銷燬，但如果後臺任務有多個的話，onHandleIntent執行完最後一個任務時，服務才銷燬。最後我們要知道每次執行一個後臺任務就必須啟動一次IntentService，而IntentService內部則是通過訊息的方式傳送給HandlerThread的，然後由Handler中的Looper來處理訊息，而Looper是按順序從訊息佇列中取任務的，也就是說IntentService的後臺任務時順序執行的，當有多個後臺任務同時存在時，這些後臺任務會按外部呼叫的順序排隊執行，我們前面的使用案例也很好說明了這點。

參考

http://blog.csdn.net/javazejian/article/details/52426425