O aplicativo continua em execução quando o serviço em primeiro plano é interrompido pela última vez

Me deparei com um comportamento no gerenciamento de processos do Android em conjunto com serviços de primeiro plano, que realmente me confunde.

O que é razoável para mim

1. Quando você desliza o aplicativo de 'Aplicativos recentes', o sistema operacional deve concluir o processo do aplicativo em um futuro relativamente próximo.
2. Quando você desliza o aplicativo de 'Aplicativos recentes' enquanto executa um serviço em primeiro plano, ele permanece ativo.
3. Quando você interrompe o serviço de primeiro plano antes de deslizar o aplicativo de 'Aplicativos recentes', obtém o mesmo de 1).

O que me confunde

Quando você interrompe o serviço de primeiro plano sem ter atividades em primeiro plano (o aplicativo NÃO aparece em 'Aplicativos recentes'), eu esperaria que o aplicativo fosse morto agora.

No entanto, isso não está acontecendo, o processo do aplicativo ainda está ativo.

Exemplo

Eu criei um exemplo mínimo que mostra esse comportamento.

O ForegroundService:

import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.Context
import android.content.Intent
import android.os.Build
import android.os.IBinder
import androidx.core.app.NotificationCompat
import timber.log.Timber

class MyService : Service() {

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onCreate() {
        super.onCreate()
        Timber.d("onCreate")
    }

    override fun onDestroy() {
        super.onDestroy()
        Timber.d("onDestroy")

        // just to make sure the service really stops
        stopForeground(true)
        stopSelf()
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        Timber.d("onStartCommand")
        startForeground(ID, serviceNotification())
        return START_NOT_STICKY
    }

    private fun serviceNotification(): Notification {
        createChannel()

        val stopServiceIntent = PendingIntent.getBroadcast(
            this,
            0,
            Intent(this, StopServiceReceiver::class.java),
            PendingIntent.FLAG_UPDATE_CURRENT
        )
        return NotificationCompat.Builder(this, CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_launcher_foreground)
            .setContentTitle("This is my service")
            .setContentText("It runs as a foreground service.")
            .addAction(0, "Stop", stopServiceIntent)
            .build()
    }

    private fun createChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val notificationManager = getSystemService(NotificationManager::class.java)
            notificationManager.createNotificationChannel(
                NotificationChannel(
                    CHANNEL_ID,
                    "Test channel",
                    NotificationManager.IMPORTANCE_DEFAULT
                )
            )
        }
    }

    companion object {
        private const val ID = 532207
        private const val CHANNEL_ID = "test_channel"

        fun newIntent(context: Context) = Intent(context, MyService::class.java)
    }
}

O BroadcastReceiver para interromper o serviço:

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent

class StopServiceReceiver : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {

        val serviceIntent = MyService.newIntent(context)

        context.stopService(serviceIntent)
    }
}

A atividade:

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        startService(MyService.newIntent(this))
    }
}

O manifesto:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.christophlutz.processlifecycletest">

    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service android:name=".MyService"/>
        <receiver android:name=".StopServiceReceiver" />
    </application>

</manifest>

Experimente das seguintes maneiras:

1. Iniciar aplicativo, interromper o serviço em primeiro plano, remover aplicativo de 'Aplicativos recentes'
2. Iniciar aplicativo, remover aplicativo de 'Aplicativos recentes', parar o serviço de primeiro plano

Você pode ver no LogCat do Android Studio que o processo do aplicativo está marcado como [MORTO] para o caso 1, mas não para o caso 2.

Como é muito fácil de reproduzir, pode ser um comportamento pretendido, mas não encontrei nenhuma menção real sobre isso nos documentos.

Alguém sabe o que está acontecendo aqui?

Isso depende do que o serviço de primeiro plano realmente faz. Se ele usa threads, conexões de rede, E / S de arquivo etc. que consome memória ativamente, mesmo se você tentar interromper o serviço, ele não será destruído, portanto o processo permanecerá ativo. Isso também inclui em qualquer retorno de chamada da interface que permaneça ativo enquanto você tenta interromper o serviço. Especialmente os threads que ainda executam (até mesmo interrompem) e serviços vinculados bloqueiam o ciclo de vida que está parando o serviço corretamente.

Verifique se não há vazamentos de memória em seu serviço e feche todas as conexões (banco de dados, rede etc ...), remova todos os retornos de chamada de todas as interfaces antes de interromper o serviço. Você pode garantir que o serviço seja destruído se onDestroy()for chamado.

Para processos diferentes: acredito que a razão pela qual o processo permanece ativo é que, o sistema vê de uma maneira que o serviço pode iniciar novamente por algum tempo, mantendo o processo ativo por um curto período de tempo. Pelo menos, foi o que eu observei, porque, mesmo depois de onDestroy()chamado, o processo permaneceu vivo, eu pude vê-lo no depurador.

Se você deseja garantir (embora esse caminho não seja recomendado) que o processo seja morto com certeza após a destruição de tudo, você sempre pode chamar isso para finalizar o próprio processo:

android.os.Process.killProcess(android.os.Process.myPid());

O sistema Android é conhecido por sua autoconsciência em termos de memória, potência do processador e tempo de vida dos processos dos aplicativos - decide por si mesmo se deseja matar um processo que não é (o mesmo com atividades e serviços)

Aqui está a documentação oficial sobre esse assunto.

Veja o que diz sobre o primeiro plano

Haverá apenas alguns desses processos no sistema, e estes serão eliminados como último recurso se a memória for tão baixa que nem mesmo esses processos possam continuar em execução. Geralmente, neste momento, o dispositivo atingiu um estado de paginação na memória, portanto, esta ação é necessária para manter a interface do usuário responsiva.

e processos visíveis (o Serviço em primeiro plano é um processo visível )

O número desses processos em execução no sistema é menos limitado que os processos em primeiro plano, mas ainda é relativamente controlado. Esses processos são considerados extremamente importantes e não serão eliminados, a menos que seja necessário para manter todos os processos em primeiro plano em execução.

Isso significa que o sistema operacional Android terá seu processo de aplicativo em execução, desde que tenha memória suficiente para suportar todos os processos em primeiro plano . Mesmo que você o pare - o sistema pode apenas movê-lo para processos em cache e manipulá-lo da maneira de uma fila. Eventualmente, ele será morto de qualquer maneira - mas geralmente não cabe a você decidir. Francamente, você não deve se importar com o que está acontecendo com o processo do seu aplicativo depois (e desde que) todos os métodos do ciclo de vida do Android sejam chamados. Android sabe melhor.

É claro que você android.os.Process.killProcess(android.os.Process.myPid());pode interromper o processo, mas isso não é recomendado, pois interrompe o ciclo de vida adequado dos elementos Android e os retornos de chamada adequados podem não ser chamados, portanto, seu aplicativo pode se comportar mal em alguns casos.

Espero que ajude.

No Android, é o sistema operacional que decide quais aplicativos serão mortos.

Há uma ordem de prioridade: os
aplicativos que possuem um serviço em primeiro plano raramente são eliminados, mas outros aplicativos e serviços são eliminados após um período de inatividade e é isso que acontece com o seu aplicativo.

Quando você termina o serviço de primeiro plano, isso aumenta as possibilidades de o sistema matar o aplicativo, mas em nenhum caso significa que ele será morto imediatamente.

A tela Recentes é uma [...] interface do usuário no nível do sistema que lista atividades e tarefas acessadas recentemente .

Você pode ter várias atividades ou tarefas de um único aplicativo na lista. É não uma recentes Apps lista.

Portanto, não há correlação direta entre os elementos da Tela Recentes e o processo do aplicativo.

De qualquer forma , se você fechar a última atividade do seu aplicativo e não tiver mais nada em execução no processo (como um serviço em primeiro plano), o processo será limpo.

Portanto, quando você interrompe um primeiro plano em execução ( ativado stopService()ou stopSelf()desativado), o sistema também limpa o processo em que estava sendo executado.

Portanto, é realmente um comportamento pretendido .