Android异步操作之IntentService

IntentService是什么？

IntentService是一种继承了Service并且是一个抽象类的特殊Service，所以使用它时必须创建它的子类才能使用IntentService

使用IntentService的优势和局限

1、与service相比，它有以下优势：

• 可直接用于执行后台耗时任务，而Service不行
• 不受UI的生命周期的影响，当任务完成后，会自动停止，极大程度上避免了Service内存泄漏的可能性

2､ 与普通线程相比，它有以下优势：

• 会自动创建独立的工作线程来处理耗时任务，无需处理多线程的问题
• 因为它是service，这比单纯的线程的优先级要高很多，比较适合执行一些高优先级的后台任务，不容易被系统杀死

3､ 局限性

工作任务队列是顺序执行的，如果一个任务正在IntentService中执行时，此时如果再发送一个新的任务请求，这个新的任务会只能一直等待，直到前面一个任务执行结束才执行，这也导致了它的工作效率低

基本用法

test.gif

非常简单的Demo，通过IntentService去访问百度。执行完成后，自己主动destory

public class MyIntentService extends IntentService {

String resultData = null;


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


@Override
protected void onHandleIntent(Intent intent) {
    String urlData = intent.getDataString();
    URL url = null;
    HttpURLConnection conn = null;
    try {
        url = new URL(urlData);
        conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        InputStream inputStream = conn.getInputStream();
        InputStreamReader isr = new InputStreamReader(inputStream);
        BufferedReader br = new BufferedReader(isr);
        String inputLine = "";
        while ((inputLine = br.readLine()) != null) {
            resultData += inputLine + "\n";
        }
        // 官方推荐通过LocalBroadcastManager来发送广播进行UI更新
        Intent dataIntent = new Intent(AppConstants.BROADCAST_ACTION);
        dataIntent.putExtra(AppConstants.BROADCAST_RESULT, resultData);
        LocalBroadcastManager.getInstance(this).sendBroadcast(dataIntent);
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

@Override
public void onDestroy() {
    super.onDestroy();
    Toast.makeText(this,"MyIntentService onDestroy",Toast.LENGTH_SHORT).show();
}

主界面代码

public class MainActivity extends AppCompatActivity {

    private TextView mResult;
    private MyReceiver myReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mResult = (TextView) findViewById(R.id.tv_result);
        myReceiver = new MyReceiver(mResult);
        IntentFilter filter = new IntentFilter(AppConstants.BROADCAST_ACTION);
        LocalBroadcastManager.getInstance(this).registerReceiver(myReceiver, filter);
    }
    
    public void startService(View view) {

        Intent service = new Intent(this, MyIntentService.class);
        service.setData(Uri.parse(AppConstants.URL));
        startService(service);
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        LocalBroadcastManager.getInstance(this).unregisterReceiver(myReceiver);
    }
}

源码分析

@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，然后使用它的Looper来构造一个Handler对象mServiceHandler，这样通过mServiceHandler发送的消息最终都会在HandlerThread中执行。

当IntentService被create后，紧接着它的onStartCommand方法就会被调用一次，

 @Override
public int onStartCommand(Intent intent, int flags, int startId) {
    onStart(intent, startId);
    return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}

继续深入onStart方法

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

很明显，IntentService仅仅是通过mServiceHandler发送了一条消息，这个消息会在HandlerThread中被处理。

我们再来看看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);
    }
}

mServiceHandler收到消息后，会将intent对象传递给onHandleIntent方法处理。注意这个intent对象的内容和外界的startService(intent)中的intent的内容是完全一致的，通过这个intent对象即可解析出外界启动startService是所传的参数，通过这些参数就可以区分具体的后台任务。

protected abstract void onHandleIntent(Intent intent);

onHandleIntent是一个抽象方法，我们需要在子类中实现它。它的作用是从Intent参数中区分具体的任务并执行这些任务。如果目前只存在一个后台任务，那么onHandleIntent方法执行这个任务后，stopSelf(int startId)会直接停止该服务；如果目前存在多个后台任务，那么onHandleIntent会等到执行完最后一个任务时，stopSelf(int startId)会直接停止该服务。

由于每执行一个后台任务就必须启动一次IntentService，而IntentService内部则通过消息的方式向HandlerThread请求执行任务，Handler中的Looper是顺序处理消息的，这就意味着IntentService也是顺序执行后台任务的，当有多个后台任务同时存在，这些后台任务会按照外界发起的顺序排队执行

另外，当onHandleIntent执行完后，这里是采用stopSelf(int startId)来停止该服务，而不是直接采用stopSelf()，这是因为stopSelf()会立刻停止服务，而这个时候可能还有其他消息未处理；而stopSelf(int startId)则会等待所有的消息都处理完毕后才终止服务