android - siempre - Continuar con el servicio incluso si la aplicación se borra de la aplicación reciente

servicio siempre activo android studio

Question

Estoy teniendo un pequeño problema

En mi aplicación, se inicia un Servicio después de que el usuario haya iniciado sesión correctamente. Anteriormente, el servicio debía detenerse si se cancelaba la aplicación. (por ejemplo, eliminado de la lista de aplicaciones recientes al deslizar). Así que usamos android:stopWithTask="true" . Ahora necesitamos que el Servicio se ejecute tal como está, incluso si la Tarea que lo inició, se elimina de la lista de Aplicaciones recientes. Así que cambié el Servicio para incluir android:stopWithTask="false" . Pero eso no parece funcionar.

Código relacionado:

Aquí está la parte manifiesta relacionada con el Servicio:

<service
android:enabled="true"
android:name=".MyService"
android:exported="false"
android:stopWithTask="false" />

En MyService.java:

public class MyService extends AbstractService {
@Override
public void onStartService() {
Intent intent = new Intent(this, MyActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
Notification notification = new Notification(R.drawable.ic_launcher, "My network services", System.currentTimeMillis());
notification.setLatestEventInfo(this, "AppName", "Message", pendingIntent);
startForeground(MY_NOTIFICATION_ID, notification);
}
@Override
public void onTaskRemoved(Intent rootIntent) {
Toast.makeText(getApplicationContext(), "onTaskRemoved called", Toast.LENGTH_LONG).show();
System.out.println("onTaskRemoved called");
super.onTaskRemoved(rootIntent);
}
}

AbstractService.java es una clase personalizada que extiende Sevrice :

public abstract class AbstractService extends Service {
protected final String TAG = this.getClass().getName();
@Override
public void onCreate() {
super.onCreate();
onStartService();
Log.i(TAG, "onCreate(): Service Started.");
}
@Override
public final int onStartCommand(Intent intent, int flags, int startId) {
Log.i(TAG, "onStarCommand(): Received id " + startId + ": " + intent);
return START_STICKY; // run until explicitly stopped.
}
@Override
public final IBinder onBind(Intent intent) {
return m_messenger.getBinder();
}
@Override
public void onDestroy() {
super.onDestroy();
onStopService();
Log.i(TAG, "Service Stopped.");
}
public abstract void onStartService();
public abstract void onStopService();
public abstract void onReceiveMessage(Message msg);
@Override
public void onTaskRemoved(Intent rootIntent) {
Toast.makeText(getApplicationContext(), "AS onTaskRemoved called", Toast.LENGTH_LONG).show();
super.onTaskRemoved(rootIntent);
}
}

Ahora, si inicio sesión en la aplicación, se inicia MyService. Después de eso presiono el botón de Inicio, por lo que la aplicación se mueve al fondo. Ahora elimino la aplicación de la lista de aplicaciones recientes. En ese momento, debería ver el mensaje Toast y la consola, según la descripción de este método:

public void onTaskRemoved (Intento rootIntent)

Agregado en API nivel 14

Esto se llama si el servicio se está ejecutando actualmente y el usuario ha eliminado una tarea que proviene de la aplicación del servicio. Si ha configurado ServiceInfo.FLAG_STOP_WITH_TASK, no recibirá esta devolución de llamada; en cambio, el servicio simplemente se detendrá.

Parámetros rootIntent Intento raíz original que se utilizó para iniciar la tarea que se está eliminando.

Pero no estoy viendo nada de eso. El servicio regresa START_STICKY en onStartCommand , por lo que creo que onTaskRemoved debería onTaskRemoved junto con el indicador android:stopWithTask="false" .

¿Me estoy perdiendo algo?

Avíseme en caso de que necesite agregar algún código que podría ser importante para descubrir qué está mal.

PD: Probé esto en 4.2.2 hasta ahora.

PD: acabo de probar el mismo código en 4.1.2, en el que el Servicio sigue ejecutándose, y también recibo el mensaje "onTaskRemoved llamado" en el registro.

¿Qué debo hacer para que esto funcione en todas las versiones?

Answer 1

En su servicio, agregue el siguiente código. Me funciona bien en 4.4.2

Aquí hay una solución que encontré y funciona bien para reiniciar un servicio si su proceso se cierra al cerrar la aplicación.

 @Override public void onTaskRemoved(Intent rootIntent){
Intent restartServiceIntent = new Intent(getApplicationContext(), this.getClass());
PendingIntent restartServicePendingIntent = PendingIntent.getService(
getApplicationContext(), 1, restartServiceIntent, PendingIntent.FLAG_ONE_SHOT);
AlarmManager alarmService = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
alarmService.set(ELAPSED_REALTIME, elapsedRealtime() + 1000,
restartServicePendingIntent);
super.onTaskRemoved(rootIntent);
}

Answer 2

Escriba las 5 líneas que agregué en oncreate() de la clase de servicio

Me gusta esto:

public class AlarmService extends Service {
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
Intent iHeartBeatService = new Intent(AlarmService.this,
AlarmService.class);
PendingIntent piHeartBeatService = PendingIntent.getService(this, 0,
iHeartBeatService, PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
alarmManager.cancel(piHeartBeatService);
alarmManager.setRepeating(AlarmManager.RTC_WAKEUP,
System.currentTimeMillis(), 1000, piHeartBeatService);
}
}

o

prueba este

public class MyService extends Service{
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return null;
}
@Override
public void onCreate() {
// TODO Auto-generated method stub
super.onCreate();
System.out.println("service created");
}
@SuppressLint("NewApi")
@Override
public void onTaskRemoved(Intent rootIntent) {
// TODO Auto-generated method stub
System.out.println("onTaskRemoved");
super.onTaskRemoved(rootIntent);
}
@Override
@Deprecated
public void onStart(Intent intent, int startId) {
// TODO Auto-generated method stub
super.onStart(intent, startId);
System.out.println("Service started");
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Service is running");
}
}, 5000);
}
}

Answer 3

Parece que quitar una aplicación de las ''tareas recientes'' mata todo lo adjunto.

Tal vez debería echar un vistazo allí para encontrar una manera de relanzar su servicio si se detiene: https://.com/a/22464640/4232337

Answer 4

Si está bien poner una notificación mientras el servicio se está ejecutando, puede usar startForegroundService y startForeground para lograrlo.

Hay tres trucos importantes:

1. Llame a startForegroundService que crea un servicio de larga ejecución no limitado al contexto enlazado y haga una promesa de llamar a startForeground más tarde.
2. Regrese START_STICKY en onStartComand
3. Llame a startForeground con una notificación como se prometió en (1).

Por ejemplo, si desea ejecutar un TimerService, en su TimerActivity hará lo siguiente:

private var timerService: TimerService? = null
private val timerServiceConnection = object : ServiceConnection {
override fun onServiceConnected(className: ComponentName, service: IBinder) {
val binder = service as TimerService.Binder
timerService = binder.getService()
}
override fun onServiceDisconnected(arg0: ComponentName) {
}
}
override fun onCreate(savedInstanceState: Bundle?) {
...
startButton.setOnClickListener {
timerService?.startTimer(60L, 0L)
}
}
override fun onStart() {
super.onStart()
Intent(this, TimerService::class.java).also {
ContextCompat.startForegroundService(this, it) // that''s the first trick
bindService(it, timerServiceConnection, Context.BIND_AUTO_CREATE)
}
}
override fun onStop() {
super.onStop()
unbindService(timerServiceConnection)
timerService?.updateNotification(secondsRemaining)
}

Su TimerService será algo así:

class TimerService : Service() {
private val binder = Binder()
private var serviceLooper: Looper? = null
private var serviceHandler: ServiceHandler? = null
private var timer: CountDownTimer? = null
private val notificationUtil by lazy {
NotificationUtil(this)
}
override fun onCreate() {
HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply {
start()
serviceLooper = looper
serviceHandler = ServiceHandler(looper)
}
}
override fun onBind(intent: Intent?): IBinder? = binder
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
val timerRemaining = intent?.getLongExtra(EXTRA_REMAINING, 0) ?: 0L
if (timerRemaining != 0L) {
serviceHandler?.obtainMessage()?.also { msg ->
msg.arg1 = startId
msg.data.putLong(EXTRA_REMAINING, timerRemaining)
serviceHandler?.sendMessage(msg)
}
}
return START_STICKY // that''s the second trick
}
override fun onDestroy() {
super.onDestroy()
timer?.cancel()
}
fun startTimer(secondsRemaining: Long, id: Long) {
updateNotification(secondsRemaining)
Intent(this, TimerService::class.java).apply {
putExtra(EXTRA_REMAINING, secondsRemaining)
}.also {
onStartCommand(it, 0, id.toInt())
}
}
fun stopTimer() {
timer?.cancel()
}
fun updateNotification(secondsRemaining: Long){
val notification = NotificationCompat.Builder(this, NotificationUtil.CHANNEL_ID_TIMER)
.setSmallIcon(R.drawable.ic_timer)
.setAutoCancel(true)
.setDefaults(0)
.setContentTitle(secondsRemaining.formatSeconds())
.setContentText("Timer")
.setContentIntent(notificationUtil.getPendingIntentWithStack(this, TimerActivity::class.java))
.setOngoing(true)
.build()
startForeground(NotificationUtil.NOTIFICATION_ID, notification) // that''s the last trick
}
private fun sendMessage(remaining: Long) {
Intent(TimerService::class.java.simpleName).apply {
putExtra(EXTRA_REMAINING, remaining)
}.also {
LocalBroadcastManager.getInstance(this).sendBroadcast(it)
}
}
private inner class ServiceHandler(looper: Looper) : Handler(looper) {
override fun handleMessage(msg: Message) {
val secondsRemaining = msg.data.getLong(EXTRA_REMAINING)
notificationUtil.showTimerStarted(secondsRemaining)
timer = object : CountDownTimer(secondsRemaining * 1000, 1000) {
override fun onTick(millisUntilFinished: Long) {
Log.i(this::class.java.simpleName, "tick ${(millisUntilFinished / 1000L).formatSeconds()}")
updateNotification(millisUntilFinished / 1000)
sendMessage(millisUntilFinished / 1000)
}
override fun onFinish() {
Log.i(this::class.java.simpleName, "finish")
notificationUtil.showTimerEnded()
sendMessage(0)
stopSelf()
}
}.start()
}
}
inner class Binder : android.os.Binder() {
// Return this instance of LocalService so clients can call public methods
fun getService(): TimerService = this@TimerService
}
companion object {
const val EXTRA_REMAINING = "EXTRA_REMAINING"
const val NOTIFICATION_ID = 1 // cannot be 0
fun Long.formatSeconds(): String {
val s = this % 60
val m = this / 60 % 60
val h = this / (60 * 60) % 24
return if (h > 0) String.format("%d:%02d:%02d", h, m, s)
else String.format("%02d:%02d", m, s)
}
}
}

Answer 5

Si se une a su servicio desde una subclase de clase de Aplicación y mantiene su conexión de IBinder, el servicio permanecerá activo incluso después de que la aplicación se elimine de las aplicaciones recientes.

Answer 6

Simplemente siga estos escenarios, su servicio y procesos (los hilos se ejecutan dentro de su servicio) permanecerán continuos.

1. Cree el servicio y use START_STICKY como valor de retorno en el método onStartCommand como se muestra a continuación:

   @Override
   public int onStartCommand(final Intent intent,
   final int flags,
   final int startId) {
   //your code
   return START_STICKY;
   } 

2. El código anterior reiniciará el servicio si se destruye y siempre se mantendrá en ejecución, pero el proceso (subprocesos) ejecutado desde el servicio dejará de funcionar si su aplicación se elimina de las aplicaciones recientes. Para garantizar que sus procesos (subprocesos) permanezcan siempre en condiciones de ejecución, debe anular el método onTaskRemoved () y agregar código para reiniciar las tareas como se muestra a continuación.

   @Override
   public void onTaskRemoved(Intent rootIntent){
   Intent restartServiceTask = new Intent(getApplicationContext(),this.getClass());
   restartServiceTask.setPackage(getPackageName());
   PendingIntent restartPendingIntent =PendingIntent.getService(getApplicationContext(), 1,restartServiceTask, PendingIntent.FLAG_ONE_SHOT);
   AlarmManager myAlarmService = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
   myAlarmService.set(
   AlarmManager.ELAPSED_REALTIME,
   SystemClock.elapsedRealtime() + 1000,
   restartPendingIntent);
   super.onTaskRemoved(rootIntent);
   }

3. Iniciar servicio como a continuación

startService (nueva intención (esto, YourService.class));