android - ¿Puede un IntentService ejecutarse indefinidamente?

Question

Según mi entendimiento, un IntentService se detendrá cuando se realice su solicitud actual.

Considere el siguiente escenario, estaré activando una solicitud al IntentSerivce por cada 100 ms y el tiempo de procesamiento será de 90 ms para esa solicitud.

Por lo tanto, para cada una de mis solicitudes: la llamada startSerivce, el servicio se invocará y después de 90 ms (una vez que se haya realizado el procesamiento), se invocará onDestroy of IntentServicee.

Me gustaría tener este IntentServicee funcionando hasta que yo diga que se detenga. ¿Es eso posible?

Supongo que voy a hacer lo siguiente en mi servicio.

1. Configuralo
2. Enviar alguna solicitud
3. esperar respuesta
4. lee la respuesta
5. Difusión a la actividad que invocó.

Los pasos 1 son comunes para todas mis solicitudes, así que pensé que puedo hacerlas cuando el servicio se inicia inicialmente una vez y luego hacer 3-6 en HandleIntent en función de las solicitudes.

Answer 1

Debe crear un Service y bind a su servicio para evitar que se detenga. Ver los docs .

El servicio que se iniciará con bindService() se ejecutará hasta que ninguna actividad esté vinculada a él.

Answer 2

Si no tiene mucho trabajo que hacer en el servicio, simplemente puede extender un servicio regular. Devuelve null en onBind () y recibe comandos en onStartCommand () que devuelve START_STICKY.

Answer 3

IntentService se extiende desde la clase de Service estándar, por lo que no veo por qué no debería hacerse de esta manera. De hecho lo haré de esta manera también. ;)

Answer 4

El IntentService es en realidad una clase bastante pequeña que envuelve a un Handler, el problema es que una vez que se ha manejado un Intent, llama a stopSelf() .

La eliminación de esa línea única le proporciona un IntentService que debe detenerse explícitamente:

public abstract class NonStopIntentService extends Service {

    private String mName;
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;

    public NonStopIntentService(String name) {
        super();
        mName = name;
    }

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

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return START_STICKY;
    }    

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

    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        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.
     *
     * @param intent The value passed to {@link
     *               android.content.Context#startService(Intent)}.
     */
    protected abstract void onHandleIntent(Intent intent);  

}