Inactive — o estado de transição entre Active e Background

Inactive — a essência do estado de transição

Inactive é um estado intermediário no ciclo de vida do aplicativo móvel que ocorre durante a transição entre Active e Background. Neste estado, o app ainda está em primeiro plano e visível para o usuário, mas não recebe eventos de toque, pressionamentos de tecla ou outros eventos de UI. O sistema bloqueia a entrega de eventos ao app, mas a UI permanece na tela e não é minimizada.

A natureza do Inactive é temporária. Este estado dura exatamente o tempo da interrupção do sistema: de 0.1 segundos ao fechar rapidamente o Control Center a vários segundos durante uma chamada recebida com tela de chamada. Após o término da interrupção, o app retorna ao Active ou transita para Background se o usuário mudou para outro app. Inactive é o único estado que pode transitar em ambas as direções: de volta ao Active ou adiante para Background.

No iOS, o Inactive é gerenciado automaticamente pelo sistema. O desenvolvedor não pode estender ou encurtar o tempo no Inactive — é totalmente controlado pelo UIApplication. A única coisa que o desenvolvedor pode fazer é tratar corretamente a transição para Inactive através do applicationWillResignActive e o retorno através do applicationDidBecomeActive. No Android, o equivalente é onPause, embora a semântica difira: onPause é chamado mesmo quando uma Activity está parcialmente coberta por outro componente.

Comparação do Inactive no iOS e Android

No iOS, Inactive é um estado separado do ciclo de vida da aplicação (um de cinco: Not Running, Active, Inactive, Background, Suspended). No Android não há equivalente direto — onPause sinaliza que a Activity está perdendo o foco de entrada mas pode permanecer visível (por exemplo, quando um diálogo abre). A diferença chave: Inactive no iOS é um estado de todo o app, enquanto onPause no Android é um estado por Activity. No multi-janela do Android, uma Activity pode estar em onPause (sem foco) enquanto outra está em onResume (com foco).

Quando o Inactive ocorre

Inactive no iOS ocorre em vários cenários estritamente definidos. O usuário abre o Control Center (deslizar para baixo do canto superior direito no iPhone X+ ou deslizar para cima em modelos antigos). O usuário abre o Notification Center (deslizar para baixo do canto superior esquerdo). Uma chamada recebida chega — o sistema mostra a tela de chamada sobre o app. Uma permissão do sistema é solicitada — geolocalização, microfone, câmera, contatos. No iPad, o Slide Over ou Split View é iniciado — a cena ativa se torna Inactive.

No Android, onPause (o equivalente de Inactive) ocorre numa gama ainda mais ampla de situações. Abertura de um diálogo (AlertDialog, DialogFragment). Sobreposição parcial de uma Activity por outra Activity (por exemplo, uma Activity transparente para autenticação). Rotação de tela (a Activity é recriada, sequência: onPause → onStop → onDestroy → onCreate → onStart → onResume). Modo multi-janela — a janela inativa recebe onPause. Cada um desses eventos requer a suspensão de operações intensivas em recursos para preservar a bateria e o desempenho.

import UIKit

extension Notification.Name {
    static let systemInterruptionBegan = Notification.Name("systemInterruptionBegan")
    static let systemInterruptionEnded = Notification.Name("systemInterruptionEnded")
}

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func applicationWillResignActive(_ application: UIApplication) {
        // O aplicativo transita para Inactive — interrupção do sistema
        print("Interrupção: Control Center, chamada ou alerta do sistema")

        // Pausar operações sensíveis ao tempo
        pauseVideoPlayback()
        stopContinuousDataCollection()
        hideSensitiveInformation()

        // Notificar componentes
        NotificationCenter.default.post(name: .systemInterruptionBegan, object: nil)
    }

    // Retorno de Inactive para Active
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeVideoPlayback()
        restartDataCollection()
        NotificationCenter.default.post(name: .systemInterruptionEnded, object: nil)
    }

    private func pauseVideoPlayback() {
        // Pausar o vídeo para que o áudio não se sobreponha
    }

    private func hideSensitiveInformation() {
        // Ocultar dados sensíveis na captura de tela
        // Control Center/App Switcher tiram uma captura da UI
    }
}

O código mostra o tratamento do Inactive no UIKit. applicationWillResignActive pausa o vídeo, interrompe a coleta de dados e oculta informações sensíveis. Isto é importante porque ao abrir o Control Center ou App Switcher, o sistema tira uma captura da UI atual — o usuário poderia ver dados confidenciais na pré-visualização. O NotificationCenter permite que os componentes do app se inscrevam em eventos de interrupção.

Inactive no iOS: Swift e UIKit

No iOS, Inactive é tratado por um par de métodos: applicationWillResignActive (transição para Inactive) e applicationDidBecomeActive (retorno do Inactive). Estes métodos fazem parte do UIApplicationDelegate e são chamados para cada transição através do Inactive. Desde o iOS 13 e UISceneDelegate, foram adicionados sceneWillResignActive e sceneDidBecomeActive para cenários multi-janela.

SceneDelegate e Inactive multi-janela

No iPad com iOS 13+, um app pode ter múltiplas cenas (janelas). Cada cena tem seu próprio ciclo de vida. Uma cena pode se tornar Inactive (o usuário mudou para outra cena) enquanto outra permanece Active. Esta é uma diferença importante do iPhone, onde Inactive é um estado global para todo o app. Ao desenvolver para iPad, é necessário tratar o Inactive para cada cena separadamente.

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    // A cena se torna inativa
    func sceneWillResignActive(_ scene: UIScene) {
        // No iPad esta cena perde o foco, mas outras podem estar ativas
        print("A cena perde atividade")

        // Pausar as tarefas desta cena
        pauseSceneSpecificOperations()
    }

    // A cena se torna ativa
    func sceneDidBecomeActive(_ scene: UIScene) {
        print("A cena se tornou ativa")
        resumeSceneSpecificOperations()
    }

    private func pauseSceneSpecificOperations() {
        // Pausar operações específicas desta cena
    }

    private func resumeSceneSpecificOperations() {
        // Retomar operações quando o foco retorna
    }
}

// AppDelegate permanece o ponto de entrada, delega para as cenas
@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(
        _ application: UIApplication,
        configurationForConnecting connectingSceneSession: UISceneSession,
        options: UIScene.ConnectionOptions
    ) -> UISceneConfiguration {
        return UISceneConfiguration(
            name: "Default Configuration",
            sessionRole: connectingSceneSession.role
        )
    }
}

O código mostra um SceneDelegate para tratar o Inactive no nível da cena. sceneWillResignActive é chamado quando uma janela específica perde o foco — isto pode ocorrer ao alternar entre janelas no iPad. O AppDelegate configura o UISceneConfiguration para suportar multi-janela. Cada cena tem um estado independente e o desenvolvedor deve tratá-las separadamente.

Inactive no Android: onPause e visibilidade

No Android, o equivalente direto do Inactive do iOS é o método onPause() do ciclo de vida da Activity. Ele é chamado quando a Activity perde o foco de entrada mas pode permanecer visível. Cenários típicos: abertura de um diálogo, lançamento de outra Activity no mesmo app, chamada recebida, pressionar o botão Home ou Recents. No onPause, o desenvolvedor deve suspender operações intensivas em recursos — animações, reprodução de vídeo, trabalho com câmera.

Uma diferença importante do Android é que onPause sempre precede onStop, mas não o contrário. Uma Activity pode receber onPause sem onStop (por exemplo, ao abrir uma Activity transparente). Além disso, onPause pode ser chamado múltiplas vezes durante a vida de uma Activity — em cada troca de foco. Não coloque lógica única no onPause — use onStop para operações finais e onPause apenas para suspender ações interativas.

class VideoPlayerActivity : AppCompatActivity() {

    private var exoPlayer: ExoPlayer? = null
    private var currentPosition: Long = 0L

    override fun onPause() {
        super.onPause()
        // O aplicativo perde o foco — pausamos o vídeo
        exoPlayer?.let { player ->
            if (player.isPlaying) {
                currentPosition = player.currentPosition
                player.pause()
            }
        }
        // Ocultamos dados sensíveis (GDPR/telas bancárias)
        if (window.decorView.systemUiVisibility and
            View.SYSTEM_UI_FLAG_SECURE == 0
        ) {
            hideSensitiveOverlay()
        }
    }

    override fun onResume() {
        super.onResume()
        // O foco retorna — retomamos a reprodução
        exoPlayer?.seekTo(currentPosition)
        exoPlayer?.play()
        showSensitiveOverlay()
    }

    private fun hideSensitiveOverlay() {
        // Sobrepor uma tela preta sobre dados financeiros
    }
}

O código mostra o tratamento correto do onPause para um player de vídeo. ExoPlayer é pausado quando o foco é perdido, e a posição de reprodução é salva. Ao retornar ao onResume, o player retoma a reprodução da posição salva. Adicionalmente, um padrão para ocultar dados sensíveis é mostrado — importante para aplicações financeiras e médicas que exigem proteção contra capturas de tela ao alternar.

Melhores práticas para lidar com Inactive

Primeira regra — oculte dados confidenciais ao transitar para Inactive. Quando o usuário abre o Control Center ou App Switcher, o iOS tira uma captura da tela atual. No Android, similarmente, o sistema mostra uma prévia da última Activity no Recents. Use UIApplication.shouldSnapshotSecureApp (iOS 16+) ou FLAG_SECURE (Android) para proteger telas confidenciais.

Segunda regra — pause animações e mídia. Inactive não é um bom momento para reproduzir vídeo ou animações, já que o usuário não pode vê-los. Além disso, a reprodução em segundo plano pode sobrepor o áudio com sons do sistema (toque, notificação). Pare AVPlayer, ExoPlayer e UIView.animate ao ir para Inactive e retome ao voltar para Active.

Terceira regra — bloqueie a entrada de dados. Se o app contém formulários de entrada ou rascunhos, bloqueie o teclado e os campos de entrada ao ir para Inactive. Isto evita entrada acidental ao retornar e protege contra interceptação de dados através de sobreposições do sistema. No iOS, renuncie ao primeiro respondedor (view.endEditing(true)), no Android — limpe o foco (currentFocus?.clearFocus()).

Quarta regra — não realize operações longas no applicationWillResignActive ou onPause. Estes métodos devem completar em frações de segundo. Se precisar salvar uma grande quantidade de dados, comece a salvar numa thread em segundo plano e complete no applicationDidEnterBackground ou onStop. O iOS dá 5 segundos para executar o applicationWillResignActive, após o qual o sistema pode forçar o encerramento do app.

import UIKit

final class SecureOverlayManager {
    private var blurView: UIVisualEffectView?

    func showBlurOverlay() {
        guard let window = UIApplication.shared.keyWindow,
              blurView == nil
        else { return }

        let blur = UIVisualEffectView(effect: UIBlurEffect(style: .dark))
        blur.frame = window.bounds
        blur.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        window.addSubview(blur)
        blurView = blur
    }

    func removeBlurOverlay() {
        blurView?.removeFromSuperview()
        blurView = nil
    }
}

// Uso no AppDelegate
func applicationWillResignActive(_ application: UIApplication) {
    SecureOverlayManager().showBlurOverlay()
}

func applicationDidBecomeActive(_ application: UIApplication) {
    SecureOverlayManager().removeBlurOverlay()
}

O código mostra a implementação de uma sobreposição segura para proteção de dados durante a transição para Inactive. Uma UIVisualEffectView com efeito blur é sobreposta sobre toda a UI ao ir para Inactive e removida ao voltar para Active. Isto garante que dados confidenciais não serão visíveis nas capturas do App Switcher e Control Center. Similarmente, você pode usar UIImageView com um logotipo para uma sobreposição personalizada.