Background Service — o que é, tipos e como funciona no Android

O que é Background Service no Android?

Background Service (ou simplesmente Service) é um dos quatro componentes fundamentais de um aplicativo Android, juntamente com Activity, BroadcastReceiver e ContentProvider. Ao contrário de Activity, Service não possui interface visual e é projetado para realizar operações que devem continuar independentemente de o aplicativo estar em primeiro plano ou não.

Service é executado na thread principal do aplicativo, portanto, qualquer operação bloqueante dentro dele requer a criação de uma thread separada. Caso contrário, o sistema lançará um ANR (Application Not Responding). Para operações simples em segundo plano, o Android fornece IntentService, que cria automaticamente uma thread de trabalho. Em projetos modernos, recomenda-se usar corrotinas Kotlin com CoroutineScope dentro do Service para processamento assíncrono sem bloquear a thread principal.

O principal propósito do Service é reproduzir música, baixar arquivos, lidar com requisições de rede, sincronizar dados e outras tarefas que devem continuar após o usuário sair do aplicativo. No entanto, desde o Android 8, os desenvolvedores devem escolher conscientemente entre os tipos de serviços, levando em consideração as restrições de trabalho em segundo plano.

Como funciona o ciclo de vida do Service?

Service tem seu próprio ciclo de vida, que difere de Activity. Inclui quatro métodos principais: onCreate, onStartCommand, onBind e onDestroy. Compreender esse ciclo é essencial para implementar corretamente tarefas em segundo plano sem vazamentos de memória.

onCreate e onStartCommand

O método onCreate é chamado quando o serviço é criado, uma vez durante sua vida. Aqui, recursos como temporizadores, conexões de banco de dados e sockets são inicializados. O método onStartCommand é chamado toda vez que startService é invocado, permitindo enviar comandos a um serviço já em execução. O valor de retorno determina o comportamento do sistema ao reiniciar.

class DownloadService : Service() {

    override fun onCreate() {
        super.onCreate()
        initializeDownloader()
    }

    override fun onStartCommand(
        intent: Intent?,
        flags: Int,
        startId: Int
    ): Int {
        downloadFile(intent?.getStringExtra("url"))
        return START_STICKY
    }

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

onBind e onDestroy

onBind é chamado ao vincular um serviço via bindService e retorna um objeto IBinder para interação com o cliente. Este método é usado apenas para Bound Service. onDestroy é a última chamada antes da destruição do serviço. Aqui, todos os recursos são liberados, threads são paradas e tarefas são canceladas.

Tipos de serviços em segundo plano

Android oferece três tipos de Service, cada um projetado para seu próprio cenário. Escolher o tipo errado pode levar a um comportamento instável do aplicativo ou consumo de bateria.

Started Service

Started Service é iniciado chamando startService e funciona até chamar stopSelf ou stopService. É adequado para tarefas que precisam ser executadas imediatamente: enviar análises, processar uma imagem, baixar um arquivo único. Após concluir seu trabalho, o serviço para sozinho.

Bound Service

Bound Service fornece uma interface cliente-servidor, permitindo que uma Activity, Fragment ou outro componente interaja com o serviço. O serviço vive enquanto houver pelo menos um cliente vinculado. Quando todos os clientes se desvinculam, o serviço é destruído. Bound Service é útil para tarefas que exigem comunicação bidirecional: reprodutor de música, navegação.

Foreground Service

Foreground Service é um Started Service com uma notificação persistente na barra de status. O sistema considera tal serviço como ativo e não o elimina mesmo com pouca memória. Foreground Service é obrigatório para reprodução de música, gravação de áudio, rastreamento de localização e outras tarefas importantes para o usuário.

Criação e execução de Service

Criar um serviço começa declarando uma classe que herda de Service e registrando-a no AndroidManifest.xml. Sem o registro no manifesto, o sistema não conseguirá iniciar o serviço, e qualquer chamada a startService resultará em uma exceção.

// Registro no AndroidManifest.xml
@SuppressLint("ForegroundServiceType")
class SyncService : Service() {

    override fun onStartCommand(
        intent: Intent?,
        flags: Int,
        startId: Int
    ): Int {
        startForeground(
            NOTIFICATION_ID,
            createNotification()
        )
        performSync(intent)
        return START_NOT_STICKY
    }
}

Para iniciar um serviço a partir de uma Activity ou Fragment, é utilizado um Intent com uma referência explícita à classe do serviço. A partir do Android 8, Foreground Service requer a permissão FOREGROUND_SERVICE no manifesto.

// Iniciar um Started Service
val intent = Intent(this, SyncService::class.java)
intent.putExtra("action", "sync")
startService(intent)

// Iniciar um Foreground Service (Android 8+)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    startForegroundService(intent)
} else {
    startService(intent)
}

Restrições no Android 8+

A partir do Android 8 (API 26), o Google introduziu restrições rigorosas para serviços em segundo plano. A inicialização de serviço em segundo plano (quando o aplicativo não está em primeiro plano) só é permitida em casos excepcionais: ao receber uma notificação push, após a inicialização do dispositivo ou via JobScheduler.

Para tarefas longas que não exigem execução imediata, recomenda-se usar WorkManager ou JobScheduler. Se um aplicativo realmente precisa de um serviço em execução, a única maneira é um Foreground Service com uma notificação visível ao usuário. Iniciar um serviço sem notificação em segundo plano será ignorado pelo sistema.

JobIntentService para compatibilidade reversa

JobIntentService é uma classe especializada que apareceu na biblioteca de suporte para funcionar no Android 5+. Ela combina o comportamento do IntentService (thread de trabalho automática, processamento sequencial) com o agendamento via JobScheduler. No Android 8+, JobIntentService usa JobScheduler internamente, e em versões mais antigas, um Service normal. Isso permite o manuseio uniforme de tarefas em segundo plano sem verificações adicionais da versão do Android.

class UploadJobService : JobIntentService() {

    companion object {
        private const val JOB_ID = 1000

        fun enqueueWork(context: Context, work: Intent) {
            enqueueWork(
                context,
                UploadJobService::class.java,
                JOB_ID,
                work
            )
        }
    }

    override fun onHandleWork(intent: Intent) {
        val fileUri = intent.getStringExtra("file_uri")
        // Executa em uma thread de segundo plano
        uploadFile(fileUri)
    }
}

Gerenciamento de memória e vazamentos no Service

Um dos problemas comuns ao trabalhar com Background Service são os vazamentos de memória. Como um Service pode durar mais que uma Activity, referências a Activity dentro do Service (via listener, callback ou broadcast) impedem a coleta de lixo dos componentes de UI. Recomenda-se usar WeakReference, ViewModel ou LiveData para comunicação Service-UI. No onDestroy, lembre-se de cancelar todas as assinaturas, parar threads e fechar cursores.

Service vs WorkManager: quando escolher cada um

A escolha entre Background Service e WorkManager depende do cenário. Service é adequado para tarefas que devem ser executadas imediatamente e continuamente: reprodução de música, gravação de áudio, rastreamento GPS. WorkManager é melhor para tarefas adiadas e garantidas: sincronização, envio de análises, upload de logs. WorkManager sobrevive a reinicializações do dispositivo, enquanto Service não. Service pode ser Foreground com notificação, enquanto WorkManager funciona silenciosamente em segundo plano. Na prática, os desenvolvedores combinam ambas as abordagens: Foreground Service para tarefas críticas para o usuário e WorkManager para manutenção em segundo plano.

O Android 12 introduziu o sinalizador android:foregroundServiceType, que exige especificar o tipo de serviço: dataSync, camera, connectedDevice, location, mediaPlayback e outros. A especificação incorreta do tipo leva a uma exceção na inicialização. Essa prática torna o Background Service mais transparente tanto para o usuário quanto para o sistema.

Exemplo de registro de Service no AndroidManifest

O registro adequado de Service no manifesto inclui o atributo exported (acessibilidade para aplicativos externos), foregroundServiceType (tipo de serviço em segundo plano no Android 12+) e permissão. Para Bound Service, também é necessário declarar android:permission="android.permission.BIND_JOB_SERVICE" para JobIntentService. Sem o registro no manifesto, qualquer chamada a startService ou bindService lançará uma exceção, portanto, verificar o manifesto é o primeiro passo ao diagnosticar problemas relacionados ao Service.