sintaxe:
<activity android:allowEmbedded=["true" | "false"]
          android:allowTaskReparenting=["true" | "false"]
          android:alwaysRetainTaskState=["true" | "false"]
          android:autoRemoveFromRecents=["true" | "false"]
          android:banner="drawable resource"
          android:clearTaskOnLaunch=["true" | "false"]
          android:colorMode=[ "hdr" | "wideColorGamut"]
          android:configChanges=["mcc", "mnc", "locale",
                                 "touchscreen", "keyboard", "keyboardHidden",
                                 "navigation", "screenLayout", "fontScale",
                                 "uiMode", "orientation", "density",
                                 "screenSize", "smallestScreenSize"]
          android:directBootAware=["true" | "false"]
          android:documentLaunchMode=["intoExisting" | "always" |
                                  "none" | "never"]
          android:enabled=["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: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 interface visual do usuário do aplicativo. Todas as atividades precisam ser representadas por elementos <activity> no arquivo de manifesto. Os serviços não declarados nesse arquivo não ficam visíveis ao sistema e nunca são executados.
atributos:
android:allowEmbedded
Indica que a atividade pode ser iniciada como um elemento filho incorporado de outra atividade. Especialmente no caso em que o elemento filho reside em um contêiner, como um Display de outra atividade. Por exemplo, atividades usadas em notificações personalizadas do Wear precisam fazer 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
Se a atividade puder ser movida da tarefa que a iniciou para a tarefa com que a atividade tem afinidade na próxima vez que ela for trazida para o primeiro plano: "true" se for possível mover a atividade e "false" se ela permanecer na tarefa em que foi iniciada.

Se este atributo não for definido, o valor definido pelo atributo allowTaskReparenting correspondente do elemento <application> vai 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 durante toda a vida útil dela. 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 mover as atividades de um aplicativo até a tarefa principal associada a ele.

Por exemplo: se uma mensagem de e-mail tiver um link para uma página da Web, um clique nesse link aciona 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, vai ser mostrada na próxima vez que o navegador vier para o primeiro plano e não vai 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 os 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
Se o estado da tarefa onde a atividade está sempre vai ser mantido pelo sistema ou não: "true" se for sempre mantido e "false" se o sistema pode redefinir a tarefa ao 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 (remove 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 vão retornar à tarefa no último estado dela, independente de como chegarem lá. Isso é útil, por exemplo, em um aplicativo como o navegador da Web, em que há muitas informações de estado (como várias guias abertas) que os usuários não gostariam de perder.

android:autoRemoveFromRecents
Se as tarefas iniciadas com esse atributo permanecem, ou não, na tela de visão geral até que a última atividade na tarefa seja concluída. Se definido como true, a tarefa é automaticamente removida da tela de visão geral. Isso substitui o uso de FLAG_ACTIVITY_RETAIN_IN_RECENTS pelo autor da chamada. Precisa ser um valor 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 aparece somente na tela inicial, ele só precisa ser especificado por aplicativos com uma atividade que processe a intent CATEGORY_LEANBACK_LAUNCHER.

Esse atributo precisa ser definido como uma referência a um recurso drawable que contenha a imagem (por exemplo, "@drawable/banner"). Não há um banner padrão.

Veja mais informações sobre como Oferecer um banner de tela inicial em "Introdução a apps para TV".

android:clearTaskOnLaunch
Se todas as atividades forem removidas da tarefa, exceto pela atividade raiz, sempre que for inicializada novamente da página inicial: "true" se a tarefa for sempre reduzida à atividade raiz dela ou, caso contrário, "false". 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", vai ser possível remover as atividades da tarefa em algumas situações (consulte o atributo alwaysRetainTaskState), mas nem sempre é o caso.

Suponha, por exemplo, que alguém inicie a atividade P na tela inicial e, de dentro dela, vá para a atividade Q. Em seguida, o usuário pressiona o botão home e retorna à atividade P. Normalmente, o usuário veria a atividade Q, que era o que ele estava fazendo pela última vez na tarefa P. No entanto, se P definir essa sinalização como "true", todas as atividades acima dela (Q, neste caso) são removidas quando o usuário iniciar a atividade P na tela inicial. Assim, o usuário só vai ver "P" ao retornar à tarefa.

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

Esse atributo é ignorado se FLAG_ACTIVITY_RESET_TASK_IF_NEEDED não for definido.

android:colorMode

Solicita a atividade a ser exibida 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 oferecer suporte ao modo de gama ampla de cores, o atributo não vai ter efeito. Para mais informações 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 este 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: evite usar esse atributo. Use-o somente como último recurso. Leia sobre como Processar mudanças durante a execução para ver mais informações sobre como processar corretamente uma reinicialização causada por uma mudança de configuração.

Todas as strings abaixo são valores válidos para esse atributo. Vários valores são separados por "|". Por exemplo, "locale|navigation|orientation".

Valor Descrição
"density" A densidade da tela mudou: o usuário pode ter especificado uma escala de exibição diferente ou outra exibição pode estar ativa.

Adicionado no nível 24 da API.

"fontScale" O fator de escalonamento de fonte mudou: o usuário selecionou um novo tamanho global de fonte.
"keyboard" O tipo de teclado mudou, por exemplo, o usuário conectou um teclado externo.
"keyboardHidden" A acessibilidade do teclado mudou, por exemplo, o usuário revelou o teclado de hardware.
"layoutDirection" A direção do layout mudou, por exemplo, o sentido mudou de da esquerda para a direita (LTR, na sigla em inglês) para direita para a esquerda (RTL, na sigla em inglês).

Adicionado no nível 17 da API.

"locale" A localidade mudou: o usuário solicitou um novo idioma para exibição do texto.
"mcc" O código do país para dispositivos móveis (MCC) IMSI mudou: um chip foi detectado e atualizou o MCC.
"mnc" O código de rede móvel (MNC) IMSI mudou: um chip foi detectado e atualizou o MNC.
"navigation" O tipo de navegação (trackball/dpad) mudou. Normalmente, isso não deveria acontecer.
"orientation" A orientação da tela mudou: o usuário girou o dispositivo.

Observação: se o aplicativo for direcionado ao Android 3.2 (nível 13 da API) ou a versões mais recentes, também é necessário declarar as configurações de "screenSize" e "screenLayout", porque elas também podem mudar quando um dispositivo alterna entre as orientações retrato e paisagem.

"screenLayout" O layout da tela mudou: uma exibição diferente pode ter sido ativada.
"screenSize" O tamanho de tela atual disponível mudou.

Isso representa uma mudança no tamanho atual disponível em relação à taxa de 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" O tamanho físico da tela mudou.

Isso representa uma mudança de tamanho, independente da orientação. Portanto, essa mudança ocorre somente quando o tamanho físico da tela mudar, como 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" A tela touchscreen mudou. Normalmente, isso não deveria acontecer.
"uiMode" O modo de interface do usuário mudou: o usuário colocou o dispositivo em uma base para carro ou mesa ou houve mudança no modo noturno. Para mais informações sobre os diferentes modos de IU, consulte UiModeManager.

Adicionado no nível 8 da API.

Todas essas mudanças de configuração podem afetar os valores do recurso visíveis ao aplicativo. Portanto, quando o método onConfigurationChanged() for chamado, normalmente é necessário extrair novamente todos os recursos (inclusive layouts de visualização, drawables e assim por diante) para processar corretamente a mudança.

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

android:directBootAware

Se a atividade tem ou não reconhecimento de inicialização direta, ou seja, se ela pode ou não ser executada antes do 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 uma nova instância de uma atividade precisa ser adicionada a uma tarefa sempre que ela for inicializada. Esse atributo permite que o usuário possa ver vários documentos do mesmo aplicativo na tela de visão geral.

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 base no ComponentName da intent e no URI de dados que correspondam aos da intent de inicialização. Se o sistema encontrar essa tarefa, ele a limpa e reinicia com a atividade raiz que recebe uma chamada para onNewIntent(android.content.Intent). Caso o sistema não encontre a tarefa, uma nova vai 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 de visão geral trata a atividade seguindo o comportamento padrão: ela exibe uma tarefa para o app, que retoma a atividade invocada pelo usuário mais recentemente.
"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 modifica o comportamento das sinalizações FLAG_ACTIVITY_NEW_DOCUMENT e FLAG_ACTIVITY_MULTIPLE_TASK, se um deles estiver definido na atividade. A tela de visão geral exibe uma única tarefa para o app, que retoma 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" vai ser usado.

android:enabled
Se a atividade pode ou não ser instanciada pelo sistema: "true" se puder ou, caso contrário, "false". 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" (ambos são por padrão) para que o sistema seja capaz de instanciar a atividade. Se algum deles for "false", não será possível o instanciar.

android:excludeFromRecents
Se a tarefa iniciada por essa atividade precisa ser excluída, ou não, da lista de aplicativos usados recentemente, a tela de visão geral. Ou seja, quando essa atividade for a atividade raiz de uma nova tarefa, esse atributo determina se a tarefa aparece ou não na lista de aplicativos recentes. Defina "true" se a tarefa precisar ser excluída da lista. Defina "false" se ela precisar ser incluída. O valor padrão é "false".

android:exported
Este elemento define se a atividade pode ser iniciada por componentes de outros aplicativos:

  • Se for "true", a atividade vai poder ser acessada por qualquer app e ser iniciada pelo nome exato da classe.
  • Se definido como "false", a atividade só vai 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 a 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
Se uma instância existente da atividade precisa ou não ser encerrada (concluída), exceto a atividade raiz, sempre que o usuário iniciar novamente a tarefa (escolhe a tarefa na tela inicial): "true" se precisar ser encerrada e "false" se não precisar. O valor padrão é "false".

Se este atributo e allowTaskReparenting forem "true", este atributo tem precedência. A afinidade da atividade é ignorada. Em vez de assumir um novo pai, a atividade é destruída.

Esse atributo é ignorado se FLAG_ACTIVITY_RESET_TASK_IF_NEEDED não estiver definido.

android:hardwareAccelerated
Se a renderização acelerada por hardware precisa ou não ser ativada para essa atividade: "true" se for preciso ativar, e "false" caso contrário. O valor padrão é "false".

A partir do Android 3.0, 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 Câmera vão ser 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 vai consumir mais memória RAM.

Nem todas as operações OpenGL 2D 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 costuma ser acompanhado por um rótulo (consulte o atributo android:label).

Esse atributo precisa ser 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 vai ser usado. 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. Consulte o atributo icon do elemento <intent-filter>.

android:immersive
Define a configuração de modo imersivo para a atividade atual. Se o atributo android:immersive estiver definido como true na entrada do manifesto do app dessa atividade, o membro ActivityInfo.flags vai ter o conjunto de bits FLAG_IMMERSIVE, mesmo se o modo imersivo mudar durante a execução com 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 precisa ser representada para o usuário. Muitas vezes, é exibido com o ícone de atividade.

Se esse atributo não for definido, o rótulo definido para o aplicativo como um todo vai ser usado. Consulte o atributo label do elemento <application>.

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. 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 da mesma forma que as 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 iniciar a atividade. Há cinco modos que funcionam em conjunto com as sinalizações de atividade (constantes FLAG_ACTIVITY_*) em objetos Intent para determinar o que acontece quando a atividade é chamada para processar uma intent. São eles:

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

O modo padrão é "standard".

Como mostrado na tabela abaixo, os modos se enquadram em dois grupos principais, com as atividades "standard" e "singleTop" de um lado, e "singleTask", "singleInstance" e "singleInstancePerTask" do outro. Uma atividade com o modo de inicialização "standard" ou "singleTop" pode ser instanciada 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. 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". A atividade pode ser instanciada várias vezes e pode ser localizada em qualquer tarefa de uma mesma taskAffinity. Enquanto isso, o dispositivo pode conter apenas uma tarefa para localizar a atividade "singleTask" na raiz da tarefa da atividade.

Os modos "standard" e "singleTop" são diferentes em apenas um aspecto: sempre que há uma nova intent para uma atividade "standard", uma nova instância da classe é criada para responder à intent. Cada instância processa uma única intent. Da mesma forma, uma nova instância de uma atividade "singleTop" também pode ser criada para lidar com 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()) e nenhuma instância nova vai ser criada. Em outras circunstâncias, por exemplo, se uma instância existente da atividade "singleTop" estiver na tarefa de destino, mas não no topo da pilha, ou se estiver no topo da pilha, mas não na tarefa de destino, uma nova instância vai ser criada e colocada na pilha.

Da mesma forma, se você navegar para cima até uma atividade na pilha atual, o comportamento vai 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 vai ser levada ao topo da pilha e o estado vai ser preservado. A intent de navegação é recebida pelo método onNewIntent() da atividade mãe. 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 é diferente de "singleTask" e "singleInstancePerTask" em apenas um aspecto: uma atividade com os modos de inicialização "singleTask" ou "singleInstancePerTask" permite que as atividades "standard" e "singleTop" façam parte da tarefa. Por outro lado, uma atividade "singleInstance" não permite que outras atividades façam parte da tarefa. É necessário que ela seja 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, vai haver apenas uma instância dessa atividade em uma tarefa, mas ela pode ser instanciada várias vezes em tarefas diferentes.

Conforme mostrado na tabela acima, standard é o modo padrão e é adequado para a maioria dos tipos de atividades. 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 à maioria dos aplicativos, porque resultam em um modelo de interação que provavelmente não é muito conhecido pelos usuários e é bem diferente da maioria dos outros aplicativos.

Independentemente do modo de inicialização escolhido, não deixe de testar a usabilidade da atividade durante a inicialização e quando voltar à atividade original de outras atividades e tarefas usando o botão Voltar.

Para ver mais informações sobre modos de inicialização e a interação deles com sinalizações de Intent, consulte o documento Tarefas e pilha de retorno.

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 usa esse modo, os usuários do dispositivo normalmente não veem notificações, não podem acessar aplicativos que não estejam na lista de permissões nem podem voltar à tela inicial (a não ser que ela esteja na lista de permissões). Somente aplicativos na lista de permissões do controlador de políticas do dispositivo (DPC) podem ser executados quando o sistema está em 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 tarefas, mas podem ser substituídas chamando o método startLockTask().
"never"

As tarefas não são inicializadas no modo de bloqueio de tarefas e os usuários do dispositivo não podem fixar essas tarefas da tela de visão geral.

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 modelo 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 vai 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 vai 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 com acesso root nessa atividade na tela de visão geral. Quando esse número de entradas for alcançado, o sistema vai remover a instância mais antiga da tela de visão geral. Os valores válidos são de 1 a 50 (25 em dispositivos com pouca memória). Zero é inválido. Esse valor precisa ser um número inteiro, como 50. O valor padrão é 16.
android:maxAspectRatio
É a proporção máxima a que a atividade oferece suporte. 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 será ignorado se a atividade tiver definido a constante resizeableActivity como verdadeira, uma vez que isso significa que a atividade tem suporte a todos os tamanhos.

Para saber mais sobre esse atributo, consulte Declarar uma proporção máxima em Declaração de suporte restrito à tela.

android:multiprocess
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 sinalização for definida como "true", é 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 nem desejado.

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

Depois de publicar o aplicativo, não mude esse nome (link em inglês), a menos que você tenha definido android:exported="false".

Não há padrão. O nome precisa ser especificado.

android:noHistory
Se a atividade precisa ser removida ou não da pilha de atividades e concluída (o método finish() precisa ser chamado ou não) quando o usuário sair dela e a atividade não estiver mais visível na tela: "true" se tiver que ser concluída. Caso contrário, "false". O valor padrão é "false".

Um valor "true" significa que a atividade não vai ser incluída em um rastro histórico. A atividade não vai ser mantida na pilha de atividades da tarefa, portanto, o usuário não pode retornar a ela. Nesse caso, o método onActivityResult() nunca vai 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 vai ser iniciada quando o usuário pressionar o 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". Exemplo:

<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, consulte como fornecer navegação para cima.

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 vai ser entregue à atividade.

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

Para mais informações sobre permissões, consulte a seção Permissões na introdução e outro documento, chamado Segurança e permissões.

android:process
É o nome do processo em que a atividade precisa ser 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 esse atributo. No entanto, se necessário, você pode modificar o nome do processo padrão usando este atributo, o que permite distribuir os componentes do aplicativo em vários processos.

Se o nome atribuído a esse atributo começar com dois-pontos (":"), um novo processo, particular ao aplicativo, vai ser criado quando for necessário e a atividade for executada nesse processo. Se o nome do processo começar com um caractere em letra minúscula, a atividade vai 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 na pilha de tarefas ou não. Tarefas com atividade raiz em que esse atributo é definido como "true" substituem a intent base com o atributo 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 para qualquer atividade que tiver sido inicializada na mesma tarefa. Esse processo continua para todas as atividades até encontrar uma que tenha esse atributo definido como "false". O valor padrão é "false".

Esse atributo definido como "true" também permite que a atividade use o ActivityManager.TaskDescription para mudar rótulos, cores e ícones na tela de visão geral.

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" (verdadeiro), o usuário vai poder iniciar a atividade nos modos de tela dividida e de forma livre. Se você definir o atributo como "false" (falso), o app não vai 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 "true" 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, definir essa sinalização não garante que o app tenha acesso exclusivo a recursos.

Se o app for destinado ao nível 24 da API ou mais recente, mas você não especificar um valor para esse atributo, ele vai 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 vai 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 a altura mínimas da atividade estiverem dentro dos requisitos de várias janelas, o app oferece suporte a esse modo. Se resizeableActivity="false", o app não vai oferecer suporte ao modo de várias janelas, independente da largura e da 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 são redimensionáveis.

android:screenOrientation
A orientação da tela da atividade no dispositivo. O sistema vai ignorar esse atributo se a atividade estiver em execução no modo de várias janelas.

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. 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. Adicionado no nível 18 da API.
"sensor" A orientação é determinada pelo sensor de orientação do dispositivo. A orientação da tela depende da forma com que o usuário segura o dispositivo e muda quando ele é girado. No entanto, por padrão, alguns dispositivos não giram em todas as quatro orientações possíveis. Para permitir todas as quatro orientações, use "fullSensor". O sensor é usado mesmo se o usuário bloquear a rotação com base em sensor.
"fullSensor" A orientação é determinada pelo sensor de orientação do dispositivo para qualquer uma das quatro orientações. Isso é semelhante a "sensor", exceto por permitir qualquer uma das quatro orientações possíveis, independente do que o dispositivo oferece normalmente. 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 bloqueou a rotação com base em sensor, o comportamento vai ser o mesmo de user, caso contrário, vai 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 vai ser considerado um requisito fixo para a orientação usada pela atividade. Como tal, 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 vai ser disponibilizado somente aos dispositivos com suporte à orientação paisagem. No entanto, você também precisa declarar explicitamente que o aplicativo exige orientação de retrato ou paisagem com o elemento <uses-feature>. Por exemplo: <uses-feature android:name="android.hardware.screen.portrait"/>. Esse comportamento é simplesmente 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

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

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

android:stateNotNeeded
Se a atividade pode ou não ser eliminada e reiniciada sem salvar o estado dela: "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 vai ser possível chamar onSaveInstanceState() e onCreate() vai receber null em vez do pacote, da mesma forma que no início da atividade pela primeira vez.

Uma configuração "true" garante que a atividade possa ser reiniciada na ausência do estado retido. Por exemplo: a atividade que exibe a tela inicial usa essa configuração para assegurar que não vai ser removida se por algum motivo houver falha.

supportsPictureInPicture

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

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

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 for inicializada com a sinalização 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 tema. Consulte setTheme() e também pode "iniciar" animações antes que a atividade seja lançada para melhor correspondência com a aparência real da atividade.

Se esse atributo não for definido, a atividade vai herdar o tema definido 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 mais informações, consulte o guia do desenvolvedor de Estilos e temas.

android:uiOptions
Opções extras para a IU de uma atividade.

Precisa ser um dos valores abaixo.

ValorDescrição
"none"Nenhuma opção extra de IU. Esse é o padrão.
"splitActionBarWhenNarrow"Adicione uma barra na parte de baixo da tela para exibir 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 mais informações sobre a barra de apps, consulte a aula de treinamento Adicionar 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:
  • O estado do teclado de software: se está oculto ou visível, quando a atividade se torna o foco da atenção do usuário.
  • O ajuste feito na janela principal da atividade: se vai ser 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 abaixo ou uma combinação de um valor "state..." com um valor "adjust...". Definir vários valores em um dos grupos, ou seja, vários valores "state...", por exemplo, tem resultados indefinidos. Valores individuais são separados por uma barra vertical (|). Por exemplo:

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

Os valores definidos aqui (exceto "stateUnspecified" e "adjustUnspecified") substituem os valores definidos no tema.

Valor Descrição
"stateUnspecified" O estado do teclado de software (oculto ou visível) não é especificado. O sistema escolhe um estado adequado ou usa a definiçã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 escolher a atividade, ou seja, quando o usuário navegar 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 navegar 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 especifica se a janela principal do aplicativo for redimensionada a fim de criar espaço para o teclado de software ou se o conteúdo da janela for 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. Se houver uma dessas visualizações, a janela vai 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 a fim de 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.
veja também:
<application>
<activity-alias>