intentService解析

先说自己的理解:intentservice 相当于一个做完事自己了结自己的线程.

好比厉鬼,一般情况下不会被干掉,对一件事情执念很深,自己心愿完成了就自己飞升了.

注意加粗字体

再上源码

路径：alps\frameworks\base\core\java\Android\app\IntentService.java 

public abstract class IntentService extends Service {  
    private volatile Looper mServiceLooper;  
    private volatile ServiceHandler mServiceHandler;  
    private String mName;  
    private boolean mRedelivery;  
  
    private final class ServiceHandler extends Handler {  
        public ServiceHandler(Looper looper) {  
            super(looper);  
        }  
  
        @Override  
        public void handleMessage(Message msg) {  
		//自定义的IntentService子类主要就是实现onHandleIntent这个函数了。注意执行完这个之后就  
        //stopSelf了，传入的参数是startId。  
        onHandleIntent((Intent)msg.obj);  
        stopSelf(msg.arg1);  
    }  
}  
  
/** 
 * Creates an IntentService.  Invoked by your subclass's constructor. 
 * 
 * @param name Used to name the worker thread, important only for debugging. 
 */  
public IntentService(String name) {  
    super();  
    mName = name;  
}  
  
/** 
 * Sets intent redelivery preferences.  Usually called from the constructor 
 * with your preferred semantics. 
 * 
 * <p>If enabled is true, 
 * {@link #onStartCommand(Intent, int, int)} will return 
 * {@link Service#START_REDELIVER_INTENT}, so if this process dies before 
 * {@link #onHandleIntent(Intent)} returns, the process will be restarted 
 * and the intent redelivered.  If multiple Intents have been sent, only 
 * the most recent one is guaranteed to be redelivered. 
 * 
 * <p>If enabled is false (the default), 
 * {@link #onStartCommand(Intent, int, int)} will return 
 * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent 
 * dies along with it. 
 */  
public void setIntentRedelivery(boolean enabled) {  
    mRedelivery = enabled;  
}  
  
@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();  

//好好看看下面这个代码，启动了一个工作线程，获取线程的Looper，然后用这个Looper初始化Handler句柄  

//这样以后可以直接用mHandler.sendMessage的方式将任务直接放到工作线程了。  

    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");  
    thread.start();  
  
    mServiceLooper = thread.getLooper();  
    mServiceHandler = new ServiceHandler(mServiceLooper);  
}  
  
@Override  
public void onStart(Intent intent, int startId) {  

//从消息队列中获取一个消息，一般都是用这种方式初始化一个消息，而不是用new message()形式  

    //效率更高，代码更健壮  
    Message msg = mServiceHandler.obtainMessage();  
    msg.arg1 = startId;//  
    msg.obj = intent;//这个就是startService的时候传入的Intent了，  
    mServiceHandler.sendMessage(msg);//将包含请求内容Intent的message传入到工作线程中  
}  
  
/** 
 * 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，和它传入的值。  
        onStart(intent, startId);  
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;  
    }  
  
    @Override  
    public void onDestroy() {  
        mServiceLooper.quit();  
    }  
  
    /** 
     * Unless you provide binding for your service, you don't need to implement this 
     * method, because the default implementation returns null.  
     * @see android.app.Service#onBind 
     */  
    @Override  
    public IBinder onBind(Intent intent) {  
        return null;  
    }  
  
    /** 
     * This method is invoked on the worker thread with a request to process. 
     * Only one Intent is processed at a time, but the processing happens on a 
     * worker thread that runs independently from other application logic. 
     * So, if this code takes a long time, it will hold up other requests to 
     * the same IntentService, but it will not hold up anything else. 
     * When all requests have been handled, the IntentService stops itself, 
     * so you should not call {@link #stopSelf}. 
     * 
     * @param intent The value passed to {@link 
     *               android.content.Context#startService(Intent)}. 
     */  
    protected abstract void onHandleIntent(Intent intent);  
}  

IntentService继承自Service，它是一个抽象类，其被创建的时候就new了一个HandlerThread和ServiceHandler，有了它，就可以利用IntentService做一些优先级较高的task，IntentService不会被系统轻易杀掉。为啥不会...我也不知道...

使用IntentService也是很简单，首先startService(intent)，然后IntentService会把你的intent封装成Message然后通过ServiceHandler进行发送，接着ServiceHandler会调用onHandleIntent(Intent intent)来处理这个Message，onHandleIntent(Intent intent)中的intent就是你startService(intent)中的intent，ok，现在你需要做的是从IntentService派生一个子类并重写onHandleIntent方法，然后你只要针对不同的intent做不同的事情即可，事情完成后IntentService会自动停止。所以，IntentService是除了Thread和AsyncTask外又一执行耗时操作的方式，而且其不容易被系统干掉，建议关键操作采用IntentService。 注意:只有onHandleIntent的执行是在另外一个新线程中，其他函数（onCreate/onStart/onStartCommand等）的执行都是在main线程（主线程的名称）中

IntentService的优缺点都显而易见：

使用方便，代码简洁，不再需要我们自己像Service里面还要去创建线程；

由于是单个的worker thread，所以任务需要排队，不适合大多数的多任务情况；

自己懒的写,又怕乃们看不懂,就附个抄来的小栗子  : )

package com.test;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

import java.lang.Thread;
/**
 * @desc IntentService的实现类：每隔200ms将一个数字+2并通过广播发送出去
 * @author skywang
 *
 */
public class IntentServiceSub extends IntentService {
    private static final String TAG = "skywang-->IntentServiceTest";
    
    // 发送的广播对应的action
    private static final String COUNT_ACTION = "com.test.COUNT_ACTION";
    
    // 线程：用来实现每隔200ms发送广播
    private static CountThread mCountThread = null;
    // 数字的索引
    private static int index = 0;
    
    public IntentServiceSub() {
        super("IntentServiceSub");
        Log.d(TAG, "create IntentServiceSub");
    }

    @Override
    public void onCreate() {
        Log.d(TAG, "onCreate");
        super.onCreate();
    }
    
    @Override
    public void onDestroy() {
        Log.d(TAG, "onDestroy");        
        super.onDestroy();
    }
    
    @Override
    protected void onHandleIntent(Intent intent) {
        Log.d(TAG, "onHandleIntent");
        // 非首次运行IntentServiceSub服务时，执行下面操作
        // 目的是将index设为0
        if ( mCountThread != null) {
            index = 0;
            return;
        }
        
        // 首次运行IntentServiceSub时，创建并启动线程
        mCountThread = new CountThread();
        mCountThread.start();
    }
    
    private class CountThread extends Thread {
        @Override 
        public void run() {
            index = 0;
            try {
                while (true) {
                    // 将数字+2,
                    index += 2;                    
                    
                    // 将index通过广播发送出去
                    Intent intent = new Intent(COUNT_ACTION);
                    intent.putExtra("count", index);
                    sendBroadcast(intent);
//                    Log.d(TAG, "CountThread index:"+index);
                    
                    // 若数字>=100 则退出
                    if (index >= 100) {
                        if ( mCountThread != null)
                            mCountThread = null;
                        
                        return ;
                    }
                    
                    // 200ms
                    this.sleep(200);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}