Incorporação de atividades

A incorporação de atividades otimiza apps em dispositivos de tela grande dividindo a janela de tarefa de um app em duas atividades ou duas instâncias.

Atualizar as bases de código legadas para oferecer suporte a telas grandes é uma tarefa intensa e demorada. A conversão de apps baseados em atividade para layouts de vários painéis usando fragmentos requer uma refatoração significativa.

A incorporação de atividades exige pouca ou nenhuma refatoração do app. Para determinar como o app mostra as atividades (lado a lado ou empilhadas), crie um arquivo de configuração XML ou faça chamadas da API Jetpack WindowManager.

O suporte a telas pequenas é mantido automaticamente. Quando o app está em um dispositivo com uma tela pequena, as atividades são empilhadas uma sobre a outra. Em telas grandes, as atividades são exibidas lado a lado. O sistema determina a apresentação com base na configuração criada e nenhuma lógica de ramificação é necessária.

A incorporação de atividades oferece suporte a mudanças de orientação do dispositivo e funciona perfeitamente em dispositivos dobráveis, empilhando e desempilhando atividades conforme o dispositivo é dobrado e desdobrado.

O desenvolvimento moderno para Android usa uma arquitetura de atividade única com fragmentos, componentes de navegação e gerenciadores de layout versáteis, como o SlidingPaneLayout.

No entanto, caso seu app seja composto por várias atividades, a incorporação de atividades permite melhorar facilmente a experiência do usuário em tablets, dispositivos dobráveis e ChromeOS.

A incorporação de atividades pode ser realizada na maioria dos dispositivos de tela grande que executam o Android 12L (nível 32 da API) e versões mais recentes.

Dividir janela de tarefas

A incorporação de atividades divide a janela de tarefas do app em dois contêineres: primário e secundário. Os contêineres guardam as atividades iniciadas da atividade principal ou de outras atividades que já estão neles.

As atividades são empilhadas no contêiner secundário conforme são iniciadas, e o contêiner secundário é empilhado sobre o contêiner principal em telas pequenas. Portanto, o empilhamento de atividades e a navegação de retorno são consistentes com a ordem de atividades já integradas ao app.

A incorporação de atividades possibilita mostrar atividades de várias maneiras. O app pode dividir a janela de tarefas iniciando duas atividades lado a lado simultaneamente:

Ou então, uma atividade que ocupa toda a janela da tarefa pode criar uma divisão ao iniciar uma nova atividade lado a lado:

As atividades que já estão em uma divisão e compartilhando uma janela de tarefas podem iniciar outras atividades das seguintes maneiras:

• Ao lado, por cima da outra atividade:

  

• Ao lado e a divisão é movida na lateral, ocultando a atividade principal anterior:

  

• A atividade é iniciada por cima, ou seja, na mesma pilha de atividades:

  

• A atividade é iniciada em tela cheia na mesma tarefa:

  

Navegação de retorno

Diferentes tipos de aplicativos podem ter diferentes regras de navegação de retorno no estado de janela de uma tarefa dividida, dependendo das dependências entre as atividades ou de como os usuários acionam o evento de retorno, por exemplo:

• Juntas: se as atividades estão relacionadas e uma delas não é mostrada sem a outra, a navegação de retorno pode ser configurada para concluir as duas.
• Sozinhas: se as atividades são totalmente independentes, a navegação de retorno em uma atividade não afeta o estado de outra na janela de tarefas.

O evento de retorno é enviado para a última atividade em foco ao usar a navegação por botões. Com a navegação baseada em gestos, o evento "Voltar" é enviado à atividade em que o gesto ocorreu.

Layout com vários painéis

A biblioteca Jetpack WindowManager 1.1.0 Alpha04 possibilita criar um layout de vários painéis com atividades em dispositivos de tela grande com o 12L (API de nível 32) e alguns dispositivos com versões anteriores da plataforma. Os apps já existentes que são baseados em várias atividades em vez de fragmentos ou layouts baseados em visualização, por exemplo, SlidingPaneLayout, podem oferecer uma melhor experiência do usuário na tela grande, sem precisar de refatoração.

Um exemplo comum é uma divisão do painel de detalhes e lista. Para garantir uma apresentação de qualidade, o sistema inicia a atividade de lista e o aplicativo inicia imediatamente a atividade de detalhes. O sistema de transição aguarda até que ambas as atividades sejam desenhadas e as exibe juntas. Para o usuário, as duas atividades são iniciadas como uma só.

Proporção da divisão

O aplicativo especifica como a proporção da janela de tarefas é aplicada pelo atributo ratio de uma configuração de divisão. Consulte Configuração de divisão abaixo.

Marcadores de posição

As atividades de marcador de posição são atividades secundárias vazias que ocupam uma área de divisão de atividade. Elas precisam ser substituídas por outra atividade que inclua conteúdo. Por exemplo, uma atividade de marcador de posição pode ocupar o lado secundário de uma divisão de atividades em um layout de detalhes da lista até um item da lista ser selecionado. Nesse momento, uma atividade contendo as informações detalhadas do item da lista selecionada substitui o marcador.

Por padrão, o sistema mostra marcadores somente quando há espaço suficiente para uma divisão de atividade. Os marcadores de posição são concluídos automaticamente quando o tamanho de exibição muda para uma largura ou altura muito pequena para mostrar uma divisão. Quando o espaço permitir, o sistema vai reiniciar o marcador com um estado reinicializado.

No entanto, o atributo stickyPlaceholder de uma SplitPlaceholderRule pode substituir o comportamento padrão. Quando o atributo é definido como verdadeiro, o sistema mostra o marcador como a atividade de maior nível na janela de tarefas quando a tela é redimensionada para uma tela menor de um único painel a partir de uma tela de dois painéis. Consulte Configurar divisões para conferir um exemplo.

Mudanças no tamanho das janelas

Quando as mudanças na configuração do dispositivo reduzem a largura da janela de tarefas de tal modo que ela não seja grande o suficiente para um layout de vários painéis, as atividades não marcadoras de posição no painel secundário da janela de tarefas são empilhadas sobre as atividades no painel principal. Por exemplo, quando um dispositivo dobrável com tela grande do tamanho de um tablet é dobrado para o tamanho de um smartphone, ou quando a janela do app é redimensionada no modo de várias janelas.

As atividades de marcador de posição são exibidas apenas quando há espaço na tela de largura suficiente para uma divisão. Em telas menores, o marcador é dispensado automaticamente. Quando o espaço na tela se torna grande o suficiente, o marcador é recriado. Consulte Marcadores de posição acima.

O empilhamento da atividade é possível porque o WindowManager organiza as atividades no painel secundário na ordem z, acima das atividades no painel principal.

Várias atividades no painel secundário

A atividade B inicia a atividade C sem outras flags de intent:

Resultando na seguinte ordem z de atividades na mesma tarefa:

Portanto, em uma janela de tarefas menor, o aplicativo diminui para uma única atividade com C na parte de cima da pilha:

Voltar na janela menor é navegar pelas atividades empilhadas umas sobre as outras.

Se a configuração da janela de tarefas for restaurada para um tamanho maior que possa acomodar vários painéis, as atividades são exibidas lado a lado.

Divisões empilhadas

A atividade B inicia a atividade C na lateral e muda a divisão ao lado:

O resultado é a seguinte ordem z das atividades na mesma tarefa:

Em uma janela de tarefas menor, o aplicativo diminui para uma única atividade com C na parte de cima:

Orientação de retrato fixo

A configuração do manifesto android:screenOrientation permite que os apps restrinjam as atividades às orientações de retrato ou paisagem. Para melhorar a experiência do usuário em dispositivos de tela grande, como tablets e dobráveis, os fabricantes de dispositivos (OEMs) podem ignorar as solicitações de orientação da tela e colocar o app com efeito letterbox em orientação de retrato em telas no modo paisagem ou vice-versa.

Da mesma forma, quando a incorporação de atividades está ativada, os OEMs podem personalizar os dispositivos para mostrar atividades no modo retrato fixo com efeito letterbox na orientação de paisagem em telas grandes (largura ≥ 600 dp). Quando uma atividade no modo retrato fixo inicia uma outra, o dispositivo pode mostrar as duas atividades lado a lado em uma tela de dois painéis.

Sempre adicione a propriedade android.window.PROPERTY_ACTIVITY_EMBEDDING_SPLITS_ENABLED ao arquivo de manifesto do app para informar aos dispositivos que o app é compatível com a incorporação de atividades (consulte Configurar divisões abaixo). Os dispositivos personalizados pelo OEM podem determinar se as atividades no modo retrato fixo vão ter efeito letterbox.

Configurar divisões

As regras de divisão configuram divisões de atividade. Você pode definir regras de divisão em um arquivo de configuração XML ou fazendo chamadas da API Jetpack WindowManager.

Nos dois casos, o app precisa acessar a biblioteca WindowManager e informar ao sistema que o app implementou a incorporação de atividades.

Faça o seguinte:

1. Adicione a seguinte dependência da biblioteca WindowManager ao arquivo build.gradle:

   implementation 'androidx.window:window:1.1.0-alpha04'

   O componente Window Manager SplitController gerencia divisões.

2. Informe ao sistema que o app implementou a incorporação de atividades.

   Adicione a propriedade android.window.PROPERTY_ACTIVITY_EMBEDDING_SPLITS_ENABLED ao elemento <application> do arquivo de manifesto do app e defina o valor como "true", por exemplo:

   <manifest xmlns:android="http://schemas.android.com/apk/res/android">
       <application>
           <property
               android:name="android.window.PROPERTY_ACTIVITY_EMBEDDING_SPLITS_ENABLED"
               android:value="true" />
       </application>
   </manifest>
   

   Na versão 1.1.0-alpha06 do WindowManager e mais recentes, as divisões de incorporação de atividades são desativadas, a menos que a propriedade seja adicionada ao manifesto e definida como verdadeira.

   Além disso, os fabricantes de dispositivos usam a configuração para ativar recursos personalizados para apps com suporte à incorporação de atividades. Por exemplo, os dispositivos podem usar o efeito letterbox em uma atividade somente retrato em telas de modo paisagem para orientar a atividade na transição para um layout de dois painéis quando uma segunda atividade é iniciada.

Configuração de XML

Para criar uma implementação de incorporação de atividade baseada em XML, siga estas etapas:

1. Crie um arquivo de recurso XML que faça o seguinte:

   • Definir atividades que compartilham uma divisão.
   • Configurar as opções de divisão.
   • Criar um marcador de posição para o contêiner secundário de uma divisão quando o conteúdo não estiver disponível
   • Especificar as atividades que nunca devem fazer parte de uma divisão.

   Exemplo:

   <!-- split_configuration.xml -->
   
   <resources
       xmlns:window="http://schemas.android.com/apk/res-auto">
   
       <!-- Define a split for the named activities. -->
       <SplitPairRule
           window:splitRatio="0.33"
           window:splitMinWidth="840dp"
           window:finishPrimaryWithSecondary="never"
           window:finishSecondaryWithPrimary="always">
           <SplitPairFilter
               window:primaryActivityName=".ListActivity"
               window:secondaryActivityName=".DetailActivity"/>
       </SplitPairRule>
   
       <!-- Specify a placeholder for the secondary container when content is
            not available. -->
       <SplitPlaceholderRule
           window:placeholderActivityName=".PlaceholderActivity"
           window:splitRatio="0.33"
           window:splitMinWidth="840dp"
           window:stickyPlaceholder="false">
           <ActivityFilter
               window:activityName=".ListActivity"/>
       </SplitPlaceholderRule>
   
       <!-- Define activities that should never be part of a split. Note: Takes
            precedence over other split rules. -->
       <ActivityRule
           window:alwaysExpand="true">
           <ActivityFilter
               window:activityName=".ExpandedActivity"/>
       </ActivityRule>
   
   </resources>
   

2. Criar um inicializador.

   O componente SplitController do WindowManager gerencia as divisões de atividade com base nas regras do arquivo de configuração XML. Uma biblioteca de inicialização do Jetpack Initializer disponibiliza as regras de divisão para o SplitController na inicialização do app para que o SplitController possa aplicá-las, se necessário, à medida que as atividades forem iniciadas.

   Para criar um inicializador, faça o seguinte:

   1. Adicione a dependência de biblioteca do Jetpack Startup mais recente ao seu arquivo build.gradle, por exemplo:

      implementation 'androidx.startup:startup-runtime:1.1.1'

   2. Crie uma classe que implemente a interface Initializer.

      O inicializador disponibiliza as regras de divisão para o SplitController, fornecendo o ID do arquivo de recurso XML que contém as definições (split_configuration.xml) para o método initialize() do componente.

      Kotlin

      class SplitInitializer : Initializer<SplitController> {
      
       override fun create(context: Context): SplitController {
           SplitController.initialize(context, R.xml.split_configuration)
           return SplitController.getInstance()
       }
      
       override fun dependencies(): List<Class<out Initializer<*>>> {
           return emptyList()
       }
      }
      

      Java

      class SplitInitializer extends Initializer<SplitController> {
      
       @Override
       SplitController create(Context context) {
           SplitController.initialize(context, R.xml.split_configuration);
           return SplitController.getInstance();
       }
      
       @Override
       List<Class<? extends Initializer<?>>> dependencies() {
           return Collections.emptyList();
       }
      }
      

3. Crie um provedor de conteúdo para as definições da regra.

   Adicione androidx.startup.InitializationProvider ao arquivo de manifesto do app como um <provider>. Inclua uma referência à implementação do inicializador SplitController, SplitInitializer:

   <!-- AndroidManifest.xml -->
   
   <provider android:name="androidx.startup.InitializationProvider"
       android:authorities="${applicationId}.androidx-startup"
       android:exported="false"
       tools:node="merge">
       <!-- Make SplitInitializer discoverable by InitializationProvider. -->
       <meta-data android:name="${applicationId}.SplitInitializer"
           android:value="androidx.startup" />
   </provider>
   

   O InitializationProvider descobre e inicializa o SplitInitializer antes que o método onCreate() do app seja chamado. Como resultado, as regras de divisão entram em vigor quando a atividade principal do app é iniciada.

API WindowManager

É possível implementar a incorporação de atividades de forma programática com várias chamadas de API. Faça as chamadas no método onCreate() da atividade principal na divisão, ou seja, a atividade que inicia a divisão.

Para criar uma divisão de atividade de forma programática, faça o seguinte:

1. Crie uma regra de divisão:

   1. Crie um SplitPairFilter que identifique as atividades que compartilham a divisão:

      Kotlin

      val splitPairFilter = SplitPairFilter(
       ComponentName(applicationContext, ListActivity::class.java),
       ComponentName(applicationContext, DetailActivity::class.java),
       null
      )
      

      Java

      SplitPairFilter splitPairFilter = new SplitPairFilter(
       new ComponentName(this, ListActivity.class),
       new ComponentName(this, DetailActivity.class),
       null
      );
      

   2. Adicione o filtro a um conjunto:

      Kotlin

      val filterSet = setOf(splitPairFilter)
      

      Java

      Set<SplitPairFilter> filterSet = new HashSet<>();
      filterSet.add(splitPairFilter);
      

   3. Crie variáveis que configurem a divisão:

      Kotlin

      val minWidth = (800f * resources.displayMetrics.density).toInt()
      val minSmallestWidth = (600f * resources.displayMetrics.density).toInt()
      

      Java

      int minWidth = (int)(800f * getResources().getDisplayMetrics().density);
      int minSmallestWidth = (int)(600f * getResources().getDisplayMetrics().density);
      

      • minWidth: especifica a largura mínima da tela (em pixels) que permite uma divisão
      • minSmallestWidth: especifica o valor mínimo (em pixels) que a menor das duas dimensões de tela precisa ter para permitir uma divisão, independentemente da orientação do dispositivo.

   4. Crie um SplitPairRule:

      Kotlin

      val splitPairRule = SplitPairRule.Builder(
           filterSet,
           minWidth,
           minSmallestWidth
       ).setSplitRatio(0.33f)
        .setFinishPrimaryWithSecondary(0)
        .setFinishSecondaryWithPrimary(1)
        .setClearTop(false)
        .build()
      

      Java

      SplitPairRule splitPairRule = new SplitPairRule.Builder(
       filterSet,
       minWidth,
       minSmallestWidth
      ).setSplitRatio(0.33f)
      .setFinishPrimaryWithSecondary(0)
      .setFinishSecondaryWithPrimary(1)
      .setClearTop(false)
      .build();
      

      Use SplitPairRule.Builder para criar a regra e definir as seguintes propriedades:

      • splitRatio: a proporção da área da tela disponível para o contêiner principal. O contêiner secundário preenche o restante da área de tela disponível
      • finishPrimaryWithSecondary: como a finalização de todas as atividades no contêiner secundário afeta as atividades no contêiner principal, 0 = nunca finalizar atividades (consulte Finalizar atividades)
      • finishSecondaryWithPrimary: como a finalização de todas as atividades no contêiner principal afeta as atividades no contêiner secundário, 1 = sempre finalizar atividades (consulte Finalizar atividades)
      • clearTop: se todas as atividades no contêiner secundário são concluídas quando uma nova atividade é iniciada no contêiner

   5. Receba uma instância SplitController do WindowManager e registre a regra:

      Kotlin

      val splitController = SplitController.getInstance()
      splitController.registerRule(splitPairRule)
      

      Java

      SplitController splitController = SplitController.getInstance();
      splitController.registerRule(splitPairRule);
      

2. Crie um marcador de posição para o contêiner secundário quando o conteúdo não estiver disponível:

   1. Crie um ActivityFilter que identifique a atividade com que o marcador compartilha uma divisão de janela de tarefas:

      Kotlin

      val activityFilter = ActivityFilter(
        ComponentName(applicationContext, ListActivity::class.java),
        null
      )
      

      Java

      ActivityFilter activityFilter = new ActivityFilter(
        new ComponentName(this, ListActivity.class),
        null
      );
      

   2. Adicione o filtro a um conjunto:

      Kotlin

      val activityFilterSet = setOf(activityFilter)
      

      Java

      Set<ActivityFilter> activityFilterSet = new HashSet<>();
      activityFilterSet.add(activityFilter);
      

   3. Crie um SplitPlaceholderRule:

      Kotlin

      val splitPlaceholderRule = SplitPlaceholderRule.Builder(
            activityFilterSet,
            Intent(applicationContext, PlaceholderActivity::class.java),
            minWidth,
            minSmallestWidth
        ).setSplitRatio(0.33f)
         .setFinishPrimaryWithPlaceholder(1)
         .build()
      

      Java

      SplitPlaceholderRule splitPlaceholderRule = new SplitPlaceholderRule.Builder(
        activityFilterSet,
        new Intent(this, PlaceholderActivity.class),
        minWidth,
        minSmallestWidth
      ).setSplitRatio(0.33f)
      .setFinishPrimaryWithPlaceholder(1)
      .build();
      

      Use SplitPlaceholderRule.Builder para criar a regra e definir as seguintes propriedades:

      • splitRatio: a proporção da área da tela disponível para o contêiner principal. A atividade do marcador ocupa o restante da área disponível
      • finishPrimaryWithPlaceholder: como a finalização da atividade de marcador de posição afeta as atividades no contêiner principal, 1 = sempre finalizar atividades (consulte Finalizar atividades)

   4. Registre a regra com o SplitController do WindowManager:

      Kotlin

      splitController.registerRule(splitPlaceholderRule)
      

      Java

      splitController.registerRule(splitPlaceholderRule);
      

3. Especifique as atividades que nunca devem fazer parte de uma divisão:

   1. Crie um ActivityFilter que identifique uma atividade que sempre vai ocupar toda a área de tela da tarefa:

      Kotlin

      val expandedActivityFilter = ActivityFilter(
         ComponentName(applicationContext, ExpandedActivity::class.java),
         null
      )
      

      Java

      ActivityFilter expandedActivityFilter = new ActivityFilter(
         new ComponentName(this, ExpandedActivity.class),
         null
      );
      

   2. Adicione o filtro a um conjunto:

      Kotlin

      val expandedfilterSet = setOf(expandedActivityFilter)
      

      Java

      Set<ActivityFilter> expandedfilterSet = new HashSet<>();
      expandedfilterSet.add(expandedActivityFilter);
      

   3. Crie uma interface ActivityRule:

      Kotlin

      val activityRule = ActivityRule.Builder(
            expandedfilterSet
        ).setAlwaysExpand(true)
         .build()
      

      Java

      ActivityRule activityRule = new ActivityRule.Builder(
        expandedfilterSet
      ).setAlwaysExpand(true)
      .build();
      

      Use ActivityRule.Builder para criar a regra e definir as seguintes propriedades:

      • alwaysExpand: se a atividade vai preencher toda a janela de tarefas.

   4. Registre a regra com o SplitController do WindowManager:

      Kotlin

      splitController.registerRule(activityRule)
      

      Java

      splitController.registerRule(activityRule);
      

Incorporação entre aplicativos

No Android 13 (nível 33 da API) e em versões mais recentes, os apps podem incorporar atividades de outros apps. A incorporação de atividades entre aplicativos, ou entre UIDs, permite a integração visual de atividades de vários apps Android. O sistema mostra uma atividade do app host e uma atividade incorporada de outro app na tela lado a lado ou na parte de cima e de baixo, assim como na incorporação de atividades em um único app.

Por exemplo, o app Configurações pode incorporar a atividade do seletor de plano de fundo do app WallpaperPicker:

Modelo de confiança

Os processos do host que incorporam atividades de outros apps podem redefinir a apresentação das atividades incorporadas, incluindo tamanho, posição, corte e transparência. Hosts maliciosos podem usar esse recurso para enganar os usuários e criar clickjacking (link em inglês) ou outros ataques de correção da IU.

Para evitar o uso indevido da incorporação de atividades entre apps, o Android exige que os apps ativem esse recurso. Os apps podem designar hosts como confiáveis ou não confiáveis.

Hosts confiáveis

Para permitir que outros aplicativos incorporem e controlem totalmente a apresentação de atividades do seu app, especifique o certificado SHA-1 do aplicativo host no atributo android:knownActivityEmbeddingCerts dos elementos <activity> ou <application> do arquivo de manifesto do app.

Defina o valor de android:knownActivityEmbeddingCerts como uma string:

<activity
    android:name=".MyEmbeddableActivity"
    android:knownActivityEmbeddingCerts="@string/known_host_certificate_digest>"
    ... />

Se preferir, para especificar vários certificados, use uma matriz de strings:

<activity
    android:name=".MyEmbeddableActivity"
    android:knownActivityEmbeddingCerts="@array/known_host_certificate_digests"
    ... />

que faz referência a um recurso como este:

<resources>
    <string-array name="known_host_certificate_digests">
      <item>cert1</item>
      <item>cert2</item>
      ...
    </string-array>
</resources>

Os proprietários de apps podem receber um resumo de certificado SHA executando a tarefa signingReport do Gradle. O resumo do certificado é a impressão digital SHA-1 sem os dois-pontos de separação. Para mais informações, consulte Executar um relatório de assinatura e Como autenticar seu cliente.

Hosts não confiáveis

Para permitir que qualquer app incorpore as atividades do seu app e controle a apresentação dele, especifique o atributo android:allowUntrustedActivityEmbedding nos elementos <activity> ou <application> no manifesto do app, por exemplo:

<activity
    android:name=".MyEmbeddableActivity"
    android:allowUntrustedActivityEmbedding="true"
    ... />

O valor padrão do atributo é falso, o que impede a incorporação de atividades entre apps.

Autenticação personalizada

Para diminuir os riscos da incorporação não confiável de atividades, crie um mecanismo de autenticação personalizado que verifique a identidade do host. Se você conhecer os certificados do host, use a biblioteca androidx.security.app.authenticator para autenticar. Se o host for autenticado depois de incorporar sua atividade, você vai poder mostrar o conteúdo real. Caso contrário, informe ao usuário que a ação não foi permitida e bloqueie o conteúdo.

Use o método SplitController#isActivityEmbedded() da biblioteca WindowManager do Jetpack para verificar se um host está incorporando sua atividade, por exemplo:

fun isActivityEmbedded(activity: Activity): Boolean {
    return (SplitController.getInstance().isActivityEmbedded(activity))
}

public static boolean isActivityEmbedded(@NonNull Activity activity) {
    return SplitController.getInstance().isActivityEmbedded(activity);
}

Restrição de tamanho mínimo

O sistema Android aplica a altura e a largura mínimas especificadas no elemento <layout> do manifesto do app a atividades incorporadas. Se um aplicativo não especificar a altura e a largura mínimas, os valores padrão do sistema não vão ser aplicados (sw220dp).

Se o host tentar redimensionar o contêiner incorporado para um tamanho menor que o mínimo, ele vai ser expandido para ocupar todos os limites da tarefa.

<activity-alias>

Para que a incorporação de atividades confiáveis ou não confiáveis funcione com o elemento <activity-alias>, a propriedade android:knownActivityEmbeddingCerts ou android:allowUntrustedActivityEmbedding precisa ser aplicada à atividade de destino em vez do alias. A política que verifica a segurança no servidor do sistema é baseada nas sinalizações definidas no destino, não no alias.

Aplicativo host

Os aplicativos host implementam a incorporação de atividades entre apps da mesma maneira que a incorporação de atividades em apps únicos. Os objetos SplitPairRule e SplitPairFilter ou ActivityRule e ActivityFilter especificam atividades incorporadas e divisões da janela de tarefas. As regras de divisão são definidas estaticamente em XML ou durante a execução usando chamadas da API WindowManager do Jetpack.

Se um aplicativo host tentar incorporar uma atividade que não tenha ativado esse recurso, a atividade vai ocupar todos os limites da tarefa. Como resultado, os aplicativos host precisam saber se as atividades de destino permitem a incorporação entre apps.

Se uma atividade incorporada iniciar uma nova atividade na mesma tarefa que não ativou a incorporação entre apps, ela vai ocupar todos os limites da tarefa em vez de sobrepor a atividade no contêiner incorporado.

Um aplicativo host pode incorporar as próprias atividades sem restrições, desde que as atividades sejam iniciadas na mesma tarefa.

Exemplos de divisão

Dividir da tela cheia

Nenhuma refatoração é necessária. É possível definir a configuração da divisão de forma estática ou no momento da execução e, em seguida, chamar Context#startActivity() sem outros parâmetros.

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

Dividir por padrão

Quando a página de destino de um aplicativo é projetada para ser dividida em dois contêineres em telas grandes, a experiência do usuário é melhor quando ambas as atividades são criadas e apresentadas de forma simultânea. No entanto, o conteúdo pode não estar disponível para o contêiner secundário da divisão até que o usuário interaja com a atividade no contêiner principal, por exemplo, quando o usuário seleciona um item em um menu de navegação. Uma atividade de marcador de posição pode preencher o espaço vazio até que o conteúdo possa ser mostrado no contêiner secundário da divisão. Consulte Marcadores de posição acima.

Para criar uma divisão com um marcador, crie um marcador e o associe à atividade principal:

<SplitPlaceholderRule
    window:placeholderIntentName=".Placeholder">
    <ActivityFilter
        window:activityName=".Main"/>
</SplitPlaceholderRule>

Divisão de link direto

Quando um app recebe uma intent, a atividade de destino pode ser mostrada como a parte secundária de uma divisão de atividades. Por exemplo, um pedido para mostrar uma tela de detalhes com informações sobre um item de uma lista; Em telas pequenas, os detalhes são mostrados em toda a janela de tarefas. Em dispositivos maiores, ao lado da lista.

O pedido de inicialização precisa ser encaminhado para a atividade principal, e a atividade de detalhes de destino precisa ser iniciada em uma divisão. SplitController escolhe automaticamente a apresentação correta (empilhada ou lado a lado) com base na largura de tela disponível.

override fun onCreate(savedInstanceState Bundle?) {
    …
    splitController.registerRule(SplitPairRule(newFilters))
    startActivity(Intent(this, DetailActivity::class.java))
}

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    …
    splitController.registerRule(new SplitPairRule(newFilters));
    startActivity(new Intent(this, DetailActivity.class));
}

O destino do link direto pode ser a única atividade que precisa estar disponível para o usuário na pilha de navegação de retorno. Você pode evitar a ação de dispensar a atividade dos detalhes e deixar apenas a atividade principal:

Em vez disso, é possível finalizar as duas atividades ao mesmo tempo usando o atributo finishPrimaryWithSecondary:

<SplitPairRule
    window:finishPrimaryWithSecondary="always">
    <SplitPairFilter
        window:primaryActivityName=".List"
        window:secondaryActivityName=".Detail"/>
</SplitPairRule>

Consulte Atributos de configuração abaixo.

Várias atividades em contêineres divididos

O empilhamento de várias atividades em um contêiner dividido permite que os usuários acessem conteúdo localizado em partes diferentes. Por exemplo, com uma divisão dos detalhes da lista, o usuário pode precisar acessar uma seção de subdetalhes, mas manter a atividade principal no lugar:

class DetailActivity {
    …
    fun onOpenSubDetail() {
      startActivity(Intent(this, SubDetailActivity::class.java))
    }
}

public class DetailActivity {
    …
    void onOpenSubDetail() {
        startActivity(new Intent(this, SubDetailActivity.class));
    }
}

A atividade de subdetalhes é posicionada acima da atividade detalhada, que fica ocultada:

O usuário pode voltar ao nível de detalhes anterior navegando de volta pela pilha:

As atividades se empilham umas sobre as outras como comportamento padrão quando são iniciadas de uma atividade no mesmo contêiner secundário. Atividades iniciadas do contêiner principal em uma divisão ativa também acabam no contêiner secundário, na parte de cima da pilha de atividades.

Atividades em uma nova tarefa

Quando as atividades em uma janela de tarefas dividida iniciam atividades em uma nova tarefa, a nova tarefa é separada da tarefa que inclui a divisão e preenche a janela toda. A tela "Recentes" mostra duas tarefas: uma na divisão e a nova tarefa.

Substituir atividades

As atividades podem ser substituídas na pilha de contêineres secundária. Por exemplo, quando a atividade principal é usada para a navegação de nível mais alto e a atividade secundária é um destino selecionado. Cada seleção da navegação de nível superior precisa iniciar uma nova atividade no contêiner secundário e remover as atividades que estavam lá anteriormente.

Se o app não finaliza a atividade no contêiner secundário quando a seleção de navegação mudar, a navegação de retorno pode ficar confusa quando a divisão é recolhida (quando o dispositivo está dobrado). Por exemplo, se você tiver um menu no painel principal e telas A e B empilhadas no painel secundário, quando o usuário dobrar o smartphone, B vai estar em cima de A e A em cima do menu. Ao navegar de volta de B, o usuário vê A em vez do menu.

Nesses casos, é necessário remover a tela A da backstack.

O comportamento padrão ao iniciar uma atividade na lateral em um novo contêiner acima de uma divisão existente é colocar os novos contêineres secundários na parte de cima e manter os antigos na backstack. É possível configurar as divisões para limpar os contêineres secundários anteriores com clearTop e iniciar novas atividades normalmente.

<SplitPairRule
    window:clearTop="true">
    <SplitPairFilter
        window:primaryActivityName=".Menu"
        window:secondaryActivityName=".ScreenA"/>
    <SplitPairFilter
        window:primaryActivityName=".Menu"
        window:secondaryActivityName=".ScreenB"/>
</SplitPairRule>

class MenuActivity {
    …
    fun onMenuItemSelected(selectedMenuItem: Int) {
        startActivity(Intent(this, classForItem(selectedMenuItem)))
    }
}

public class MenuActivity {
    …
    void onMenuItemSelected(int selectedMenuItem) {
        startActivity(new Intent(this, classForItem(selectedMenuItem)));
    }
}

Como alternativa, use a mesma atividade secundária e envie novas intents da atividade principal (menu) que sejam resolvidas para a mesma instância, mas acionem uma atualização de estado ou de IU no contêiner secundário.

Várias divisões

Os apps podem oferecer navegação em vários níveis iniciando outras atividades na lateral.

Quando uma atividade em um contêiner secundário inicia uma nova atividade ao lado, uma nova divisão é criada sobre a divisão existente.

A pilha de retorno contém todas as atividades que foram abertas anteriormente para que os usuários possam navegar para a divisão A/B após a finalização de C.

Para criar uma nova divisão, inicie a nova atividade na lateral pelo contêiner secundário existente. Declare as configurações para as divisões A/B e B/C, e inicie a atividade C normalmente pela B:

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
    <SplitPairFilter
        window:primaryActivityName=".B"
        window:secondaryActivityName=".C"/>
</SplitPairRule>

class B {
    fun onOpenC() {
        startActivity(Intent(this, C::class.java))
    }
}

public class B {
    …
    void onOpenC() {
        startActivity(new Intent(this, C.class));
    }
}

Reagir a mudanças de estado da divisão

Atividades diferentes em um app podem ter elementos da IU que executam a mesma função. Por exemplo, um controle que abre uma janela contendo as configurações da conta.

Se duas atividades que têm um elemento da IU em comum estão divididas, é redundante e pode ser confuso mostrar o elemento nas duas atividades.

Para saber quando as atividades estão em uma divisão, registre um listener com o SplitController para mudanças no estado da divisão. Em seguida, ajuste a IU de acordo:

override fun onCreate(savedInstanceState: Bundle?) {
    splitController
        .addSplitListener(this, mainThreadExecutor, SplitInfoChangeCallback())
}

inner class SplitInfoChangeCallback : Consumer<List<SplitInfo>> {
    override fun accept(splitInfoList: List<SplitInfo>) {
        findViewById<View>(R.id.infoButton).visibility =
            if (!splitInfoList.isEmpty()) View.GONE else View.VISIBLE
    }
}

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    splitController
        .addSplitListener(this, mainThreadExecutor, SplitInfoChangeCallback());
}

class SplitInfoChangeCallback extends Consumer<List<SplitInfo>> {
    public void accept(List<SplitInfo> splitInfoList) {
        findViewById<View>(R.id.infoButton).visibility =
            !splitInfoList.isEmpty()) ? View.GONE : View.VISIBLE;
    }
}

É possível fazer callbacks em qualquer estado do ciclo de vida, inclusive quando uma atividade é interrompida. Os listeners geralmente precisam ser registrados em onStart() e não registrados em onStop().

Tela cheia modal

Algumas atividades impedem que os usuários interajam com o aplicativo até que uma ação especificada seja realizada. Por exemplo, uma atividade de tela de login, uma tela de confirmação de política ou uma mensagem de erro. As atividades modais precisam ser impedidas de aparecer em uma divisão.

Uma atividade pode ser forçada a sempre preencher a janela de tarefas usando a configuração de expansão:

<ActivityRule
    window:alwaysExpand="true">
    <ActivityFilter
        window:activityName=".FullWidthActivity"/>
</ActivityRule>

Finalizar atividades

Os usuários podem finalizar atividades em qualquer lado da divisão deslizando a partir da borda da tela:

Se o dispositivo estiver configurado para usar o botão "Voltar" em vez da navegação por gestos, a entrada é enviada para a atividade em foco, ou seja, a atividade que foi tocada ou iniciada por último.

O resultado da finalização de uma das atividades na divisão depende da configuração da divisão.

Atributos de configuração

É possível especificar atributos de regra de par dividido para configurar como a conclusão de todas as atividades em um lado da divisão afeta as atividades do outro lado da divisão. Os atributos são:

• window:finishPrimaryWithSecondary: como a conclusão de todas as atividades no contêiner secundário afeta as atividades no contêiner principal
• window:finishSecondaryWithPrimary: como a conclusão de todas as atividades no contêiner principal afeta as atividades no contêiner secundário

Os valores possíveis dos atributos incluem:

• always: sempre conclui as atividades no contêiner associado
• never: nunca conclui as atividades no contêiner associado
• adjacent: conclui as atividades no contêiner associado quando os dois contêineres são mostrados lado a lado, mas não quando estão empilhados

Exemplo:

<SplitPairRule
    <!-- Do not finish the primary activity when the secondary activity finishes. -->
    window:finishPrimaryWithSecondary="never"
    <!-- Finish the secondary activity whenever the primary activity finishes. -->
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

Configuração padrão

Quando uma atividade na divisão termina, a atividade restante ocupa a janela inteira:

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

Finalizar atividades em conjunto

Finalize a atividade principal automaticamente quando a atividade secundária for concluída:

<SplitPairRule
    window:finishPrimaryWithSecondary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

Conclua a atividade secundária automaticamente quando a atividade principal for finalizada:

<SplitPairRule
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

Conclua as atividades ao mesmo tempo quando o painel primário ou o secundário são finalizados:

<SplitPairRule
    window:finishPrimaryWithSecondary="always"
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

Finalizar várias atividades em contêineres

Se várias atividades forem empilhadas em um contêiner dividido, finalizar uma atividade na parte de baixo da pilha não conclui automaticamente as atividades na parte de cima.

Por exemplo, se duas atividades estiverem no contêiner secundário, C em cima de B:

E a configuração da divisão é definida pelas definições das atividades A e B:

<SplitPairRule>
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

A conclusão da atividade de cima mantém a divisão.

Concluir a atividade de baixo (raiz) do contêiner secundário não remove as atividades acima dele, e assim, retém a divisão.

Todas as outras regras para finalizar as atividades em conjunto, por exemplo, a conclusão da atividade secundária com a primária, também são executadas:

<SplitPairRule
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

E quando a divisão estiver configurada para finalizar as partes primária e secundária juntas:

<SplitPairRule
    window:finishPrimaryWithSecondary="always"
    window:finishSecondaryWithPrimary="always">
    <SplitPairFilter
        window:primaryActivityName=".A"
        window:secondaryActivityName=".B"/>
</SplitPairRule>

Mudar propriedades de divisão no momento da execução

Não é possível mudar as propriedades de uma divisão atualmente ativa e visível. Mudar as regras de divisão afeta a inicialização de outras atividades e novos contêineres, mas não divisões existentes e ativas.

Para mudar as propriedades de divisões ativas, conclua a atividade lateral ou as atividades na divisão e reinicie para a lateral novamente com uma nova configuração.

Extrair uma atividade de uma divisão para tela cheia

Crie uma nova configuração que mostre a tela cheia com a atividade lateral e, em seguida, reinicie a atividade com uma intent que é resolvida na mesma instância.

Conferir o suporte para divisão no momento da execução

A incorporação de atividades pode ser realizada no Android 12L (nível 32 da API) e versões mais recentes. Porém, ela também está disponível em alguns dispositivos com versões anteriores da plataforma. Para conferir a disponibilidade do recurso no tempo de execução, use o método SplitController.isSplitSupported():

val splitController = SplitController.Companion.getInstance()
if (splitController.isSplitSupported()) {
    // Device supports split activity features.
}

SplitController splitController = SplitController.Companion.getInstance();
if (splitController.isSplitSupported()) {
  // Device supports split activity features.
}

Se não houver suporte para divisões, as atividades vão ser iniciadas na parte de cima, seguindo o modelo de incorporação sem atividade.

Impedir a substituição do sistema

Os fabricantes de dispositivos Android (fabricantes de equipamentos originais, ou OEMs) podem implementar a incorporação de atividades como uma função do sistema do dispositivo. O sistema especifica regras de divisão para apps com várias atividades e substitui o comportamento de janelamento. A substituição do sistema força os apps com várias atividades a entrar em um modo de incorporação definido pelo sistema.

Esse tipo de incorporação de atividades pode melhorar a apresentação do app com o uso de layouts de vários painéis, como list-detail, sem realizar nenhuma mudança no app. No entanto, ela também pode gerar layouts de app incorretos, bugs ou conflitos.

O app pode impedir ou permitir a incorporação de atividades do sistema definindo uma propriedade no arquivo de manifesto do app, por exemplo:

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application>
        <property
            android:name="android.window.PROPERTY_ACTIVITY_EMBEDDING_ALLOW_SYSTEM_OVERRIDE"
            android:value="true|false" />
    </application>
</manifest>

O nome da propriedade é definido no objeto WindowProperties da API Jetpack WindowManager. Defina o valor como false se o app implementar a incorporação de atividades ou se você quiser impedir que o sistema use as regras da incorporação. Defina como true para permitir o uso da incorporação de atividades definida pelo sistema.

Limitações, restrições e advertências

• Apenas o app host da tarefa, que é identificado como o proprietário da atividade raiz, pode organizar e incorporar outras atividades à tarefa. Se as atividades que oferecem suporte a divisões e incorporação forem executadas em uma tarefa que pertença a um aplicativo diferente, as incorporações e divisões não funcionarão para essas atividades.
• As atividades só podem ser organizadas em uma tarefa. Iniciar uma atividade em uma nova tarefa sempre a coloca em uma nova janela expandida fora das divisões existentes.
• Apenas atividades no mesmo processo podem ser organizadas e colocadas em uma divisão. O callback SplitInfo só informa atividades que pertencem ao mesmo processo, já que não há como saber sobre atividades em processos diferentes.
• Cada par ou regra de atividade única se aplica apenas para atividades iniciadas após a regra ser registrada. Atualmente, não há como atualizar as divisões existentes ou as propriedades visuais delas.
• A configuração do filtro de par dividido precisa corresponder às intents usadas ao iniciar completamente as atividades. A correspondência ocorre no momento em que uma nova atividade é iniciada do processo do aplicativo. Por isso, ela pode não saber sobre os nomes de componentes que são resolvidos mais tarde no processo do sistema ao usar intents implícitas. Se o nome de um componente não for conhecido no momento da inicialização, um caractere curinga pode ser usado (“*/*”) e a filtragem pode ser realizada com base na ação da intent.
• Atualmente, não há como mover atividades entre contêineres ou para dentro e fora de divisões após serem criadas. As divisões são criadas pela biblioteca WindowManager apenas quando novas atividades com regras correspondentes são iniciadas, e as divisões são destruídas quando a última atividade em um contêiner de divisão é finalizada.
• As atividades podem ser reiniciadas quando a configuração é alterada. Portanto, quando uma divisão é criada ou removida e os limites de atividades mudam, a atividade pode passar pela destruição completa da instância anterior e criação da nova. Como resultado, os desenvolvedores de apps precisam ter cuidado, por exemplo, com a inicialização de novas atividades usando callbacks do ciclo de vida.
• Os dispositivos precisam incluir a interface de extensões de janela para oferecer suporte à incorporação de atividades. Quase todos os dispositivos de tela grande que executam o Android 12L (nível 32 da API) ou versões mais recentes incluem a interface. No entanto, alguns dispositivos de tela grande que não são capazes de executar várias atividades não incluem a interface de extensões de janela. Se um dispositivo de tela grande não oferece suporte para o modo de várias janelas, ele pode não realizar a incorporação de atividades.

Outros recursos

• Prévia para desenvolvedores do 12L
• Instalar o 12L