Screen Continuity: o que é, API de dobra e adaptação de interface

O que é Screen Continuity?

Screen Continuity é um mecanismo do Android que preserva o estado da Activity quando a configuração física da tela muda em dispositivos dobráveis. Quando o usuário desdobra ou dobra o telefone, o sistema pode reiniciar a Activity com novas dimensões de janela. A continuidade evita perda de dados inseridos, posição de rolagem e tela atual.

Diferente de uma simples rotação de tela onde o Android apenas recria a Activity com uma nova orientação, dispositivos dobráveis introduzem cenários fundamentalmente novos. A postura HALF_OPENED permite que o aplicativo funcione em meia tela, enquanto FLAT opera em modo tablet totalmente desdobrado. Sem suporte a Screen Continuity, cada mudança de postura redefine a interface ao estado inicial.

De acordo com Google I/O 2024, mais de 62% dos usuários de dispositivos dobráveis encontraram aplicativos que lidam incorretamente com a troca de estado. Screen Continuity resolve esse problema no nível da API, fornecendo ao desenvolvedor ferramentas prontas para salvar e restaurar a interface do usuário.

Estados de dispositivos dobráveis: posturas de tela

Jetpack WindowManager define três posturas básicas para dispositivos dobráveis através da classe FoldingFeature. Cada postura corresponde a uma posição física específica da dobradiça e requer tratamento especial de interface.

HALF_OPENED — Estado semidobrado

O dispositivo está em um ângulo de 30 a 160 graus. A tela é dividida em duas áreas lógicas. O aplicativo pode exibir conteúdo na metade superior e controles na inferior. Modo tabletop para chamadas de vídeo e players de mídia usa esta postura.

FLAT — Estado totalmente desdobrado

O dispositivo está aberto 180 graus, formando uma única tela grande. O aplicativo alterna para modo tablet com área de trabalho ampliada. Nesta postura, é recomendado mostrar um layout de múltiplos painéis com um painel de navegação e conteúdo detalhado lado a lado.

TABLE_TOP — Postura de laptop

O dispositivo está em uma superfície em um ângulo de cerca de 120 graus. A metade inferior da tela serve como painel tátil ou teclado. Modo touchpad nesta postura permite emular um trackpad na parte inferior da tela.

Como funciona a continuidade de tela no Android?

Android lida com mudanças de configuração de dispositivos dobráveis através do mecanismo de configuration changes. Quando o usuário desdobra o telefone, o sistema detecta a mudança de tamanho da janela e inicia o ciclo padrão de recriação da Activity. Screen Continuity intercepta este processo e salva dados importantes.

O método principal para salvar o estado é onRetainNonConfigurationInstance, que é chamado antes da Activity ser destruída. O desenvolvedor salva nele o modelo de dados, posição da lista e tela de navegação atual. Após a recriação, a Activity recebe estes dados através de getLastNonConfigurationInstance e restaura a interface exatamente como estava antes de dobrar.

Para Fragments, o mecanismo é implementado através de setRetainInstance(true), que impede que o fragment seja destruído em mudanças de configuração. Em Jetpack Compose, usa-se rememberSaveable, que salva automaticamente o estado quando as Window Metrics mudam.

class MainActivity : AppCompatActivity() {
    private var currentScrollPosition: Int = 0

    override fun onRetainNonConfigurationInstance(): Any {
        return SavedState(scrollPosition = currentScrollPosition)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val saved = lastNonConfigurationInstance as? SavedState
        saved?.let { currentScrollPosition = it.scrollPosition }
    }
}

API ScreenContinuity no Jetpack WindowManager

Jetpack WindowManager versão 1.1+ inclui a classe ScreenContinuityController, que fornece mecanismos prontos para gerenciar a continuidade de tela. A API lida automaticamente com mudanças de postura e notifica o aplicativo através de interfaces callback.

ScreenContinuityController

A classe central que registra ouvintes de mudança de postura. registerContinuityListener aceita um callback que é acionado em cada transição entre estados do dispositivo dobrável. O controlador também fornece informações sobre a postura atual através do método getCurrentFoldingFeature.

FoldingFeatureAdapter

Uma classe utilitária para transformar dados FoldingFeature em estados legíveis pelo aplicativo. FoldingFeatureAdapter normaliza coordenadas da dobradiça e determina se a postura atual é HALF_OPENED, FLAT ou TABLE_TOP. Isso poupa o desenvolvedor de cálculos manuais de ângulos e limites.

Integração com Jetpack Compose

Para aplicativos Compose, WindowManager fornece WindowSizeClass e modificadores que consideram a dobra. O componente BoxWithConstraints se adapta a mudanças de tamanho de tela em tempo real sem recriação da Activity. Compose aciona automaticamente recomposição quando WindowMetrics mudam.

val windowManager = WindowManager(context)
val controller = windowManager.screenContinuityController

controller.registerContinuityListener { feature: FoldingFeature ->
    when (feature.state) {
        FoldingFeature.State.HALF_OPENED -> enterTabletopMode()
        FoldingFeature.State.FLAT -> expandToTablet()
    }
}

Exemplo de implementação em Kotlin

Vejamos um exemplo completo de Activity com suporte a Screen Continuity. MainActivity lida com três cenários: dobrar, desdobrar e estado semidobrado. Os dados são salvos via onRetainNonConfigurationInstance e restaurados na recriação.

class ContinuityActivity : AppCompatActivity() {
    private lateinit var binding: ActivityContinuityBinding
    private var itemList = mutableListOf<String>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityContinuityBinding.inflate(layoutInflater)
        setContentView(binding.root)

        val savedState = lastNonConfigurationInstance as? ContinuityState
        if (savedState != null) {
            itemList.addAll(savedState.items)
            restoreUi(savedState)
        }
        setupWindowManager()
    }

    private fun setupWindowManager() {
        val controller = WindowManager(this).screenContinuityController
        controller.registerContinuityListener { feature ->
            updateLayoutForFeature(feature)
        }
    }

    private fun updateLayoutForFeature(feature: FoldingFeature) {
        when (feature.state) {
            FoldingFeature.State.HALF_OPENED -> binding.root.enableTabletopMode()
            FoldingFeature.State.FLAT -> binding.root.enableTabletMode()
            FoldingFeature.State.TABLE_TOP -> binding.root.enableTouchpadMode()
        }
    }

    override fun onRetainNonConfigurationInstance(): Any {
        return ContinuityState(itemList.toList(), binding.listView.firstVisiblePosition)
    }
}

data class ContinuityState(
    val items: List<String>,
    val scrollPosition: Int
)

O elemento principal é a classe ContinuityState, que armazena a lista de itens e a posição de rolagem. A Activity a salva antes da recriação e a restaura imediatamente após chamar onCreate. O controlador WindowManager se inscreve em mudanças de postura e alterna o layout entre modos.

Testando continuidade no emulador e dispositivo

Android Studio fornece um emulador de dispositivo dobrável com suporte para todas as três posturas. Para testar Screen Continuity, basta criar um dispositivo virtual do tipo Pixel Fold ou Samsung Galaxy Z Fold e alternar posturas usando o painel de controle do emulador.

Configuração do emulador

Crie um AVD com a categoria Foldable e selecione uma resolução de tela de 7,6 polegadas. Nos controles estendidos do emulador, abra a aba Folding Postures e alterne entre posturas. Cada alternância aciona um configuration change que o aplicativo deve tratar corretamente.

Dispositivo físico

Em um dispositivo real (Galaxy Z Fold 5, Pixel Fold), os testes são feitos dobrando e desdobrando fisicamente. Os modos Samsung DeX e Multi-Window também ativam a continuidade. Para depuração, use o comando ADB adb shell dumpsys window policy, que exibe o estado atual da dobra.

Problemas comuns

Os principais erros incluem perda de estado do RecyclerView, redefinição de texto em campos de texto e fechamento de janelas de diálogo. ViewModel resolve esses problemas mantendo dados em memória independente do ciclo de vida da Activity. Também é importante anotar a Activity no manifesto com o parâmetro android:configChanges se o aplicativo lidar manualmente com as mudanças.

<!-- AndroidManifest.xml -->
@android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"