¿Cómo forzar que un IntentService se detenga inmediatamente con un botón cancelar de una actividad?

Aquí está el truco, hacer uso de una variable estática volátil y comprobar continuar condición en algunas de las líneas en su servicio que el servicio continuar debe ser comprobado:

class MyService extends IntentService {
    public static volatile boolean shouldContinue = true;
    public MyService() {
        super("My Service");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        doStuff();
    }

    private void doStuff() {
        // do something 

        // check the condition
        if (shouldContinue == false) {
            stopSelf();
            return;
        }

       // continue doing something

       // check the condition
       if (shouldContinue == false) {
           stopSelf();
           return;
       }

       // put those checks wherever you need
   }
}

Y en su actividad hacer esto para detener su servicio,

 MyService.shouldContinue = false;

He utilizado un BroadcastReceiver dentro del servicio que simplemente pone un booleano stop a true. Ejemplo:

private boolean stop=false;

public class StopReceiver extends BroadcastReceiver {

   public static final String ACTION_STOP = "stop";

   @Override
   public void onReceive(Context context, Intent intent) {
       stop = true;
   }
}


@Override
protected void onHandleIntent(Intent intent) {
    IntentFilter filter = new IntentFilter(StopReceiver.ACTION_STOP);
    filter.addCategory(Intent.CATEGORY_DEFAULT);
    StopReceiver receiver = new StopReceiver();
    registerReceiver(receiver, filter);

    // Do stuff ....

    //In the work you are doing
    if(stop==true){
        unregisterReceiver(receiver);
        stopSelf();
    }
}

Luego, desde la llamada a la actividad:

//STOP SERVICE
Intent sIntent = new Intent();
sIntent.setAction(StopReceiver.ACTION_STOP);
sendBroadcast(sIntent);

Para detener el servicio.

PD: Uso un booleano porque en mi caso detengo el servicio mientras estoy en un bucle, pero probablemente puedes llamar a unregisterReceiver y stopSelf en onReceive.

PD2: No olvide llamar a unregisterReceiver si el servicio termina su trabajo normalmente o obtendrá un IntentReceiver filtrado error.

En el caso de IntentService no se detiene ni toma ninguna otra solicitud a través de alguna acción de intención hasta que su método onHandleIntent complete la solicitud anterior.

Si intentamos iniciar IntentService de nuevo con alguna otra acción, onHandleIntent se llamará solo cuando se haya terminado la intent / tarea anterior.

También stopService(intent); o stopSelf(); no funciona hasta que el método onHandleIntent() termina su tarea.

Así que creo que aquí la mejor solución es usar normal Service aquí.

Espero que ¡ayudará!

Si usas un IntentService, entonces creo que estás atascado haciendo algo como lo describes, donde el código onHandleIntent() tiene que sondear su señal de "stop".

Si su tarea en segundo plano es potencialmente de larga duración, y si necesita ser capaz de detenerla, creo que es mejor usar un Service simple en su lugar. En un alto nivel, escriba su Servicio a:

• Exponer una Intent" start " para iniciar una AsyncTask para realizar su trabajo en segundo plano, guardando una referencia a esa nueva creación AsyncTask.
• Expone una Intención de "cancelar" para invocar AsyncTask.cancel(true), o hacer que onDestroy invoque AsyncTask.cancel(true).
• La Actividad puede entonces enviar la Intent "cancelar" o simplemente llamar a stopService().

A cambio de la capacidad de cancelar el trabajo en segundo plano, el Servicio asume las siguientes responsabilidades:

• El AsyncTask doInBackground() tendrá que manejar con gracia la excepción interrumpida y/o verificar periódicamente si hay Subprocesos.interrumpida (), y retorno "temprano".
• El Servicio tendrá que asegurarse de que stopSelf() es llamado (tal vez en AsyncTask onPostExecute/onCancelled).

@Override
protected void onHandleIntent(Intent intent) {
    String action = intent.getAction();
    if (action.equals(Action_CANCEL)) {
        stopSelf();
    } else if (action.equals(Action_START)) {
        //handle
    }
}

Espero que funcione.

Como @budius ya mencionó en su comentario, debe establecer un booleano en el Service cuando haga clic en ese botón:

// your Activity.java
public boolean onClick() {
   //...
   mService.performTasks = false;
   mService.stopSelf();
}

Y en su manejo Intent, antes de hacer la importante tarea de confirmar / enviar la información de intent, simplemente use ese booleano:

// your Service.java
public boolean performTasks = true;

protected void onHandleIntent(Intent intent) {
   Bundle intentInfo = intent.getBundle();
   if (this.performTasks) {
      // Then handle the intent...
   }
}

De lo contrario, el Servicio hará su tarea de procesamiento Intent. Así es como estaba destinado a ser utilizado, porque no puedo ver cómo se podría resolver de otra manera si nos fijamos en el núcleo codificar.

Aquí hay un código de ejemplo para iniciar/detener el servicio

Para empezar,

Intent GPSService = new Intent(context, TrackGPS.class);
context.startService(GPSService);

Para parar,

context.stopService(GPSService);

context.stopService(GPSService);