IntentService explicar (para usar el código fuente de la línea y otra vez)

¿Por IntentService?

Sabemos, servicio como uno de los cuatro componentes, que va a correr en el hilo principal, por lo que si tenemos una operación que consume tiempo, debe abrir un nuevo hilo.
Para este fin androide proporciona una clase dedicada, es IntentService, su interior contiene un controlador para procesar un subproceso en segundo plano.
Uso IntentService, en primer lugar heredad la tierra, y luego darse cuenta de método onHandleIntent ().

Por ejemplo, la simulación de demostración de carga y descarga de archivos:
Mi IntentService:

package example.ylh.com.service_demo;

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

/**
 * Created by yangLiHai on 2017/8/30.
 */

public class TestIntentService extends IntentService {

    private String TAG = TestIntentService.class.getSimpleName();
    public static final String ACTION_UPLOAD_FILE = "action_upload_file";
    public static final String ACTION_DOWNLOAD_FILE = "action_download_file";

    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     *  Used to name the worker thread, important only for debugging.
     */
    public TestIntentService() {
        super("test intent service");
        Log.e(TAG,"construction");
    }

    @Override
    public void onCreate() {
        Log.e(TAG,"oncreate");
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        Log.e(TAG,"ondestroy");
        super.onDestroy();
    }

    @Override
    protected void onHandleIntent(Intent intent) {

        String action = intent.getAction();
        if (action.equals(ACTION_DOWNLOAD_FILE)){
            downloadFile();
        }else if (action.equals(ACTION_UPLOAD_FILE)){
            uploadFile();
        }
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void uploadFile(){

        Log.e(TAG,"handleintent upload:"+Thread.currentThread().getId()+"");
    }
    private void downloadFile(){

        Log.e(TAG,"handleintent download:"+Thread.currentThread().getId()+"");
    }
}

Código de la actividad:

package example.ylh.com.service_demo;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;

import example.ylh.com.R;

/**
 * Created by yanglihai on 2017/8/17.
 */

public class ServiceTestActivity extends Activity {

    public static final String TAG = ServiceTestActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.service_test_activity);

        findViewById(R.id.btn4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startUploadService();
            }
        });
        findViewById(R.id.btn5).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startDownloadService();
            }
        });
    }

    public void startDownloadService(){
        Intent i = new Intent(ServiceTestActivity.this, TestIntentService.class);
        i.setAction(TestIntentService.ACTION_DOWNLOAD_FILE);
        startService(i);
    }
    public void startUploadService(){
        Intent i = new Intent(ServiceTestActivity.this, TestIntentService.class);
        i.setAction(TestIntentService.ACTION_UPLOAD_FILE);
        startService(i);
    }


}

Para pasar los datos a través de Intención, distribuir diferentes tareas. Múltiples llamadas se pueden colocar dentro de la cola de controlador, en cualquier momento sólo hay una intención está siendo procesado, la cola cuando no hay necesidad de manejar la tarea, se destruirá.
Haga clic en el botón para imprimir dos veces fueron los siguientes:

Se puede ver claramente, las tareas de carga y descarga se realizan en la sub-hilo, cuando la ejecución de todas las tareas completa destruirá. Así que utilice IntentService no tenemos en cuenta el ciclo de vida del servicio, no tiene que crear sus propias tareas abiertas hilo hijo, todo se hace para ayudarnos, todavía es muy fácil de usar.

fuente IntentService análisis
IntentService heredado del servicio, que es un servicio especial, que es el interior del paquete y el HandlerThread Handler.
Esta es su método 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);
    }

Al empezar, el método onCreate se llama, creó un HandlerThread, y luego usarlo para construir una mServiceHandler looper (un manipulador de objetos). Tal mServiceHandler puede manejar la tarea en un hilo hijo. Después de realizar oncreat, llevará a cabo el método onStartCommand, invocado en varias ocasiones onStartCommand iniciar método IntentService varias veces,
que es el código onStartCommand método específico:

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

Se puede ver el interior llamado método onStart, veamos método onStart:

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

En el método onStart, cada vez que se envía un mensaje con mServiceHandler, a continuación, echamos un vistazo a mServiceHandler código:

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);
      }
  }

Se puede ver claramente, después cada uno recibió intención, la intención será la de onHandleIntent método de tratar, que es el camino que tenemos que ser reescrito, por la intención de que podemos analizar los datos que se pasan en el mundo exterior, manejados en consecuencia. Después de onHandleIntent ejecutado, y se ejecuta stopSelf (int startID) método para cerrar sí mismo. Pero él no se va a cerrar de inmediato, pero esperar hasta después de toda la intención de terminar el servicio para ser procesados. En general, stopSelf (int startID) antes de cerrar el servicio puesto en marcha recientemente determinará el número y la igualdad startID, parar inmediatamente el servicio si son iguales, si no igual, no a tope.

Bajo IntentService mayoría de los casos son muy sencilla y práctica, sólo es necesario para generar un fondo de operaciones de la tarea sin tiempo para iniciar la relación, si el envío de múltiples Intención de IntentService, éstos Intención se ejecutarán de forma secuencial, cada ejecución a. Si hay demanda concurrente, no es adecuado para su uso IntentService, o escribir usted mismo servicio.

IntentService aquí se ha acabado, leen mis ejemplos se ven en la fuente, creo que ha sido capaz de comprender plenamente.
Si no hay bastante exacto decir por favor, dame un mensaje, gracias.