<activity>

Sintaxe:

<activity android:allowEmbedded=["true" | "false"]
          android:allowTaskReparenting=["true" | "false"]
          android:alwaysRetainTaskState=["true" | "false"]
          android:autoRemoveFromRecents=["true" | "false"]
          android:banner="drawable resource"
          android:canDisplayOnRemoteDevices=["true" | "false"]
          android:clearTaskOnLaunch=["true" | "false"]
          android:colorMode=[ "hdr" | "wideColorGamut"]
          android:configChanges=["colorMode", "density",
                                 "fontScale", "fontWeightAdjustment",
                                 "grammaticalGender", "keyboard",
                                 "keyboardHidden", "layoutDirection", "locale",
                                 "mcc", "mnc", "navigation", "orientation",
                                 "screenLayout", "screenSize",
                                 "smallestScreenSize", "touchscreen", "uiMode"]
          android:directBootAware=["true" | "false"]
          android:documentLaunchMode=["intoExisting" | "always" |
                                  "none" | "never"]
          android:enabled=["true" | "false"]
          android:enabledOnBackInvokedCallback=["true" | "false"]
          android:excludeFromRecents=["true" | "false"]
          android:exported=["true" | "false"]
          android:finishOnTaskLaunch=["true" | "false"]
          android:hardwareAccelerated=["true" | "false"]
          android:icon="drawable resource"
          android:immersive=["true" | "false"]
          android:label="string resource"
          android:launchMode=["standard" | "singleTop" |
                              "singleTask" | "singleInstance" | "singleInstancePerTask"]
          android:lockTaskMode=["normal" | "never" |
                              "if_whitelisted" | "always"]
          android:maxRecents="integer"
          android:maxAspectRatio="float"
          android:multiprocess=["true" | "false"]
          android:name="string"
          android:noHistory=["true" | "false"]  
          android:parentActivityName="string" 
          android:persistableMode=["persistRootOnly" | 
                                   "persistAcrossReboots" | "persistNever"]
          android:permission="string"
          android:process="string"
          android:relinquishTaskIdentity=["true" | "false"]
          android:requireContentUriPermissionFromCaller=["none" | "read" | "readAndWrite" |
                                                         "readOrWrite" | "write"] 
          android:resizeableActivity=["true" | "false"]
          android:screenOrientation=["unspecified" | "behind" |
                                     "landscape" | "portrait" |
                                     "reverseLandscape" | "reversePortrait" |
                                     "sensorLandscape" | "sensorPortrait" |
                                     "userLandscape" | "userPortrait" |
                                     "sensor" | "fullSensor" | "nosensor" |
                                     "user" | "fullUser" | "locked"]
          android:showForAllUsers=["true" | "false"]
          android:stateNotNeeded=["true" | "false"]
          android:supportsPictureInPicture=["true" | "false"]
          android:taskAffinity="string"
          android:theme="resource or theme"
          android:uiOptions=["none" | "splitActionBarWhenNarrow"]
          android:windowSoftInputMode=["stateUnspecified",
                                       "stateUnchanged", "stateHidden",
                                       "stateAlwaysHidden", "stateVisible",
                                       "stateAlwaysVisible", "adjustUnspecified",
                                       "adjustResize", "adjustPan"] >   
    ...
</activity>

contido em:

<application>

pode conter:

<intent-filter>
<meta-data>
<layout>

descrição:

Declara uma atividade (uma subclasse Activity) que implementa parte da IU visual do aplicativo. Todas as atividades precisam ser representadas por elementos <activity> no arquivo de manifesto. Aquelas que não forem declaradas não serão vistas pelo sistema e não serão executadas.

atributos:

android:allowEmbedded

Indica que a atividade pode ser iniciada como um elemento filho incorporado de outro atividade, especialmente no caso em que a criança mora em um contêiner, como um Display de outra atividade. Por exemplo, atividades usadas em notificações personalizadas do Wear fazem essa declaração para que o Wear possa mostrar a atividade no stream do contexto dela, que reside em outro processo.

O valor padrão desse atributo é false.

android:allowTaskReparenting

Define se a atividade pode ser movida da tarefa que a iniciou para a tarefa com que tem afinidade na próxima vez que ela for trazida para o primeiro plano. O valor será "true" se ela puder ser movida, e "false" se ela permanecer com a tarefa em que foi iniciada.

Se esse atributo não for definido, o valor definido pelo atributo allowTaskReparenting correspondente do elemento <application> será aplicado à atividade. O valor padrão é "false".

Normalmente, quando uma atividade é iniciada, ela é associada à tarefa da atividade que a iniciou e permanece nessa tarefa por todo o ciclo de vida. Você pode usar esse atributo para forçar a atividade a assumir como elemento pai a tarefa com que a atividade vai passar a ter afinidade quando a tarefa atual deixar de ser exibida. Normalmente, esse recurso é usado para fazer com que as atividades de um aplicativo sejam movidas para a tarefa principal associada ao aplicativo.

Por exemplo: se uma mensagem de e-mail tiver um link para uma página da Web, um clique nesse link acionará uma atividade que pode mostrar a página. Essa atividade é definida pelo aplicativo do navegador, mas é iniciada como parte da tarefa do e-mail. Se a atividade assumir a tarefa do navegador como novo elemento pai, ela será mostrada na próxima vez que o navegador vier para o primeiro plano, mas não aparecerá quando a tarefa do e-mail voltar ao primeiro plano.

A afinidade de uma atividade é definida pelo atributo taskAffinity. A afinidade de uma tarefa é determinada pela afinidade da atividade raiz. Portanto, por definição, uma atividade raiz está sempre em uma tarefa com a mesma afinidade. Como as atividades com modos de inicialização "singleTask" ou "singleInstance" podem estar somente na raiz de uma tarefa, a ação de assumir um novo pai está limitada aos modos "standard" e "singleTop". Consulte também o atributo launchMode.

android:alwaysRetainTaskState

Define se o estado da tarefa em que a atividade está será sempre mantido pelo sistema. Será "true" se esse for o caso, e "false" se o sistema puder redefinir a tarefa para o estado inicial em determinadas situações. O valor padrão é "false". Esse atributo é significativo somente para a atividade raiz de uma tarefa. Ele é ignorado para todas as outras atividades.

Normalmente, o sistema limpa uma tarefa, removendo todas as atividades da pilha acima da atividade raiz, em determinadas situações quando o usuário seleciona novamente essa tarefa na tela inicial. Geralmente, isso é feito se o usuário não acessar a tarefa por um tempo determinado, como 30 minutos.

No entanto, quando o atributo for "true", os usuários sempre retornarão à tarefa no último estado dela, independente de como chegarem lá. Isso é útil em um aplicativo como um navegador da Web, em que há muitas informações de estado, como várias guias abertas, que os usuários não querem perder.

android:autoRemoveFromRecents

Define se as tarefas iniciadas pela atividade com esse atributo permanecem na tela Recentes até que a última atividade da tarefa seja concluída. Se definido como true, a tarefa é automaticamente removida da tela Recentes. Isso substitui o uso de FLAG_ACTIVITY_RETAIN_IN_RECENTS pelo autor da chamada. O valor precisa ser booleano, "true" ou "false".

android:banner

Um recurso drawable fornecendo um banner gráfico estendido para o item associado. Use com a tag <activity> a fim de fornecer um banner padrão a uma atividade específica ou com a tag <application> para fornecer um banner a todas as atividades do aplicativo.

O sistema usa o banner para representar um app na tela inicial do Android TV. Como o banner é exibido apenas na tela inicial, ele só é especificado por aplicativos com uma atividade que processe a intent CATEGORY_LEANBACK_LAUNCHER.

Esse atributo é definido como uma referência a um recurso drawable que contém a imagem, como "@drawable/banner". Não há nenhum banner padrão.

Para saber mais, consulte Oferecer um banner de tela inicial em "Introdução a apps para TV".

android:canDisplayOnRemoteDevices

Indica se a atividade pode ser exibida em um dispositivo remoto que pode ou não usar o Android. Precisa ser um valor booleano, ou "true" ou "false".

O valor padrão desse atributo é "true".

android:clearTaskOnLaunch

Define se todas as atividades são removidas da tarefa, exceto a atividade raiz, quando ela é reiniciada na tela inicial. Será "true" se a tarefa for sempre reduzida à atividade raiz dela, e "false" se não for. O valor padrão é "false". Esse atributo é significativo apenas para atividades que iniciam uma nova tarefa (a atividade raiz). Ele é ignorado para todas as outras atividades na tarefa.

Quando o valor for "true", sempre que o usuário reiniciar a tarefa ele vai ser levado à atividade raiz, independente do que estava fazendo na tarefa anterior e de ter usado o botão Voltar ou home para sair dela. Quando o valor for "false", será possível remover as atividades da tarefa em algumas situações, mas não sempre. Para saber mais, consulte o atributo alwaysRetainTaskState.

Suponha que o usuário inicie a atividade P na tela inicial e, de dentro dela, vá para a atividade Q. Em seguida, o usuário toca no botão home e retorna à atividade P. Normalmente, o usuário encontraria a atividade Q, que era o que ele estava fazendo pela última vez na tarefa P. No entanto, se P definir essa flag como "true", todas as atividades acima dela (Q, neste caso) serão removidas quando o usuário iniciar a atividade P na tela inicial. Portanto, o usuário encontrará somente P quando voltar à tarefa.

Se esse atributo e allowTaskReparenting forem "true", todas as atividades que puderem ter um novo elemento pai serão movidas para a tarefa com que compartilham uma afinidade. As demais atividades serão descartadas.

Esse atributo é ignorado quando FLAG_ACTIVITY_RESET_TASK_IF_NEEDED não está definido.

android:colorMode

Especifica o modo de cor da atividade. Se especificado, pode ser hdr ou wideColorGamut.

No caso de hdr, é solicitado que a atividade seja mostrada em um High Dynamic Range caso o dispositivo tenha suporte a essa tecnologia.

Observação: por motivos de desempenho, não recomendamos ativar o HDR no manifesto. Em vez disso, se o app estiver mostrando imagens em HDR, chame setColorMode() para mudar a atividade dinamicamente para o modo HDR no momento da execução. Para mais informações, consulte Mostrar imagens em Ultra HDR.

No caso de wideColorGamut, é solicitado que a atividade seja mostrada no modo de gama ampla de cores em dispositivos compatíveis. Nesse modo, uma janela pode renderizar fora da gama SRGB para mostrar cores mais vibrantes. Se o dispositivo não tiver suporte ao modo de gama ampla de cores, o atributo não terá efeito. Para saber mais sobre renderização em modo de gama ampla de cores, consulte Aprimorar gráficos com amplo conteúdo de cores.

android:configChanges

Lista as mudanças de configuração processadas pela própria atividade. Quando ocorre uma mudança de configuração durante a execução, a atividade é desativada e reiniciada por padrão. No entanto, a declaração de uma configuração com esse atributo evita que a atividade seja reiniciada. Em vez disso, a atividade permanece em execução, e o método onConfigurationChanged() dela é chamado.

Observação: use esse atributo apenas em casos especiais para melhorar o desempenho e a capacidade de resposta do aplicativo. Para mais informações, consulte Gerenciar mudanças de configuração.

As strings a seguir são valores válidos para esse atributo. Vários valores são separados por |, como "locale|navigation|orientation".

Valor	Descrição
"colorMode"	Os recursos do modo de cor da tela (gama de cores ou intervalo dinâmico) mudaram. Observação:o modo de cor solicitado pela atividade com o atributo colorMode ou durante a execução é diferente do recurso para diferentes modos de cor. Uma atividade que muda o modo de cor usada não causa uma mudança na configuração, porque os recursos de cor da tela não mudaram.
"density"	Uma mudança na densidade da tela, como quando o usuário especifica uma escala de exibição diferente ou quando outra exibição está ativa. Adicionado no nível 24 da API.
"fontScale"	Uma mudança no fator de escalonamento da fonte, como quando o usuário seleciona um novo tamanho global de fonte.
"fontWeightAdjustment"	A quantidade de aumento de espessura da fonte mudou.
"grammaticalGender"	O gênero gramatical do idioma mudou. Consulte GrammaticalInflectionManager. Adicionado no nível 34 da API.
"keyboard"	Uma mudança no tipo de teclado, como quando o usuário conecta um teclado externo.
"keyboardHidden"	Uma mudança na acessibilidade do teclado, como quando o usuário revela o teclado de hardware.
"layoutDirection"	Uma mudança na direção do layout, como da esquerda para a direita (LTR) para a direita para a esquerda (RTL). Adicionado no nível 17 da API.
"locale"	Uma mudança na localidade, como quando o usuário seleciona um novo idioma para o texto.
"mcc"	Uma mudança no código de país para dispositivos móveis (MCC) IMSI quando é detectado um chip que atualiza o MCC.
"mnc"	Uma mudança no código de rede móvel (MNC) IMSI quando é detectado um chip que atualiza o MNC.
"navigation"	Uma mudança no tipo de navegação (trackball ou botão direcional). Normalmente, isso não acontece.
"orientation"	Uma mudança na orientação da tela, como quando o usuário gira o dispositivo. Observação: se o aplicativo for destinado ao Android 3.2 (nível 13 da API) ou mais recente, declare também as configurações "screenLayout" e "screenSize", porque o layout e o tamanho da tela podem mudar quando um dispositivo alterna entre as orientações de retrato e paisagem.
"screenLayout"	Uma mudança no layout da tela, como quando uma tela diferente fica ativa.
"screenSize"	Uma mudança no tamanho da tela atual disponível. Isso representa uma mudança no tamanho disponível em relação à proporção atual, que muda quando o usuário alterna entre as orientações de paisagem e retrato. Adicionado no nível 13 da API.
"smallestScreenSize"	Uma mudança no tamanho físico da tela. Isso representa uma mudança de tamanho, independente da orientação. Portanto, essa mudança ocorre somente quando o tamanho físico da tela muda, como ao alternar para uma tela externa. Uma mudança nessa configuração corresponde a uma mudança na configuração smallestWidth. Adicionado no nível 13 da API.
"touchscreen"	Uma mudança na tela touchscreen. Normalmente, isso não acontece.
"uiMode"	Uma mudança no modo de interface do usuário, como quando o usuário coloca o dispositivo em uma base para carro ou mesa, ou então quando o modo noturno é modificado. Para mais informações sobre os diferentes modos de interface, consulte UiModeManager. Adicionado no nível 8 da API.

Todas essas mudanças de configuração podem afetar os valores de recurso visíveis ao aplicativo. Portanto, quando onConfigurationChanged() é chamado, geralmente é necessário extrair novamente todos os recursos, incluindo layouts de visualização e drawables, para que a mudança seja processada corretamente.

Observação: para processar todas as mudanças na configuração relacionadas ao Modo de várias janelas, use "screenLayout" e "smallestScreenSize". O modo de várias janelas tem suporte no Android 7.0 (nível 24 da API) e versões mais recentes.

android:directBootAware

Define se a atividade tem reconhecimento de inicialização direta, ou seja, se ela pode ser executada antes de o usuário desbloquear o dispositivo.

Observação: durante a Inicialização direta, uma atividade no aplicativo só pode acessar os dados no armazenamento protegido do dispositivo.

O valor padrão é "false".

android:documentLaunchMode

Especifica como a nova instância de uma atividade precisa ser adicionada a uma tarefa sempre que ela é inicializada. Esse atributo deixa o usuário conferir vários documentos do mesmo aplicativo na tela Recentes.

Esse atributo tem quatro valores que produzem os efeitos abaixo quando o usuário abre um documento com o aplicativo:

Valor	Descrição
"intoExisting"	O sistema procura uma tarefa que tenha um ComponentName e um URI de dados da intent base que correspondam aos da intent de inicialização. Se o sistema encontra essa tarefa, ele a limpa e reinicia com a atividade raiz que recebe uma chamada para onNewIntent(android.content.Intent). Se o sistema não encontrar a tarefa, uma nova será criada.
"always"	A atividade cria uma nova tarefa para o documento, mesmo se ele já estiver aberto. Isso é o mesmo que configurar as sinalizações FLAG_ACTIVITY_NEW_DOCUMENT e FLAG_ACTIVITY_MULTIPLE_TASK.
"none"	A atividade não cria nenhuma tarefa nova para a atividade. Esse é o valor padrão. Ele cria uma tarefa nova somente quando o atributo FLAG_ACTIVITY_NEW_TASK estiver definido. A tela Recentes trata a atividade como faria por padrão: ela exibe uma única tarefa para o app, que é retomada de qualquer atividade que o usuário invocou pela última vez.
"never"	Essa atividade não é inicializada em um novo documento, mesmo quando a intent contém FLAG_ACTIVITY_NEW_DOCUMENT. A definição desse atributo modificará o comportamento das flags FLAG_ACTIVITY_NEW_DOCUMENT e FLAG_ACTIVITY_MULTIPLE_TASK se uma delas estiver definida na atividade. A tela Recentes vai exibir uma única tarefa para o app, que retomará a atividade invocada mais recentemente pelo usuário.

Observação: para valores diferentes de "none" e "never", a atividade precisa ser definida com launchMode="standard". Se esse atributo não for especificado, documentLaunchMode="none" será usado.

android:enabled

Define se a atividade pode ser instanciada pelo sistema. Será "true" se isso for possível, e "false" se não for. O valor padrão é "true".

O elemento <application> tem o próprio atributo enabled que se aplica a todos os componentes do aplicativo, incluindo as atividades. Os atributos <application> e <activity> precisam ser "true", como são por padrão, para que o sistema possa instanciar a atividade. Se algum deles for "false", não será possível fazer o instanciamento.

android:enableOnBackInvokedCallback

Essa flag permite ativar animações preditivas do sistema no nível da atividade. Esse comportamento facilita a migração de apps grandes com várias atividades para gestos de volta preditivos.

Configurar android:enableOnBackInvokedCallback=false desativa as animações de volta preditiva no nível da atividade ou do app, dependendo de onde a tag foi definida. Além disso, o sistema é instruído a ignorar chamadas para a API OnBackInvokedCallback da plataforma.

android:excludeFromRecents

Se a tarefa iniciada por esta atividade é excluída do Tela "Recentes". Ou seja, quando essa atividade for a atividade raiz de uma nova tarefa, esse atributo determinará se a tarefa aparecerá ou não na lista de apps recentes. Está "true" se a tarefa for excluída da lista. "false" se está incluído. O valor padrão é "false".

android:exported

Se a atividade pode ser iniciada por componentes de outros aplicativos:

• Se for "true", a atividade poderá ser acessada por qualquer app e iniciada pelo nome exato da classe.
• Se definido como "false", a atividade só poderá ser iniciada por componentes do mesmo aplicativo ou com o mesmo ID do usuário ou componentes de sistema privilegiados. Esse é o valor padrão, quando não há filtros de intent.

Se uma atividade no app incluir filtros de intent, defina esse elemento como "true" para permitir que outros apps a iniciem. Por exemplo, se a atividade for a principal do app e incluir o category android.intent.category.LAUNCHER.

Se esse elemento for definido como "false" e um app tentar iniciar a atividade, o sistema vai gerar uma ActivityNotFoundException.

Esse atributo não é a única forma de limitar a exposição de uma atividade a outros aplicativos. Também é possível usar permissões para limitar as entidades externas que podem invocar a atividade. Consulte o atributo permission.

android:finishOnTaskLaunch

Define se uma instância existente da atividade é encerrada, exceto no caso da atividade raiz, quando o usuário reinicia a tarefa escolhendo-a na tela inicial. Será "true" se for encerrada, e "false" se não for. O valor padrão é "false".

Se esse atributo e allowTaskReparenting forem "true", ele prevalecerá sobre o outro. A afinidade da atividade é ignorada. A atividade não tem um novo pai, mas é destruída.

Esse atributo é ignorado quando FLAG_ACTIVITY_RESET_TASK_IF_NEEDED não está definido.

android:hardwareAccelerated

Define se a renderização acelerada por hardware é ativada para essa atividade. Será "true" se for ativada, e "false" se não for. O valor padrão é "false".

No Android 3.0 e mais recentes, há um renderizador de OpenGL acelerado por hardware disponível aos aplicativos para melhorar o desempenho de várias operações comuns de gráficos 2D. Quando o renderizador acelerado por hardware estiver ativado, a maioria das operações em Canvas, Paint, Xfermode, ColorFilter, Shader e Camera serão aceleradas.

Isso resulta em animações mais suaves, rolagem mais uniforme e melhor responsividade geral, mesmo para aplicativos que não fazem uso explícito das bibliotecas OpenGL do framework. Devido ao aumento dos recursos necessários para ativar a aceleração de hardware, o app consome mais memória RAM.

Nem todas as operações 2D do OpenGL são aceleradas. Se você ativar o renderizador acelerado por hardware, teste o aplicativo para garantir que ele possa usar o renderizador sem erros.

android:icon

Ícone que representa a atividade. O ícone é exibido aos usuários quando for necessário representar a atividade na tela. Por exemplo, ícones para atividades que iniciam tarefas são exibidos na janela da tela de início. O ícone é frequentemente acompanhado por um rótulo; Para informações sobre o rótulo, consulte o atributo android:label.

Esse atributo é definido como uma referência a um recurso drawable que contém a definição da imagem. Se ele não for definido, o ícone especificado para o aplicativo como um todo será usado. Para saber mais, consulte o atributo icon do elemento <application>.

O ícone da atividade, definido aqui ou pelo elemento <application>, é também o ícone padrão para todos os filtros de intent da atividade. Para saber mais, consulte o atributo icon do elemento <intent-filter>.

android:immersive

Define a configuração de modo imersivo para a atividade atual. Se for "true", o membro ActivityInfo.flags sempre terá a própria O conjunto de bits FLAG_IMMERSIVE, mesmo se o mudanças do modo imersivo durante a execução usando o método setImmersive().

android:label

É um rótulo legível pelo usuário para a atividade. O rótulo é exibido na tela quando a atividade é representada para o usuário. Muitas vezes, é exibido com o ícone de atividade. Se este atributo não for definido, o rótulo definido para o aplicativo como um todo será é usado no lugar dele. veja a propriedade do elemento <application> label.

O rótulo da atividade, definido aqui ou pelo elemento <application>, é também o rótulo padrão para todos os filtros de intents da atividade. Para saber mais, consulte o atributo label do elemento <intent-filter>.

O rótulo é definido como referência a um recurso de string para que possa ser localizado como outras strings da interface do usuário. No entanto, para facilitar o desenvolvimento do aplicativo, ele também pode ser definido como uma string bruta.

android:launchMode

Uma instrução de como a atividade é iniciada. Há cinco modos, que funcionam em conjunto com flags de atividade (constantes FLAG_ACTIVITY_*). em objetos Intent para determinar o que acontece quando a atividade é chamada para processar uma intent:

"standard"
"singleTop"
"singleTask"
"singleInstance"
"singleInstancePerTask"

O modo padrão é "standard".

Como mostrado na tabela a seguir, os modos se enquadram em dois grupos principais, com atividades "standard" e "singleTop" de um lado e atividades "singleTask", "singleInstance" e "singleInstancePerTask" do outro. Atividades com o modo de inicialização "standard" ou "singleTop" podem ser instanciadas várias vezes.

As instâncias podem pertencer a qualquer tarefa e podem estar localizadas em qualquer lugar na tarefa da atividade. Normalmente, elas são inicializadas na tarefa que chama o método startActivity(), a menos que o objeto da Intent contenha uma instrução FLAG_ACTIVITY_NEW_TASK. Nesse caso, uma tarefa diferente é escolhida. Para saber mais, consulte o atributo taskAffinity.

Por outro lado, as atividades "singleTask", "singleInstance" e "singleInstancePerTask" têm comportamentos diferentes. "singleInstancePerTask" está sempre na raiz da tarefa da atividade. Além disso, o dispositivo pode conter apenas uma instância da atividade "singleInstance" por vez, enquanto a atividade "singleInstancePerTask pode ser instanciada várias vezes em tarefas diferentes quando as instruções FLAG_ACTIVITY_MULTIPLE_TASK ou FLAG_ACTIVITY_NEW_DOCUMENT são configuradas.

Uma atividade com o modo de inicialização "singleTask" combina os comportamentos de "singleInstance" e "singleInstancePerTask". Ela pode ser instanciada várias vezes e estar localizada em qualquer tarefa de uma mesma taskAffinity. No entanto, o dispositivo pode conter apenas uma tarefa para localizar a atividade "singleTask" na raiz da tarefa da atividade.

Os modos "standard" e "singleTop" diferem entre si em um aspecto: sempre que há uma nova intent para uma atividade "standard", uma nova instância da classe é criada para responder a essa intent. Cada instância processa uma única intent. Da mesma forma, também é possível criar uma nova instância de uma atividade "singleTop" para processar uma nova intent.

No entanto, se a tarefa de destino já tiver uma instância da atividade no topo da pilha, essa instância vai receber a nova intent em uma chamada onNewIntent(). Uma nova instância não será criada. Caso contrário, se uma instância da atividade "singleTop" estiver na tarefa de destino, mas não no topo da pilha, ou se ela estiver na parte de cima de uma pilha, mas não na tarefa de destino, uma nova instância será criada e enviada na pilha.

Da mesma forma, se o usuário navegar para cima até uma atividade na pilha atual, o comportamento será determinado pelo modo de inicialização da atividade pai. Se a atividade mãe tiver o modo de inicialização singleTop (ou a intent up contiver FLAG_ACTIVITY_CLEAR_TOP), a atividade mãe será levada ao topo da pilha e o estado vai ser preservado.

A intent de navegação é recebida pelo método onNewIntent() da atividade pai. Se a atividade mãe tiver o modo de inicialização standard e a intent up não contiver FLAG_ACTIVITY_CLEAR_TOP, a atividade atual e a mãe serão retiradas da pilha e uma nova instância da atividade mãe será criada para receber a intent de navegação.

O modo "singleInstance" também difere de "singleTask" e "singleInstancePerTask" em apenas um aspecto: uma atividade com o modo de inicialização "singleTask" ou "singleInstancePerTask" permite que outras atividades "standard" e "singleTop" façam parte da tarefa.

Por outro lado, atividades "singleInstance" não permitem nenhuma outra atividade como parte da tarefa. Elas precisam ser a única atividade na tarefa. Se outra atividade for iniciada, ela será atribuída a uma tarefa diferente, como se FLAG_ACTIVITY_NEW_TASK estivesse na intent.

Casos de uso	Modo de inicialização	Várias instâncias?	Comentários
Inicializações normais para a maioria das atividades	"standard"	Sim	Padrão. O sistema sempre cria uma nova instância da atividade na tarefa de destino e encaminha a intent a ela.
	"singleTop"	Condicionalmente	Se uma instância da atividade já existir no topo da tarefa de destino, o sistema vai encaminhar a intent à instância com uma chamada ao método onNewIntent() em vez de criar uma nova instância da atividade.
Inicializações especializadas (não recomendadas para uso geral)	"singleTask"	Condicionalmente	O sistema recria a atividade na raiz de uma nova tarefa ou localiza a atividade em uma tarefa existente com a mesma afinidade. Se uma instância da atividade já existir e estiver na raiz da tarefa, o sistema vai encaminhar a intent à instância atual com uma chamada para o método onNewIntent(), em vez de criar uma nova.
	"singleInstance"	Não	Funciona da mesma forma que "singleTask", exceto pelo fato do sistema não iniciar nenhuma outra atividade na tarefa que contém a instância. A atividade é sempre o único membro da tarefa.
	"singleInstancePerTask"	Condicionalmente	A atividade só pode ser executada como a atividade raiz da tarefa, a primeira que a criou. Portanto, haverá apenas uma instância dessa atividade em uma tarefa, ainda que ela possa ser instanciada várias vezes em tarefas diferentes.

Conforme mostrado na tabela anterior, "standard" é o modo padrão e é adequado para a maioria dos tipos de atividade. O "singleTop" também é um modo de inicialização comum e útil para vários tipos de atividades. Os outros modos, "singleTask", "singleInstance" e "singleInstancePerTask", não são adequados para a maioria dos aplicativos, Eles resultam em um modelo de interação que provavelmente não é muito conhecido pelos usuários, além de bem diferente da maioria dos outros aplicativos.

Independentemente do modo de inicialização escolhido, teste a usabilidade da atividade durante a inicialização e ao navegar de volta a ela outras atividades e tarefas usando o botão Voltar.

Para saber mais sobre os modos de inicialização e a interação deles com flags de Intent, consulte Tarefas e a backstack.

android:lockTaskMode

Determina como o sistema apresenta essa atividade durante a execução do dispositivo em modo de bloqueio de tarefas.

O Android pode executar tarefas de maneira imersiva, semelhante à forma de quiosque, com o modo de bloqueio de tarefas. Quando o sistema é executado no modo de bloqueio de atividade, os usuários do dispositivo normalmente não recebem notificações, acessam apps não permitidos ou voltar para a tela inicial, a menos que ele esteja na lista de permissões.

Somente apps na lista de permissões do controlador de políticas de dispositivo (DPC) podem ser executados quando o sistema está no modo de bloqueio de tarefas. No entanto, o sistema e os aplicativos privilegiados podem ser executados nesse modo, mesmo sem estar na lista de permissões.

O valor pode ser qualquer uma das strings R.attr.lockTaskMode abaixo:

Valor	Descrição
"normal"	Valor padrão. Esse é o valor padrão. As tarefas não são inicializadas no modo de bloqueio de atividade, mas podem ser usadas nele chamando o método startLockTask().
"never"	As tarefas não são inicializadas no modo lockTask, e os usuários do dispositivo não podem fixar essas tarefas quando estão na tela Recentes. Observação: esse modo só está disponível para o sistema e aplicativos privilegiados. Aplicativos não privilegiados com esse valor são tratados como normal.
"if_whitelisted"	Se o DCP autorizar esse pacote usando DevicePolicyManager.setLockTaskPackages(), esse modo vai ser idêntico a always, exceto pelo fato de a atividade precisar chamar stopLockTask() antes de ser concluída, caso essa seja a última tarefa bloqueada. Se o DPC não autorizar esse pacote, o modo será idêntico a normal.
"always"	Tarefas com acesso root nessa atividade sempre são iniciadas no modo de bloqueio de tarefas. Se o sistema já estiver nesse modo durante a inicialização da tarefa, a nova tarefa será inicializada em cima da tarefa atual. Ao chamar finish(), as tarefas iniciadas nesse modo podem sair do modo de bloqueio de tarefas. Observação: esse modo só está disponível para o sistema e aplicativos privilegiados. Aplicativos não privilegiados com esse valor são tratados como normal.

Esse atributo foi introduzido no nível 23 da API.

android:maxRecents

É o número máximo de tarefas que podem ter essa atividade como raiz na tela Recentes. Quando esse número de entradas for alcançado, o sistema vai remover a instância mais antiga da tela Recentes. Os valores válidos são números inteiros de 1 a 50, ou de 1 a 25 em dispositivos com pouca memória. Zero é inválido. O valor padrão é 16.

android:maxAspectRatio

É a proporção máxima com suporte da atividade. Se o aplicativo for executado em um dispositivo com proporção mais larga, o sistema vai colocar o app em uma caixa de texto automaticamente, deixando de usar partes da tela para que o app possa ser executado com a proporção máxima especificada.

A proporção máxima é mostrada como a forma decimal do quociente da maior dimensão do dispositivo dividida pela menor dimensão. Por exemplo, se a proporção máxima for de 7:3, defina o valor desse atributo como 2.33.

Em dispositivos que não são wearables, o valor desse atributo precisa ser de 1.33 ou maior. Em dispositivos wearable, precisa ser 1.0 ou maior. Caso contrário, o valor definido vai ser ignorado pelo sistema.

Observação: esse atributo é ignorado se a atividade tiver definido resizeableActivity como "true", porque isso significa que a atividade oferece suporte a todos os tamanhos.

Para saber mais sobre esse atributo, consulte Declarar uma proporção máxima.

android:multiprocess

Define se uma instância da atividade pode ou não ser aberta no processo do componente que a iniciou: "true" se puder e "false" se não puder. O valor padrão é "false".

Normalmente, uma nova instância de uma atividade é iniciada no processo do aplicativo que a definiu. Assim, todas as instâncias da atividade são executadas no mesmo processo. No entanto, se essa flag for definida como "true", será possível executar instâncias da atividade em vários processos, permitindo ao sistema criar instâncias sempre que elas forem usadas (desde que haja permissão), algo que quase nunca é necessário ou desejável.

android:name

É o nome da classe que implementa a atividade, uma subclasse de Activity. Normalmente, o valor do atributo é um nome de classe totalmente qualificado, como "com.example.project.ExtracurricularActivity". No entanto, se o primeiro caractere do nome for um ponto (como ".ExtracurricularActivity"), ele será anexado ao namespace especificado no arquivo build.gradle como forma de abreviação.

Depois de publicar o aplicativo, não mude esse nome (link em inglês), a menos que você defina android:exported="false". Não há padrão. O nome precisa ser especificado.

android:noHistory

Define se a atividade é removida da pilha de atividades e concluída (chamando o método finish()) quando o usuário sai dela e ela não fica mais visível na tela. Será "true" se for concluída, e "false" se não for. O valor padrão é "false".

O valor "true" significa que a atividade não sai de um rastro histórico. Como ela não é mantida na pilha de atividades da tarefa, o usuário não pode retornar a ela. Nesse caso, o método onActivityResult() nunca será chamado se você iniciar outra atividade para o resultado dessa atividade.

Esse atributo foi introduzido no nível 3 da API.

android:parentActivityName

É o nome da classe do pai lógico da atividade. Esse nome precisa corresponder ao nome informado ao atributo android:name do elemento <activity>.

O sistema lê esse atributo para determinar qual atividade será iniciada quando o usuário tocar no botão "para cima" na barra de ações. O sistema também pode usar essas informações para sintetizar uma backstack de atividades com TaskStackBuilder.

Para oferecer suporte aos níveis 4 a 16 da API, também é possível declarar a atividade mãe usando um elemento <meta-data> que especifica um valor para "android.support.PARENT_ACTIVITY":

<activity
    android:name="com.example.app.ChildActivity"
    android:label="@string/title_child_activity"
    android:parentActivityName="com.example.app.MainActivity" >
    <!-- Parent activity meta-data to support API level 4+ -->
    <meta-data
        android:name="android.support.PARENT_ACTIVITY"
        android:value="com.example.app.MainActivity" />
</activity>

Para ver mais informações sobre como declarar atividades mãe para oferecer suporte à navegação para cima, leia este artigo.

Esse atributo foi introduzido no nível 16 da API.

android:persistableMode

Define como a instância de uma atividade é mantida dentro da tarefa que a contém entre reinicializações do dispositivo.

Se a atividade raiz de uma tarefa definir o valor desse atributo como persistRootOnly, somente a atividade raiz vai ser preservada. Caso contrário, as atividades mais altas na backstack da tarefa vão ser examinadas. Todas as atividades que tiverem definido o valor desse atributo como persistAcrossReboots vão ser preservadas.

Se você usar esse atributo, o valor definido precisa ser um destes:

Valor	Descrição
persistRootOnly	Valor padrão. Quando o sistema é reiniciado, a tarefa da atividade é preservada, mas somente a intent de inicialização da atividade raiz é usada. Quando a intent de inicialização do app carrega a atividade raiz dele, essa atividade não recebe um objeto PersistableBundle. Portanto, não use onSaveInstanceState() para preservar o estado da atividade raiz do app em uma reinicialização do dispositivo. Observação: esse valor de atributo afeta o comportamento do app somente se ele estiver definido na atividade raiz do app.
persistAcrossReboots	O estado dessa atividade é preservado, com o estado de cada atividade mais alta na backstack que tem o próprio atributo persistableMode definido como persistAcrossReboots. Se uma atividade não tiver um atributo persistableMode definido como persistAcrossReboots, ou se tiver sido inicializada usando a sinalização Intent.FLAG_ACTIVITY_NEW_DOCUMENT, ela, junto de todas as atividades mais altas na backstack, não vai ser preservada. Quando a intent carrega uma atividade que tenha o atributo persistableMode definido como persistAcrossReboots no app, a atividade recebe um objeto PersistableBundle no método onCreate(). Portanto, você pode usar onSaveInstanceState() para preservar o estado de uma atividade na reinicialização do dispositivo, desde que o atributo persistableMode esteja definido como persistAcrossReboots. Observação: esse valor de atributo afeta o comportamento do app, mesmo que ele esteja definido em uma atividade diferente da atividade raiz do app.
persistNever	O estado da atividade não é preservado. Observação: esse valor de atributo afeta o comportamento do app somente se ele estiver definido na atividade raiz do app.

Esse atributo foi introduzido no nível 21 da API.

android:permission

O nome de uma permissão necessária para que os clientes inicializem a atividade ou façam com que ela responda a uma intent. Se o autor da chamada de startActivity() ou startActivityForResult() não receber a permissão especificada, a intent dele não será entregue à atividade.

Se o atributo não for definido, a permissão definida pelo atributo permission do elemento <application> será aplicada à atividade. Se nenhum atributo for definido, nenhuma permissão vai proteger a atividade.

Para saber mais sobre permissões, consulte a seção Permissões na visão geral do manifesto do app e Dicas de segurança.

android:process

É o nome do processo em que a atividade é executada. Normalmente, todos os componentes de um aplicativo são executados com um nome de processo padrão criado para o aplicativo e não é necessário usar este atributo. No entanto, se necessário, você pode substituir o nome do processo padrão usando este atributo, o que permite distribuir os componentes do app em vários processos.

Se o nome atribuído a esse atributo começar com dois-pontos (:), um novo processo, particular ao aplicativo, será criado quando necessário, e a atividade será executada nesse processo.

Se o nome do processo começar com um caractere em letra minúscula, a atividade será executada em um processo global com esse nome, desde que tenha permissão. Isso permite que os componentes de diferentes aplicativos compartilhem um processo, reduzindo o uso de recursos.

O atributo process do elemento <application> pode definir um nome de processo padrão diferente para todos os componentes.

android:relinquishTaskIdentity

Se a atividade libera identificadores das tarefas para uma atividade acima dela no pilha de tarefas. Tarefas com atividade raiz que têm esse atributo definido como "true" substituem a base Intent com o valor da próxima atividade na tarefa.

Se a próxima atividade também tiver esse atributo definido como "true", ela vai liberar a Intent base em qualquer atividade iniciada na mesma tarefa. Isso continuará para cada atividade até chegar a uma com o atributo definido como "false". O valor padrão é "false".

A definição desse atributo como "true" também permite que a atividade use a ActivityManager.TaskDescription para mudar rótulos, cores e ícones na tela Recentes.

android:requireContentUriPermissionFromCaller

Especifica as permissões necessárias para iniciar essa atividade ao passar URIs de conteúdo. O valor padrão é none, o que significa que nenhuma são necessárias. Definir esse atributo restringe as atividades com base nas permissões do invocador. Se o invocador não tiver as permissões necessárias, o início da atividade será negado por uma SecurityException .

Observe que a aplicação funciona para URIs de conteúdo dentro Intent.getData(), Intent.EXTRA_STREAM, e Intent.getClipData().

Pode ser um valor de string, usando "\\;" para caracteres de escape, como '\\n' ou "\\uxxxx" para um caractere Unicode;

Precisa ser um dos valores constantes abaixo.

Constante	Valor	Descrição
none	0	Padrão, não são necessárias permissões específicas.
ler	1	Faz com que o invocador tenha acesso de leitura aos URIs de conteúdo transmitidos.
readAndWrite	4	Faz com que o invocador tenha acesso de leitura e gravação aos URIs de conteúdo transmitidos.
readOrWrite	3	Faz com que o invocador tenha acesso de leitura ou gravação aos URIs de conteúdo passados.
gravação	2	Faz com que o invocador tenha acesso de gravação aos URIs de conteúdo transmitidos.

android:resizeableActivity

Especifica se o app oferece suporte à exibição em várias janelas. É possível definir esse atributo no elemento <activity> ou <application>.

Se o atributo for definido como "true", o usuário poderá iniciar a atividade nos modos de tela dividida e formato livre. Se você definir o atributo como "false", o app não poderá ser testado nem otimizado para um ambiente de várias janelas. O sistema ainda pode colocar a atividade no modo de várias janelas com o modo de compatibilidade aplicado.

Definir esse atributo como "false" também não garante que não haverá outros apps no modo de várias janelas visíveis na tela (como o picture-in-picture) ou em outras telas. Portanto, a definição essa flag não fará com que o app tenha acesso exclusivo a recursos.

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".

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 um app pode ser redimensionado, não se ele oferece suporte ao modo de várias janelas. Se resizeableActivity="false", o app será colocado em modo de compatibilidade quando necessário para atender às dimensões de exibição.
• Telas pequenas (com menos de 600 dp): se a resizeableActivity="true" e a largura e altura mínimas da atividade estiverem dentro dos requisitos de várias janelas, o app oferecerá suporte a esse modo. Se resizeableActivity="false", o app não vai oferecer suporte ao modo de várias janelas, independente da largura e altura mínimas da atividade.

Observação: os fabricantes de dispositivos podem substituir o comportamento do nível 31 da API.

Esse atributo foi adicionado no nível 24 da API.

Observação: o valor da atividade raiz de uma tarefa é aplicado a todas as atividades extras iniciadas nela. Ou seja, se a atividade raiz de uma tarefa for redimensionável, o sistema vai tratar todas as outras atividades dela como redimensionáveis. Se a atividade raiz não for redimensionável, as outras atividades na tarefa não serão redimensionáveis.

android:screenOrientation

É a orientação solicitada da atividade.

Quando uma atividade preenche toda a tela, a orientação solicitada atua como uma sugestão para mude a orientação nessa tela para corresponder ao valor solicitado. Isso pode resultar em uma diferente da orientação física da tela no espaço, exigindo o usuário possa girar o dispositivo para continuar usando o aplicativo. No Android 12 (nível da API) 31) e versões mais recentes, os fabricantes podem configurar dispositivos individuais de tela (como a tela do tamanho de um tablet em um dispositivo dobrável) para ignorar essa sugestão e, em vez disso, forçam uma atividade a ter efeito letterbox na orientação preferida do usuário do dispositivo. Isso resulta na orientação da atividade correspondente à solicitada, sem que o usuário precise girar fisicamente o dispositivo.

No modo de várias janelas, a orientação solicitada não atua como uma sugestão para o orientação. Se a atividade for com efeito letterbox, o(a) solicitado orientação afeta o efeito letterbox aplicado à atividade.

O valor pode ser qualquer uma das strings abaixo:

"unspecified"	O valor padrão. O sistema escolhe a orientação. A política usada e, portanto, as escolhas feitas em contextos específicos podem ser diferentes entre dispositivos.
"behind"	Mantém a mesma orientação da atividade imediatamente abaixo na pilha de atividades.
"landscape"	É a orientação de paisagem (a tela é mais larga que alta).
"portrait"	É a orientação de retrato (a tela é mais alta que larga).
"reverseLandscape"	É a orientação de paisagem na direção oposta da paisagem normal. Adicionado no nível 9 da API.
"reversePortrait"	É a orientação de retrato na direção oposta do retrato normal. Adicionado no nível 9 da API.
"sensorLandscape"	É a orientação de paisagem, mas pode ser de paisagem normal ou invertida, dependendo do sensor do dispositivo. O sensor é usado mesmo se o usuário tiver bloqueado a rotação com base em sensor. Adicionado no nível 9 da API.
"sensorPortrait"	É a orientação de retrato, mas pode ser de retrato normal ou invertida, dependendo do sensor do dispositivo. O sensor é usado mesmo se o usuário tiver bloqueado a rotação com base em sensor. No entanto, dependendo da configuração do dispositivo, a rotação de cabeça para baixo pode não ser permitida. Adicionado no nível 9 da API.
"userLandscape"	É a orientação de paisagem, mas pode ser de paisagem normal ou invertida, dependendo do sensor do dispositivo e da preferência do usuário. Adicionado no nível 18 da API.
"userPortrait"	É a orientação de retrato, mas pode ser de retrato normal ou invertida, dependendo do sensor do dispositivo e da preferência do usuário. No entanto, dependendo da configuração do dispositivo, a rotação de cabeça para baixo pode não ser permitida. Adicionado no nível 18 da API.
"sensor"	O sensor de orientação do dispositivo determina a orientação. A orientação da tela depende da forma como o usuário segura o dispositivo. Ela muda quando o usuário gira o dispositivo. No entanto, por padrão, alguns dispositivos não giram em todas as quatro orientações possíveis. Para permitir as quatro orientações, use "fullSensor". O sensor será usado mesmo se o usuário tiver bloqueado a rotação com base em sensor.
"fullSensor"	O sensor de orientação do dispositivo determina a orientação para qualquer uma das quatro possibilidades. Isso é semelhante a "sensor", exceto por permitir qualquer uma das quatro orientações possíveis, independente do que o dispositivo costuma aceitar. Por exemplo, alguns dispositivos não costumam usar as orientações de paisagem ou retrato invertidas, mas essa definição as ativa. Adicionado no nível 9 da API.
"nosensor"	A orientação é determinada sem referência a nenhum sensor de orientação físico. O sensor é ignorado. Portanto, a tela não vai girar de acordo com a forma como o usuário move o dispositivo.
"user"	A orientação preferida atual do usuário.
"fullUser"	Se o usuário tiver bloqueado a rotação com base em sensor, o comportamento será o mesmo de user. Caso contrário, será o mesmo de fullSensor e permitirá qualquer uma das quatro orientações de tela possíveis. Adicionado no nível 18 da API.
"locked"	Bloqueia a orientação na rotação atual qualquer que seja. Adicionado no nível 18 da API.

Observação: ao declarar um dos valores de paisagem ou retrato, ele será considerado um requisito fixo para a orientação usada pela atividade. O valor declarado ativa o filtro por serviços, como Google Play, fazendo com que o aplicativo fique disponível somente para dispositivos com suporte à orientação exigida pelas atividades. Por exemplo: se você declarar "landscape", "reverseLandscape" ou "sensorLandscape", o aplicativo será disponibilizado somente aos dispositivos com suporte à orientação de paisagem.

Declare explicitamente também que o aplicativo exige orientação de retrato ou paisagem com o elemento <uses-feature>, como <uses-feature android:name="android.hardware.screen.portrait"/>. Esse comportamento é um filtro fornecido pelo Google Play e outros serviços com suporte a ele. A plataforma em si não controla se o app pode ou não ser instalado quando um dispositivo oferece suporte somente a algumas orientações.

android:showForAllUsers

Define se a atividade será exibida quando o usuário atual do dispositivo for diferente do que o usuário que iniciou a atividade. É possível definir esse atributo como um valor literal "true" ou "false". Também é possível definir o atributo como um recurso ou atributo de tema que contenha um valor booleano.

Esse atributo foi adicionado no nível 23 da API.

android:stateNotNeeded

Define se a atividade pode ser encerrada e reiniciada sem salvar o estado. O estado será "true" se ela puder ser reiniciada sem referência ao estado anterior, e "false" se o estado anterior for necessário. O valor padrão é "false".

Normalmente, antes que uma atividade seja desativada temporariamente para poupar recursos, o método onSaveInstanceState() é chamado. Esse método armazena o estado atual da atividade em um objeto Bundle, transmitido a onCreate() quando a atividade é reiniciada. Se este atributo for definido como "true", não será possível chamar onSaveInstanceState(), e onCreate() vai receber null em vez do Bundle, da mesma forma que no início da atividade pela primeira vez.

Uma configuração "true" significa que a atividade pode ser reiniciada sem o estado retido. Por exemplo, a atividade que exibe a tela inicial usa essa configuração para garantir que ela não será removida ao falhar por algum motivo.

android:supportsPictureInPicture

Especifica se a atividade oferece suporte à exibição picture-in-picture.

android:taskAffinity

É a tarefa com que a atividade tem afinidade. Atividades com a mesma afinidade pertencem conceitualmente à mesma tarefa, ao mesmo "aplicativo" do ponto de vista do usuário. A afinidade de uma tarefa é determinada pela afinidade da atividade raiz.

A afinidade determina duas coisas: a tarefa que a atividade assume como nova mãe (consulte o atributo allowTaskReparenting) e a tarefa que hospeda a atividade quando ela é inicializada com a flag FLAG_ACTIVITY_NEW_TASK.

Por padrão, todas as atividades de um aplicativo têm a mesma afinidade. É possível definir esse atributo para as agrupar de forma diferente e até mesmo colocar atividades definidas em aplicativos diferentes dentro da mesma tarefa. Para especificar que a atividade não tem afinidade com nenhuma tarefa, defina o atributo como uma string vazia.

Se o atributo não for definido, a atividade vai herdar a afinidade definida para o aplicativo. Consulte o atributo taskAffinity do elemento <application>. O nome da afinidade padrão de um aplicativo é o namespace definido no arquivo build.gradle.

android:theme

É uma referência a um recurso de estilo que define o tema geral da atividade. Isso configura automaticamente o contexto da atividade para usar esse theme e também pode "iniciar" animações antes que a atividade seja lançada para conseguir uma correspondência melhor com a aparência real da atividade.

Se esse atributo não for definido, a atividade vai herdar o tema especificado para o aplicativo como um todo do atributo theme do elemento <application>. Se esse atributo também não for definido, o tema do sistema padrão será usado. Para saber mais, consulte Estilos e temas.

android:uiOptions

Opções extras para a interface de uma atividade. Precisa ser um dos valores abaixo.

Valor	Descrição
"none"	Nenhuma opção extra de IU. Esse é o padrão.
"splitActionBarWhenNarrow"	Adiciona uma barra na parte de baixo da tela para mostrar ações necessárias na barra de apps, também conhecida como barra de ações, quando restrita ao espaço horizontal, como ao usar o modo retrato em um dispositivo. Em vez de um pequeno número de ações necessárias que aparecem na barra de apps na parte de cima da tela, a barra de apps é dividida na seção de navegação em cima e na barra abaixo para ações necessárias. Isso garante que uma quantidade razoável de espaço seja disponibilizada não apenas para as ações necessárias, mas também para navegação e elementos de título na parte de cima. Os itens de menu não são divididos entre as duas barras. Eles sempre aparecem juntos.

Para saber mais sobre a barra de apps, consulte Adicionar a barra de apps.

Esse atributo foi adicionado no nível 14 da API.

android:windowSoftInputMode

É a forma de interação da janela principal da atividade com a janela que contém o teclado de software na tela. A definição desse atributo afeta duas coisas:

• Se o teclado de software fica oculto ou visível quando a atividade se torna o foco da atenção do usuário.
• Se a janela principal da atividade é redimensionada com tamanho menor a fim de criar espaço para o teclado de software ou se o conteúdo se desloca para tornar visível o foco atual quando parte da janela é coberta pelo teclado de software.

A configuração precisa ser um dos valores listados na tabela a seguir ou uma combinação de um valor "state..." com um valor "adjust...". Definir vários valores em um dos grupos, como vários valores de "state...", tem resultados indefinidos. Valores individuais são separados por uma barra vertical (|), conforme mostrado no exemplo a seguir:

<activity android:windowSoftInputMode="stateVisible|adjustResize" ... >

Os valores diferentes de "stateUnspecified" e "adjustUnspecified" definidos aqui modificam os valores definidos no tema.

Valor	Descrição
"stateUnspecified"	Se o teclado de software fica oculto ou visível não é especificado. O sistema escolhe um estado adequado ou usa a configuração do tema. Essa é a configuração padrão para o comportamento do teclado de software.
"stateUnchanged"	O teclado de software é mantido no estado anterior, visível ou oculto, quando a atividade passa para o primeiro plano.
"stateHidden"	O teclado de software fica oculto quando o usuário escolhe a atividade, ou seja, quando o usuário navega afirmativamente para a atividade em vez de voltar a ela por deixar outra atividade.
"stateAlwaysHidden"	O teclado de software sempre fica oculto quando a janela principal da atividade tiver o foco de entrada.
"stateVisible"	O teclado de software fica visível quando o usuário escolhe a atividade, ou seja, quando o usuário navega afirmativamente para a atividade em vez de voltar a ela por deixar outra atividade.
"stateAlwaysVisible"	O teclado de software fica visível quando a janela recebe o foco de entrada.
"adjustUnspecified"	Não é especificado se a janela principal do aplicativo é redimensionada para criar espaço para o teclado de software ou se o conteúdo da janela é deslocado para o foco atual ficar visível na tela. O sistema seleciona automaticamente um desses modos, dependendo do conteúdo da janela ter visualizações de layout que podem rolar o conteúdo ou não. Se houver uma dessas visualizações, a janela será redimensionada com base na suposição de que a rolagem permite a visualização do conteúdo da janela em uma área menor. Essa é a configuração padrão para o comportamento da janela principal.
"adjustResize"	A janela principal da atividade é sempre redimensionada a fim de criar espaço para o teclado de software na tela.
"adjustPan"	A janela principal da atividade não é redimensionada para criar espaço para o teclado de software na tela. Em vez disso, o conteúdo da janela é deslocado automaticamente para que o foco atual nunca seja sobreposto pelo teclado e os usuários possam sempre ver o que digitam. Normalmente, esse comportamento é menos desejável que o redimensionamento, porque o usuário pode precisar fechar o teclado de software para acessar e interagir com as partes sobrepostas da janela.

Esse atributo foi introduzido no nível 3 da API.

introduzido em:

Nível 1 da API para todos os atributos, exceto noHistory e windowSoftInputMode, adicionados ao nível 3 da API.

confira também:

<application>
<activity-alias>