O modo de várias janelas permite que vários apps compartilhem a mesma tela simultaneamente. Os apps podem estar lado a lado ou acima do outro (modo de tela dividida), um app em uma pequena janela sobrepondo outros apps (modo picture-in-picture) ou apps individuais em janelas móveis e redimensionáveis separadas (modo de formato livre).
A experiência do usuário depende da versão do Android e do tipo de dispositivo:
O Android 7.0 (nível 24 da API) introduziu o modo de tela dividida em dispositivos de tela pequena e o modo picture-in-picture em alguns dispositivos.
O modo de tela dividida preenche a tela com dois apps, mostrando-os lado a lado ou um acima do outro. Os usuários podem arrastar o divisor separando os dois apps para aumentar e diminuir o outro.
O modo picture-in-picture permite que os usuários continuem a reprodução de vídeo enquanto interagem com outro app. Consulte Suporte ao modo picture-in-picture.
O modo de formato livre, em que os usuários podem redimensionar livremente cada atividade, pode ser ativado pelos fabricantes de dispositivos de tela grande.
Você pode configurar a forma como o app processa o modo de várias janelas especificando as dimensões mínimas permitidas para a atividade. Você também pode desativar o modo de várias janelas no seu app definindo
resizeabableActivity="false"
para garantir que o sistema sempre mostre o app em tela cheia.O Android 8.0 (nível 26 da API) estende o modo picture-in-picture para dispositivos de tela pequena.
O Android 12 (nível 31 da API) torna o modo de várias janelas o comportamento padrão.
Em telas grandes (largura mínima >= 600 dp), a plataforma oferece suporte a todos os apps no modo de várias janelas, independente da configuração do app. Se
resizeableActivity="false"
, o app será colocado no modo de compatibilidade quando necessário para acomodar as dimensões de exibição.Em telas pequenas (com largura menor < 600 dp), o sistema confere o
minWidth
e ominHeight
de uma atividade para determinar se ela pode ser executada no modo de várias janelas. SeresizeableActivity="false"
, o app não poderá ser executado no modo de várias janelas, independente da largura e altura mínimas.
Modo de tela dividida
Para ativar o modo de tela dividida, os usuários podem fazer o seguinte:
- Abra a tela Recentes
- Deslizar um app para vê-lo
- Pressionar o ícone do app na barra de título
- Selecionar a opção de menu "Tela dividida"
- Selecionar outro app na tela "Recentes" ou fechar essa tela e executar outro app
Os usuários podem sair do modo de tela dividida arrastando o divisor de janelas até a borda da tela (para cima/baixo, esquerda/direita).
Iniciar adjacente
Se o app precisar acessar conteúdo por uma intent, use
FLAG_ACTIVITY_LAUNCH_ADJACENT
para abrir o conteúdo em uma janela de tela
dividida adjacente.
A FLAG_ACTIVITY_LAUNCH_ADJACENT
foi introduzida no Android 7.0 (nível 24 da API) para
permitir que apps em execução no modo de tela dividida iniciem atividades na janela
próxima.
O Android 12L (nível 32 da API) e versões mais recentes ampliaram a definição da flag para permitir que apps executados em tela cheia ativem o modo de tela dividida e iniciem atividades na janela adjacente.
Para iniciar uma atividade adjacente, use FLAG_ACTIVITY_LAUNCH_ADJACENT
com FLAG_ACTIVITY_NEW_TASK
, por exemplo:
Kotlin
fun openUrlInAdjacentWindow(url: String) { Intent(Intent.ACTION_VIEW).apply { data = Uri.parse(url) addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT or Intent.FLAG_ACTIVITY_NEW_TASK) }.also { intent -> startActivity(intent) } }
Java
public void openUrlInAdjacentWindow(String url) { Intent intent = new Intent(Intent.ACTION_VIEW); intent.setData(Uri.parse(url)); intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT | Intent.FLAG_ACTIVITY_NEW_TASK); startActivity(intent); }
Ciclo de vida da atividade no modo de várias janelas
O modo de várias janelas não muda o ciclo de vida da atividade. No entanto, o estado retomado dos apps em várias janelas varia de acordo com as diferentes versões do Android.
Retomada múltipla
O Android 10 (nível 29 da API) e versões mais recentes oferecem suporte à retomada múltipla. Todas
as atividades permanecem no estado RESUMED
quando o dispositivo está no modo
de várias janelas. Uma atividade poderá ser pausada se uma atividade transparente estiver sobre ela
ou se ela não puder ser focalizada, por exemplo, se a atividade estiver no
modo picture-in-picture. Também é possível que nenhuma atividade esteja em foco em um
determinado momento, por exemplo, se a gaveta de notificações estiver aberta. O método onStop()
funciona normalmente: ele é chamado sempre que uma atividade é retirada
da tela.
A retomada múltipla também está disponível em alguns dispositivos com o Android 9 (nível 28 da API). Para ativar a retomada múltipla em dispositivos Android 9, adicione estes metadados do manifesto:
<meta-data android:name="android.allow_multiple_resumed_activities" android:value="true" />
Para verificar se determinado dispositivo é compatível com esses metadados do manifesto, consulte as especificações do dispositivo.
Android 9
No modo de várias janelas no Android 9 (API de nível 28) e versões anteriores, somente a atividade
com que o usuário interagiu mais recentemente fica ativa em determinado momento. Essa
atividade é considerada a superior e é a única no estado
RESUMED
. Todas as outras atividades visíveis ficam no estado STARTED
, mas não em RESUMED
.
No entanto, o sistema atribui a essas atividades visíveis, mas não retomadas,
uma prioridade maior que a das atividades não visíveis. Se o usuário interagir com uma das
atividades visíveis, ela será retomada, e a atividade que antes era a mais importante
entrará no estado STARTED
.
Quando houver várias atividades em um único processo de app ativo, a atividade com a ordem z mais alta será retomada e as outras serão pausadas.
Mudanças de configuração
Quando o usuário coloca um app no modo de várias janelas, o sistema notifica a atividade sobre uma mudança de configuração, conforme especificado em Processar mudanças de configuração. Isso também acontece quando o usuário redimensiona o app ou o coloca novamente no modo de tela cheia.
Essencialmente, essa mudança tem as mesmas implicações no ciclo de vida da atividade que quando o sistema notifica o app de que o dispositivo mudou da orientação retrato para paisagem, exceto que as dimensões do app são alteradas, em vez de apenas trocadas. Sua atividade pode processar a mudança de configuração por conta própria ou o app pode permitir que o sistema destrua a atividade e a recrie com as novas dimensões.
Se o usuário redimensionar uma janela e aumentar uma de suas dimensões, o sistema
redimensionará a atividade para corresponder à ação do usuário e emitirá mudanças de configuração
conforme necessário. Se o app demorar a desenhar nas áreas recém-expostas, o
sistema preencherá temporariamente essas áreas com a cor especificada pelo atributo
windowBackground
ou pelo atributo de estilo
windowBackgroundFallback
padrão.
Acesso exclusivo a recursos
Para ajudar a oferecer compatibilidade com o recurso de retomada múltipla, use o
callback do ciclo de vida onTopResumedActivityChanged()
.
O callback é invocado quando uma atividade ganha ou perde a posição de principal atividade retomada, o que é importante quando uma atividade usa um recurso Singleton compartilhado, como o microfone ou a câmera.
Kotlin
override fun onTopResumedActivityChanged(topResumed: Boolean) { if (topResumed) { // Top resumed activity // Can be a signal to re-acquire exclusive resources } else { // No longer the top resumed activity } }
Java
@Override public void onTopResumedActivityChanged(boolean topResumed) { if (topResumed) { // Top resumed activity // Can be a signal to re-acquire exclusive resources } else { // No longer the top resumed activity } }
Um app pode perder recursos por outros motivos, como a remoção de um hardware compartilhado.
Seja como for, é preciso que os apps tratem com eficiência os eventos e as mudanças de estado que afetam os recursos disponíveis.
Para apps que usam uma câmera, o
CameraManager.AvailabilityCallback#onCameraAccessPrioritiesChanged()
oferece uma dica de que pode ser um bom momento para tentar acessar a câmera.
Esse método está disponível a partir do Android 10 (API de nível 29).
Lembre-se de que resizeableActivity=false
não garante o acesso exclusivo à câmera, já que outros apps que usam a câmera podem ser abertos em outras telas.
![](https://developer.android.com/static/images/guide/topics/ui/foldables/fold-camera.png?authuser=3&hl=pt)
O app não precisa liberar a câmera quando perder o foco. Por exemplo, você pode continuar a visualização da câmera enquanto o usuário interage com o app de retomada superior recém-focado. O app pode continuar executando a câmera quando não for o de retomada superior, mas precisa lidar com o caso de desconexão corretamente. Quando o app de retomada superior quiser usar a câmera, ele poderá abri-la, e seu app perderá o acesso. Seu app poderá reabrir a câmera quando voltar o foco.
Depois que um app receber um callback CameraDevice.StateCallback#onDisconnected()
, as chamadas subsequentes no dispositivo da câmera vão gerar uma
CameraAccessException
.
Várias telas
O Android 10 (API de nível 29) é compatível com atividades em telas secundárias. Se uma atividade estiver sendo executada em um dispositivo com várias telas, os usuários poderão mover a atividade de uma tela para outra. A retomada múltipla também se aplica a cenários com várias telas. Várias atividades podem receber entrada do usuário ao mesmo tempo.
Um app pode especificar em qual tela precisa ser executado quando for iniciado
ou quando criar outra atividade. Esse comportamento depende do modo de inicialização da atividade
definido no arquivo de manifesto, bem como das sinalizações de intents e opções definidas pela
entidade que está iniciando a atividade. Consulte a classe ActivityOptions
para mais
detalhes.
Quando uma atividade é movida para uma tela secundária, ela pode passar por uma atualização
de contexto, redimensionamento de janela e mudanças de configuração e recursos. Se a atividade
processar a mudança de configuração, ela será notificada em
onConfigurationChanged()
. Caso contrário, ela será reiniciada.
Uma atividade precisa verificar a tela atual em onCreate()
e
onConfigurationChanged()
se estiver processando a mudança de configuração. Certifique-se de
atualizar os recursos e layouts quando a tela mudar.
Se o modo de inicialização selecionado para uma atividade permitir várias instâncias, a inicialização em uma tela secundária poderá criar uma nova instância da atividade. As duas atividades são retomadas ao mesmo tempo.
![](https://developer.android.com/static/images/guide/topics/ui/foldables/fold-multi-display.png?authuser=3&hl=pt)
Para saber mais, leia sobre as APIs de várias telas que foram introduzidas no Android 8.0.
Atividade x contexto do app
Usar o contexto certo é fundamental quando se usa várias telas. Ao acessar recursos, o contexto da atividade (exibido) é diferente do contexto do app (que não é exibido).
O contexto da atividade contém informações sobre a tela e é sempre ajustado para a área da tela em que a atividade aparece. Isso permite que você receba as informações corretas sobre as métricas de densidade ou janela de exibição do app. Use sempre o contexto da atividade (ou outro contexto baseado na interface) para receber informações sobre a janela ou tela atual. Isso também afeta algumas APIs do sistema que usam informações do contexto (por exemplo, consulte Visão geral dos avisos).
A configuração da janela da atividade e da tela principal definem os recursos e o contexto. Veja a exibição atual da seguinte forma:
Kotlin
val activityDisplay = activity.getDisplay()
Java
Display activityDisplay = activity.getDisplay();
Veja as métricas atuais da janela de atividade:
Kotlin
val windowMetrics = activity.getWindowManager().getCurrentWindowMetrics()
Java
WindowMetrics windowMetrics = activity.getWindowManager().getCurrentWindowMetrics();
Encontre o máximo de métricas da janela para a configuração atual do sistema:
Kotlin
val maximumWindowMetrics = activity.getWindowManager().getMaximumWindowMetrics()
Java
WindowMetrics maximumWindowMetrics = activity.getWindowManager().getMaximumWindowMetrics();
As métricas de janela máximas são para fazer cálculos, escolhas de layout ou
determinar o tamanho dos recursos a serem buscados antecipadamente. Se você as disponibilizar no
método onCreate()
, poderá tomar essas decisões antes da primeira transmissão
do layout. Essas métricas não podem ser usadas para dispor elementos específicos da visualização.
Em vez disso, use informações do objeto Configuration
.
Cortes de tela
Dispositivos dobráveis podem ter diferentes geometrias de corte quando dobrados e desdobrados. Para evitar problemas de corte, consulte Suporte a cortes da tela.
Telas secundárias
Você pode acessar as telas disponíveis no serviço do sistema do DisplayManager
:
Kotlin
val displayManager = getSystemService(Context.DISPLAY_SERVICE) as DisplayManager val displays = displayManager.getDisplays()
Java
DisplayManager displayManager = (DisplayManager) getSystemService(Context.DISPLAY_SERVICE); Display[] displays = displayManager.getDisplays();
Use a classe Display
para receber informações sobre uma tela específica, como
o tamanho da tela ou sinalizações que indicam se uma tela é segura.
No entanto, não presuma que o tamanho da tela será o mesmo que a
área de exibição alocada para o app. Lembre-se de que, no modo de várias janelas,
o aplicativo ocupa uma parte da tela.
Determine se uma atividade pode ser iniciada em uma tela:
Kotlin
val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager val activityAllowed = activityManager.isActivityStartAllowedOnDisplay(context, displayId, intent)
Java
ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); boolean activityAllowed = activityManager.isActivityStartAllowedOnDisplay(context, displayId, intent);
Em seguida, inicie a atividade na tela:
Kotlin
val options = ActivityOptions.makeBasic() options.setLaunchDisplayId(targetDisplay.displayId) startActivity(intent, options.toBundle())
Java
ActivityOptions options = ActivityOptions.makeBasic(); options.setLaunchDisplayId(targetDisplay.displayId); startActivity(intent, options.toBundle());
Suporte a várias telas
O Android é compatível com várias telas para teclados de software, planos de fundo e telas de início.
Teclado de software
Um teclado poderá ser mostrado em uma tela secundária se a exibição estiver configurada para oferecer suporte a decorações do sistema. O editor de método de entrada será exibido automaticamente se um campo de texto solicitar entrada nessa tela.
![](https://developer.android.com/static/images/guide/topics/ui/foldables/fold-keyboard.png?authuser=3&hl=pt)
Plano de fundo
No Android 10 (API de nível 29), as telas secundárias podem ter um plano de fundo. O
framework cria uma instância separada de WallpaperService.Engine
para cada
tela. Verifique se a superfície de cada mecanismo é desenhada de maneira independente. Os desenvolvedores
podem carregar recursos usando o contexto da tela em
WallpaperService.Engine#getDisplayContext()
. Além disso, verifique se o
arquivo WallpaperInfo.xml
é definido como android:supportsMultipleDisplays="true"
.
![](https://developer.android.com/static/images/guide/topics/ui/foldables/fold-wallpaper.png?authuser=3&hl=pt)
Telas de início
Uma nova categoria de filtro de intent, SECONDARY_HOME
, fornece uma atividade dedicada
para telas secundárias. Instâncias dessa atividade são usadas em todas as telas
compatíveis com decorações do sistema, uma para cada tela.
<activity>
...
<intent-filter>
<category android:name="android.intent.category.SECONDARY_HOME" />
...
</intent-filter>
</activity>
É necessário que a atividade tenha um modo de inicialização que não impeça várias instâncias
e que possa se adaptar a diferentes tamanhos de tela. Não é possível usar os modos de inicialização
singleInstance
ou singleTask
.
Por exemplo, a implementação do AOSP de Launcher3
é compatível com uma
atividade SECONDARY_HOME
.
![](https://developer.android.com/static/images/guide/topics/ui/foldables/fold-launcher-phone.png?authuser=3&hl=pt)
![](https://developer.android.com/static/images/guide/topics/ui/foldables/fold-launcher-display.png?authuser=3&hl=pt)
Métricas de janela
O Android 11 (nível 30 da API) introduziu os métodos WindowManager
abaixo
para fornecer os limites de apps em execução no modo de várias janelas:
getCurrentWindowMetrics()
: retorna um objetoWindowMetrics
para o estado atual do janelamento do sistema.getMaximumWindowMetrics()
: retornaWindowMetrics
para o maior estado de janelamento potencial do sistema.
Os métodos da biblioteca WindowManager do Jetpack computeCurrentWindowMetrics()
e computeMaximumWindowMetrics()
oferecem uma funcionalidade semelhante,
respectivamente, mas com compatibilidade com versões anteriores até o nível 14 da API.
Para acessar métricas de outras telas além da atual, faça o seguinte (conforme mostrado no snippet de código):
- Crie um contexto de exibição
- Crie um contexto de janela para a tela
- Encontre o
WindowManager
do contexto da janela - Encontre o
WindowMetrics
da área de exibição máxima disponível para o app
Kotlin
val windowMetrics = context.createDisplayContext(display) .createWindowContext(WindowManager.LayoutParams.TYPE_APPLICATION, null) .getSystemService(WindowManager::class.java) .maximumWindowMetrics
Java
WindowMetrics windowMetrics = context.createDisplayContext(display) .createWindowContext(WindowManager.LayoutParams.TYPE_APPLICATION, null) .getSystemService(WindowManager.class) .getMaximumWindowMetrics();
Métodos obsoletos
Os métodos Display
getSize()
e getMetrics()
foram descontinuados no
nível 30 da API em favor dos novos métodos WindowManager
.
O Android 12 (nível 31 da API) descontinuou os métodos Display
getRealSize()
e
getRealMetrics()
e atualizou o comportamento para corresponder melhor ao
comportamento de getMaximumWindowMetrics()
.
Configuração do modo de várias janelas
Se o app for direcionado ao Android 7.0 (nível 24 da API) ou versões mais recentes, você poderá configurar como
e se as atividades dele oferecem suporte ao modo de várias janelas. Você pode definir
atributos no manifesto para controlar o tamanho e o layout. As configurações de atributos
de uma atividade raiz se aplicam a todas as atividades na pilha de tarefas dela. Por exemplo,
se a atividade raiz tiver android:resizeableActivity="true"
, todas
as atividades na pilha de tarefas serão redimensionáveis. Em alguns dispositivos maiores, como
Chromebooks, seu app poderá ser executado em uma janela redimensionável, mesmo se você especificar
android:resizeableActivity="false"
. Se isso corromper seu app, você poderá usar
filtros no Google Play para restringir a disponibilidade do app nesses dispositivos.
O Android 12 (nível 31 da API) usa o modo de várias janelas por padrão. Em telas grandes (com 600 dp ou mais), todos os apps são executados no modo de várias janelas, independente da configuração do app. Em
telas pequenas, o sistema verifica as configurações minWidth
, minHeight
e resizeableActivity
de uma atividade para determinar se ela pode ser executada
no modo de várias janelas.
resizeableActivity
Defina esse atributo no elemento <activity>
ou <application>
do manifesto para ativar ou desativar o modo de várias janelas no nível 30 da API e versões anteriores:
<application
android:name=".MyActivity"
android:resizeableActivity=["true" | "false"] />;
Se o atributo for definido como true
, a atividade poderá ser iniciada nos modos de tela dividida
e formato livre. Se o atributo for definido como false
, a atividade não vai oferecer
suporte ao modo de várias janelas. Se o valor for "false" e o usuário tentar
iniciar a atividade no modo de várias janelas, a atividade vai ocupar a tela
cheia.
Se o app for direcionado ao nível 24 da API ou mais recente, mas você não especificar um valor para esse atributo, ele será definido como "true" por padrão.
Se o app for direcionado ao nível 31 da API ou mais recente, esse atributo vai funcionar de forma diferente em telas pequenas e grandes:
- Telas grandes (com 600 dp ou mais): todos os apps oferecem suporte ao modo de várias janelas. O
atributo indica se uma atividade pode ser redimensionada. Se
resizeableActivity="false"
, o app vai ser colocado em modo de compatibilidade quando necessário para obedecer às dimensões de exibição. - Telas pequenas (com menos de 600 dp): se
resizeableActivity="true"
e a largura e a altura mínimas da atividade estiverem dentro dos requisitos de várias janelas, a atividade vai oferecer suporte ao modo de várias janelas. Se forresizeableActivity="false"
, a atividade não vai oferecer suporte ao modo de várias janelas, independente da largura e altura mínimas da atividade.
supportsPictureInPicture
Defina esse atributo no nó <activity>
do manifesto para indicar se
a atividade oferece suporte ao modo picture-in-picture.
<activity
android:name=".MyActivity"
android:supportsPictureInPicture=["true" | "false"] />
configChanges
Para processar mudanças de configuração de várias janelas por conta própria, como quando um usuário
redimensiona uma janela, adicione o atributo android:configChanges
ao nó
<activity>
do manifesto do app com pelo menos os seguintes valores:
<activity
android:name=".MyActivity"
android:configChanges="screenSize | smallestScreenSize
| screenLayout | orientation" />
Depois de adicionar android:configChanges
, sua atividade e seus fragmentos recebem um
callback para onConfigurationChanged()
, em vez de serem destruídos e
recriados. É possível atualizar manualmente suas visualizações, recarregar recursos e
realizar outras operações conforme necessário.
<layout>
No Android 7.0 (nível 24 da API) e versões mais recentes, o elemento de manifesto <layout>
oferece suporte a vários atributos que afetam o comportamento da atividade no modo
de várias janelas:
android:defaultHeight
,android:defaultWidth
: altura e largura padrão da atividade quando iniciada no modo de formato livre.android:gravity
: posicionamento inicial da atividade quando iniciada no modo de formato livre. Consulte a classeGravity
para conferir os valores adequados.android:minHeight
,android:minWidth
: altura e largura mínimas para a atividade nos modos de tela dividida e formato livre. Se o usuário mover o divisor no modo de tela dividida para tornar uma atividade menor que o mínimo especificado, o sistema recortará a atividade para o tamanho solicitado pelo usuário.
O código a seguir mostra como especificar um tamanho e um local padrão para a atividade, além do tamanho mínimo quando a atividade é exibida no modo de formato livre:
<activity android:name=".MyActivity">
<layout android:defaultHeight="500dp"
android:defaultWidth="600dp"
android:gravity="top|end|..."
android:minHeight="450dp"
android:minWidth="300dp" />
</activity>
Modo de várias janelas no ambiente de execução
A partir do Android 7.0, o sistema oferece funcionalidade de suporte a apps que podem ser executados no modo de várias janelas.
Recursos desativados no modo de várias janelas
No modo de várias janelas, o Android pode desativar ou ignorar recursos que não se aplicam a uma atividade que está compartilhando a tela do dispositivo com outros apps ou atividades.
Além disso, algumas opções de personalização da interface do sistema estão desativadas. Por exemplo, os apps não poderão ocultar a barra de status se estiverem sendo executados no modo de várias janelas. Consulte Controlar a visibilidade da IU do sistema.
O sistema ignora as mudanças no atributo android:screenOrientation
.
Callbacks e consultas no modo de várias janelas
A classe Activity
oferece os métodos abaixo para oferecer suporte ao modo
de várias janelas:
isInMultiWindowMode()
: indica se a atividade está no modo de várias janelas.isInPictureInPictureMode()
: indica se a atividade está no modo picture-in-picture.onMultiWindowModeChanged()
: o sistema chama esse método sempre que a atividade entra ou sai do modo de várias janelas. O sistema transmitirá ao método o valor "true" se a atividade entrar no modo de várias janelas ou "false" se a atividade sair desse modo.onPictureInPictureModeChanged()
: o sistema chama esse método sempre que a atividade entra ou sai do modo picture-in-picture. O sistema vai transmitir ao método o valor "true" se a atividade entrar no modo picture-in-picture ou "false" se a atividade sair desse modo.
A classe Fragment
expõe versões de muitos desses métodos. Por exemplo,
Fragment.onMultiWindowModeChanged()
.
Modo picture-in-picture
Para colocar uma atividade no modo picture-in-picture, chame
enterPictureInPictureMode()
. Esse método não terá efeito se o dispositivo
não oferecer suporte ao modo picture-in-picture. Para saber mais, consulte Adicionar vídeos usando
o picture-in-picture.
Novas atividades no modo de várias janelas
Ao iniciar uma nova atividade, você pode indicar que ela será
exibida ao lado da atual, se possível. Use a flag de intent
FLAG_ACTIVITY_LAUNCH_ADJACENT
, que instrui o sistema a tentar criar a
nova atividade em uma janela adjacente para que as duas atividades compartilhem a tela. O sistema faz o possível para fazer isso, mas não é garantido que isso aconteça.
Se um dispositivo estiver no modo de formato livre e você estiver iniciando uma nova atividade, poderá
especificar as dimensões e o local na tela dela chamando
ActivityOptions.setLaunchBounds()
. O método não terá efeito se o dispositivo
não estiver no modo de várias janelas.
No nível 30 da API e versões anteriores, se você iniciar uma atividade em uma pilha de tarefas, ela vai substituir a atividade na tela, herdando todas as propriedades de várias janelas. Se você quiser iniciar a nova atividade como uma janela separada no modo de várias janelas, inicie-a em uma nova pilha de tarefas.
O Android 12 (API de nível 31) permite que os apps dividam a janela de tarefas de um app entre várias atividades. Para determinar como o app mostra as atividades (tela cheia, lado a lado ou empilhada), crie um arquivo de configuração XML ou faça chamadas da API WindowManager do Jetpack.
Arrastar e soltar
Os usuários podem arrastar e soltar dados de uma atividade para outra enquanto as duas
atividades compartilham a tela. Antes do Android 7.0, os usuários só podiam arrastar
e soltar dados em uma única atividade. Para adicionar rapidamente suporte à aceitação
de conteúdo descartado, consulte a API DropHelper
. Para orientações abrangentes de arrastar e soltar, consulte Ativar o recurso de arrastar e soltar.
Várias instâncias
Cada atividade raiz tem uma tarefa própria, que é executada em um processo separado
e exibida na própria janela. Para iniciar uma nova instância do seu app em uma janela separada, inicie novas atividades com a
sinalização FLAG_ACTIVITY_NEW_TASK
. É
possível combinar isso com alguns dos atributos de várias janelas para solicitar
um local específico para a nova janela. Por exemplo, um aplicativo de compras pode exibir
várias janelas para comparar produtos.
O Android 12 (nível 31 da API) permite iniciar duas instâncias de uma atividade lado a lado na mesma janela de tarefas.
Se você quiser permitir que os usuários iniciem outra instância do aplicativo no
acesso rápido ou na barra de tarefas, verifique se a atividade da tela de início
define android:resizeableActivity="true"
e não usa um modo de inicialização que
impeda várias instâncias. Por exemplo, uma atividade singleInstancePerTask
pode
ser instanciada várias vezes em tarefas diferentes quando
FLAG_ACTIVITY_MULTIPLE_TASK
ou FLAG_ACTIVITY_NEW_DOCUMENT
está definido.
Não confunda várias instâncias com um layout de vários painéis, como uma apresentação de detalhes
de lista que usa SlidingPaneLayout
(link em inglês), que é executado em uma única
janela.
Quando várias instâncias estão em execução em janelas separadas em um dispositivo dobrável, uma ou mais instâncias poderão ser enviadas para o segundo plano se a posição mudar. Por exemplo, suponha que um dispositivo não esteja dobrado e tenha duas instâncias de app em execução em duas janelas em ambos os lados. Se o dispositivo estiver dobrado, uma das instâncias poderá ser encerrada em vez de tentar encaixar as janelas de ambas as instâncias em uma tela menor.
Verificação no modo de várias janelas
Mesmo que o app não seja destinado ao nível 24 da API ou mais recente, verifique como ele se comporta no modo de várias janelas, caso um usuário tente iniciá-lo nesse modo em um dispositivo com o Android 7.0 ou mais recente.
Testar dispositivos
Dispositivos com o Android 7.0 (nível 24 da API) ou versões mais recentes oferecem suporte ao modo de várias janelas.
Nível 23 da API ou anterior
Quando os usuários tentam usar o app no modo de várias janelas, o sistema força o redimensionamento do app, a menos que ele declare uma orientação fixa.
Se o app não declarar uma orientação fixa, inicie-o em um dispositivo com o Android 7.0 ou mais recente e tente colocá-lo no modo de tela dividida. Verifique se a experiência do usuário é aceitável quando o redimensionamento do app é forçado.
Se o app declarar uma orientação fixa, tente colocá-lo no modo de várias janelas. Ao fazer isso, verifique se ele continua no modo de tela cheia.
APIs de nível 24 ao 30
Se o app for direcionado a APIs de nível 24 a 30 e não desativar a compatibilidade com várias janelas, verifique o seguinte comportamento nos modos de tela dividida e formato livre:
Toque no botão Recentes e mantenha-o pressionado para iniciar o app em tela cheia e mudar para o modo de várias janelas. Verifique se o app alterna corretamente.
Inicie o app diretamente no modo de várias janelas e verifique se ele é iniciado corretamente. Você pode iniciar um app no modo de várias janelas pressionando o botão Recentes, mantendo a barra de título pressionada e arrastando para uma das áreas destacadas na tela.
Para redimensionar o app no modo de tela dividida, arraste o divisor de tela. Verifique se o app é redimensionado sem falhar e se os elementos de interface necessários estão visíveis.
Se você especificou dimensões mínimas para o app, tente redimensioná-lo para que o tamanho da janela seja menor que essas dimensões. Verifique se não é possível redimensionar o app para um tamanho menor que as dimensões mínimas especificadas.
Em todos os testes, verifique se o desempenho do app é aceitável. Por exemplo, verifique se não há um atraso muito longo para atualizar a interface depois que o app for redimensionado.
API de nível 31 ou mais recente
Se o app for direcionado ao nível 31 da API ou mais recente, e a largura e altura mínimas da atividade principal forem menores ou iguais às respectivas dimensões da área de exibição disponível, verifique todos os comportamentos listados para os níveis 24 a 30 da API.
Lista de verificação de teste
Para verificar o desempenho do app no modo de várias janelas, realize as operações a seguir. Tente executar estas operações nos modos de tela dividida e de formato livre, exceto quando houver instruções diferentes.
Entre e saia do modo de várias janelas.
Troque do seu app para outro e verifique se ele se comporta corretamente enquanto visível, mas não ativo. Por exemplo, se o app estiver reproduzindo vídeo, verifique se a reprodução continua enquanto o usuário está interagindo com outro app.
No modo de tela dividida, tente mover o divisor de tela para aumentar e diminuir o tamanho do app. Tente essas operações em ambas as configurações lado a lado e uma acima da outra. Verifique se o app não falha, se a funcionalidade essencial está visível e se a operação de redimensionamento não demora muito.
Execute várias operações de redimensionamento em rápida sucessão. Verifique se o app não falha nem apresenta vazamento de memória. O Memory Profiler do Android Studio fornece informações sobre o uso da memória do app. Consulte Inspecionar o uso da memória do app com o Memory Profiler.
Use seu app normalmente em várias configurações diferentes de janela e verifique se ele se comporta corretamente. Verifique se o texto é legível e se os elementos da interface não ficam pequenos demais para a interação.
Suporte ao modo de várias janelas desativado
Nos níveis 24 a 30 da API, se você desativou o suporte a várias janelas definindo
android:resizeableActivity="false"
, inicie o app em um dispositivo
com o Android 7.0 a 11 e tente colocá-lo nos modos de tela dividida e
formato livre. Ao fazer isso, verifique se o app continua no modo de
tela cheia.
Outros recursos
Para mais informações sobre a compatibilidade com várias janelas no Android, consulte:
- Amostra MultiWindowPlayground do Android
Recomendados para você
* Observação: o texto do link é exibido quando o JavaScript está desativado * Modo de compatibilidade do dispositivo * Suporte ao redimensionamento de tela grande * Processar mudanças de configuração