IntentService 学习笔记

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) {
      onHandleIntent((Intent)msg.obj);
      stopSelf(msg.arg1); // 执行完毕后自动关闭
    }
  }

  /**
  * 这里的 name 是用来给工作者线程命名的. 主要是用于 debug.
  */
  public IntentService(String name) {
    super();
    mName = name;
  }

  /**
  * Sets intent redelivery preferences. Usually called from the constructor
  * with your preferred semantics.
  *
  * 如果为 true, onStartCommand(Intent, int, int) 会返回 Service#START_REDELIVER_INTENT. 
  * 那么如果进程在 onHandleIntent() 返回值之前终结, 进程会重新启动. 
  * 同时 intent 也会重新发送. 如果有许多个 intents 已经发送了. 那么只有最近的 intent 才回保证重新发送.
  *
  * 如果为 false (默认值t), onStartCommand(Intent, int, int) 将会返回
  * Service#START_NOT_STICKY, 如果进程终结. Intent 也会终结.
  */
  public void setIntentRedelivery(boolean enabled) {
    mRedelivery = enabled;
  }

  @Override
  public void onCreate() {
    super.onCreate();
    // 自己本身就建立了一个新的线程
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
  }

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

  /**
   * 不要覆写这个方法. 而应该覆写 onHandleIntent(), onHandleIntent() 会在 IntentService 接收到请求时调用.
   * 默认实现的 onStartCommand() 的目的是将intent插入到工作队列中
   */
  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    onStart(intent, startId);
    return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
  }

  @Override
  public void onDestroy() {
    mServiceLooper.quit();
  }

  /**
   * 除非你需要给你的 service 提供绑定. 不然不需要实现这个方法. 因为默认返回 null
   */
  @Override
  public IBinder onBind(Intent intent) {
    return null;
  }

  /**
   * 这个方法会在工作者线程中被调用. 同一时间只有一个 Intent 被执行. 
   * 但是这个工作者线程是和其他的应用逻辑是独立的. 它只会用来处理 IntentService 的请求. 而不会干其他事. 
   * 当所有请求执行完毕. IntentService 会自动关. 不需要再调用 stopSelf(). 
   */
  @WorkerThread
  protected abstract void onHandleIntent(Intent intent);
}

public class IntentServiceSub extends IntentService {    

  private static final String TAG = "IntentServiceSub";    

  public IntentServiceSub() {        
    super("IntentServiceSub");        
    Log.i(TAG, "=>IntentServiceSub");    
  }    
   
  @Override    
  public void onCreate() {        
    Log.i(TAG, "=>onCreate");        
    super.onCreate();    
  }    
  
  @Override    
  public void onDestroy() {        
    Log.i(TAG, "=>onDestroy");        
    super.onDestroy();   
  }    

  @Override    
  protected void onHandleIntent(Intent arg0) {        
    Log.i(TAG, "IntentService 线程："+Thread.currentThread.getId());
    // ToDo 这里添加服务的逻辑                   
  }
}