Android Dev Summit, October 23-24: two days of technical content, directly from the Android team. Sign-up for livestream updates.

<activity>

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"]
          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. Qualquer atividade não declarada nesse arquivo não será vista pelo sistema e nunca será executada.
atributos:
android:allowEmbedded
Indica que a atividade pode ser lançada como filho incorporado de outra atividade. Particularmente no caso em que o filho reside em um contêiner, como um Display pertencente a outra atividade. Por exemplo, atividades usadas para notificações personalizadas do Wear precisam fazer essa declaração, para que o Wear possa exibir a atividade no stream de seu contexto, que reside em outro processo.

O valor padrão do 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 essa tarefa for trazida para a frente — “true” se for possível mover a atividade e “false” se ela for permanecer na tarefa em que foi iniciada.

Se o 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, é associada à tarefa da atividade que a iniciou e permanece nessa tarefa durante toda a sua vida útil. Você pode usar esse atributo para forçar a atividade a assumir como novo pai a tarefa com que a atividade 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 aciona uma atividade que pode exibir a página. Essa atividade é definida pelo aplicativo do navegador, mas é lançada como parte da tarefa do e-mail. Se a atividade assumir a tarefa do navegador como novo pai, será mostrada na próxima vez que o navegador vier para a frente e estará ausente quando a tarefa do e-mail vier para a frente novamente.

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
Se o estado da tarefa onde está a atividade será sempre mantido pelo sistema — “true” se será sempre mantido e “false” se o sistema poderá redefinir a tarefa a seu estado inicial em determinadas situações. O valor padrão é “false”. Esse atributo é significativo somente para a atividade raiz de uma tarefa e é 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 acessou a tarefa por uma determinada quantidade de tempo, como 30 minutos.

No entanto, quando o atributo for “true”, os usuários sempre retornarão à tarefa em seu último estado, independentemente 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 lançadas com esse atributo permanecerão na tela de visão geral até que a última atividade na tarefa seja concluída. Se true, a tarefa será automaticamente removida da tela de visão geral. Isso modifica 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 que fornece um banner gráfico estendido para seu item associado. Use com a tag <activity> para fornecer um banner padrão para uma atividade específica ou com a tag <application> para fornecer um banner para todas as atividades do aplicativo.

O sistema usa o banner para representar um aplicativo na tela inicial do Android TV. Como o banner é exibido na tela inicial, ele precisa ser especificado somente por aplicativos com uma atividade que processa o intent CATEGORY_LEANBACK_LAUNCHER.

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

Consulte Oferecer um banner de tela inicial em “Introdução a apps para a TV” para mais informações.

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 à sua atividade raiz ou, caso contrário, “false”. O valor padrão é “false”. Esse atributo é significativo somente para atividades que iniciam uma nova tarefa (a atividade raiz) e é ignorado para todas as outras atividades na tarefa.

Quando o valor for “true”, sempre que o usuário reiniciar a tarefa, será levado à sua atividade raiz, independentemente do que fazia na tarefa anterior e de ter usado o botão Voltar ou Home para deixá-la. Quando o valor for “false”, será possível remover as atividades da tarefa em algumas situações (consulte o atributo alwaysRetainTaskState), mas nem sempre.

Por exemplo: alguém inicializa a atividade P na tela inicial e vai dela para a atividade Q. Em seguida, o usuário pressiona Home e volta à atividade P. Normalmente, o usuário veria a atividade Q, porque era onde estava na tarefa da atividade P. No entanto, se P definiu esse sinalizador como “true”, todas as atividades acima dela (neste caso, Q) foram removidas quando o usuário pressionou Home e a tarefa foi para o segundo plano. Portanto, o usuário verá somente P quando voltar à tarefa.

Se esse atributo e allowTaskReparenting forem ambos “true”, todas as atividades que puderem assumir um novo pai serão movidas para a tarefa com que compartilham alguma afinidade. As demais atividades serão descartadas, como descrito acima.

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 exibir cores mais vibrantes. Se o dispositivo não for compatível com o modo de gama ampla de cores, o atributo não terá efeito. Para maiores informações sobre renderização em modo de gama ampla de cores, consulte Como melhorar os gráficos com conteúdo amplo de cor.

android:configChanges
Lista a alterações de configuração processadas pela própria atividade. Quando ocorre uma alteração de configuração em tempo de execução, a atividade é desativada e reinicializada por padrão. No entanto, a declaração de uma configuração com este atributo evita que a atividade seja reinicializada. Em vez disso, a atividade permanecerá em execução e seu método onConfigurationChanged() será chamado.

Observação: evite usar esse atributo e use-o somente como último recurso. Leia Processamento de alterações em tempo de execução para ter mais informações sobre como processar corretamente uma reinicialização causada por uma alteração de configuração.

Todas as strings a seguir são valores válidos para esse atributo. Valores múltiplos são separados por “|” — por exemplo: “locale|navigation|orientation”.

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

Adicionado na API de nível 24.

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

Adicionado na API de nível 17.

locale A localidade foi alterada — o usuário solicitou um novo idioma para exibição do texto.
mcc O código do país do dispositivo móvel (MCC, na sigla em inglês) IMSI foi alterado — um SIM foi detectado e atualizou o MCC.
mnc O código de rede móvel (MNC, na sigla em inglês) IMSI foi alterado — um SIM foi detectado e atualizou o MNC.
navigation O tipo de navegação (trackball/dpad) foi alterado. Normalmente, isso não deveria acontecer.
orientation A orientação da tela foi alterada — o usuário girou o dispositivo.

Observação: se o aplicativo for direcionado ao Android 3.2 (API de nível 13) ou superior, será necessário declarar também a configuração "screenSize", pois ela também será alterada quando a orientação do dispositivo mudar entre retrato e paisagem.

screenLayout O layout da tela foi alterado — uma exibição diferente pode ter sido ativada.
screenSize O tamanho de tela atual disponível foi alterado.

Isso representa uma alteração no tamanho atual disponível em relação à taxa de proporção atual, que será alterada quando o usuário mudar entre paisagem e retrato.

Adicionado na API de nível 13.

smallestScreenSize O tamanho físico da tela foi alterado.

Isso representa uma alteração de tamanho, independentemente da orientação. Portanto, essa alteração ocorre somente quando o tamanho físico da tela é alterado, como na alteração para uma tela externa. Uma alteração nessa configuração corresponde a uma alteração na configuração smallestWidth.

Adicionado na API de nível 13.

touchscreen O touchscreen foi alterado. Normalmente, isso não deveria acontecer.
uiMode O modo da interface do usuário foi alterado — o usuário substituiu o dispositivo por uma dock de carro ou mesa, ou houve alteração no modo noturno. Para mais informações sobre os diferentes modos de IU, consulte UiModeManager.

Adicionado na API de nível 8.

Todas essas alterações de configuração podem afetar os valores do recurso percebidos pelo aplicativo. Portanto, quando onConfigurationChanged() for chamado, normalmente será necessário recuperar novamente todos os recursos (inclusive layouts de visualização, drawables e assim por diante) para processar corretamente a alteração.

Observação: para processar todas as alterações na configuração relacionada ao modo de várias janelas, use "screenLayout" e "smallestScreenSize". O modo várias janelas é compatível com Android 7.0 (API de nível 24) ou superior.

android:directBootAware

Se a atividade é apta a realizar inicialização direta, ou seja, se pode executar antes de o usuário desbloquear o dispositivo.

Observação: durante a Inicialização direta, uma atividade no seu 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 seguintes efeitos quando o usuário abre um documento com o aplicativo:

Valor Descrição
intoExisting O sistema procura uma tarefa que tenha base no ComponentName do intent e dados URI que correspondam aos do intent em inicialização. Se o sistema encontrar essa tarefa, ele a conclui e reinicia com a atividade raiz. Essa atividade recebe uma chamada para onNewIntent(android.content.Intent). Caso o sistema não encontre a tarefa, uma nova é criada.
always A atividade cria uma nova tarefa para o documento, mesmo se ele já estiver aberto. Isso é o mesmo que configurar os sinalizadores 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 FLAG_ACTIVITY_NEW_TASK é definido. A tela de visão geral trata a atividade como aconteceria por padrão: ela exibe uma tarefa para o aplicativo, que retoma a atividade invocada por último pelo usuário.
never Essa atividade não é inicializada em um novo documento, mesmo quando o Intent contém FLAG_ACTIVITY_NEW_DOCUMENT. A definição desse atributo modifica o comportamento dos sinalizadores FLAG_ACTIVITY_NEW_DOCUMENT e FLAG_ACTIVITY_MULTIPLE_TASK, se um deles estiver definido na atividade, e a tela de visão geral exibe uma única tarefa para o aplicativo, que retoma a atividade invocada por último pelo usuário.

Observação: para valores que não sejam “none” e “never”, a atividade precisará ser definida com launchMode="standard". Se esse atributo não for especificado, será usado documentLaunchMode="none".

android:enabled
Se a atividade pode ser instanciada pelo sistema — "true" se puder ou, caso contrário, “false”. O valor padrão é “true”.

O elemento <application> tem seu próprio atributo enabled, que se aplica a todos os componentes do aplicativo, inclusive atividades. Os atributos <application> e <activity> precisam ambos ser “true” (como são por padrão) para que o sistema possa instanciar a atividade. Se um deles for “false”, não será possível instanciar a atividade.

android:excludeFromRecents
Se a tarefa iniciada por essa atividade precisa ser excluída 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 não terá que aparecer na lista de aplicativos recentes. Defina “true” se a tarefa precisar ser excluída da lista ou “false” caso precise ser incluída. O valor padrão é “false”.

android:exported
Esse elemento define se a atividade pode ser inicializada por componentes de outros aplicativos — “true” se puder ou, caso contrário, “false”. No caso de “false”, a atividade só pode ser inicializada por componentes do mesmo aplicativo ou aplicativos que tenham o mesmo código do usuário.

Se estiver usando filtros de intents, esse elemento “false” não será exibido. Se fizer isso e um aplicativo tentar chamar a atividade, o sistema lançará um ActivityNotFoundException. Em vez disso, é melhor evitar que outros aplicativos chamem a atividade. Para isso, não configure filtros de intents para ela.

Caso você não tenha filtros de intents, o valor padrão para esse elemento será “false”. Se você definir o elemento “true”, a atividade ficará acessível para qualquer aplicativo que conheça o próprio nome de classe. Mas isso não resolve quando o sistema tenta corresponder a um intent implícito.

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

android:finishOnTaskLaunch
Se uma instância existente da atividade tiver que ser desativada (encerrada) sempre que o usuário inicializar novamente sua tarefa (a tarefa é escolhida na tela inicial) — “true” se precisar ser desativada ou, caso contrário, “false”. O valor padrão é “false”.

Se esse atributo e allowTaskReparenting forem ambos “true”, ele prevalecerá sobre o outro. A afinidade da atividade é ignorada. Em vez de assumir um novo pai, a atividade será destruída.

android:hardwareAccelerated
Se a renderização acelerada por hardware precisa ser ativada para esta Activity — “true” se ela precisar ser ativada ou, caso contrário, “false”. 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 for ativado, a maioria das operações em Canvas, Paint, Xfermode, ColorFilter, Shader e Camera será acelerada. Os resultados serão animações e rolagens mais suaves e maior capacidade de resposta geral, mesmo em aplicativos que não fazem uso explícito das bibliotecas de OpenGL da biblioteca. Devido ao maior número de recursos necessários para ativar a aceleração de hardware, o aplicativo consumirá mais RAM.

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

android:icon
Ícone que representa a atividade. O ícone será 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 de inicialização. O ícone costuma ser acompanhado por um rótulo (consulte o atributo android:label).

Esse atributo precisa ser definido como referência a um recurso drawable contendo a definição da imagem. Se não for definido, será usado o ícone especificado para o aplicativo como um todo (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 intents 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 de manifesto do aplicativo dessa atividade, o membro ActivityInfo.flags terá o conjunto de bits FLAG_IMMERSIVE, mesmo se o modo imersivo for alterado no ambiente de execução por meio do 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 juntamente com o ícone de atividade.

Se o atributo não for definido, será usado o conjunto de rótulos para o aplicativo como um todo (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 precisa ser definido como referência a um recurso de string, assim ele pode ser localizado como outras strings na interface do usuário. No entanto, como conveniência durante o desenvolvimento do aplicativo, ele também pode ser definido como uma string bruta.

android:launchMode
Instrução de inicialização da atividade. Há quatro modos que funcionam em conjunto com os sinalizadores de atividade (constantes FLAG_ACTIVITY_*) em objetos Intent para determinar o que acontecerá quando a atividade é chamada para processar um intent. Os modos são:

standard
singleTop
singleTask
singleInstance

O modo padrão é “standard”.

Como mostrado na tabela abaixo, os modos se dividem em dois grupos principais, com atividades “standard” e “singleTop” de um lado e atividades “singleTask” e “singleInstance” 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 localizar-se em qualquer lugar da pilha de atividades. Normalmente, elas são lançadas na tarefa denominada startActivity() (a menos que o objeto 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” e “singleInstance” podem somente iniciar uma tarefa. Elas sempre estão na raiz da pilha de atividades. Além disso, o dispositivo pode conter somente uma instância da atividade em um determinado momento — só uma dessas tarefas.

Os modos “standard” e “singleTop” diferem entre si em um único aspecto: Sempre que houver um novo intent para uma atividade “standard”, uma nova instância da classe será criada para responder ao intent. Cada instância processa um único intent. Da mesma forma, também é possível criar uma nova instância de uma atividade “singleTop” para processar um novo intent. No entanto, se a tarefa de destino já tiver uma instância da atividade no topo da sua pilha, essa instância receberá o novo intent (em uma chamada onNewIntent()) e nenhuma instância nova 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 será criada e colocada na pilha.

Da mesma forma, se você navegar para cima até uma atividade na pilha atual, o comportamento será determinado pelo modo de inicialização da atividade pai. Se a atividade pai tiver o modo de inicialização singleTop (ou o intent up contiver FLAG_ACTIVITY_CLEAR_TOP), o pai será levado ao topo da pilha e o estado será preservado. O intent de navegação é recebido pelo método onNewIntent() da atividade pai. Se a atividade pai tiver o modo de lançamento standard (e o intent up não contiver FLAG_ACTIVITY_CLEAR_TOP), a atividade atual e o pai serão retirados da pilha e uma nova instância da atividade pai será criada para receber o intent de navegação.

Os modos “singleTask” e “singleInstance” também diferem entre si em somente um aspecto: Uma atividade “singleTask” permite que outras atividades participem da tarefa. Isso ocorre sempre na raiz da tarefa, mas outras atividades (necessariamente “standard” e “singleTop”) podem ser inicializadas nessa tarefa. Por outro lado, atividades “singleInstance” não permitem nenhuma outra atividade como parte da tarefa. Elas são as únicas atividades na tarefa. Se iniciar outra atividade, ela será atribuída a uma tarefa diferente — como se FLAG_ACTIVITY_NEW_TASK estivesse no 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 o intent a ela.
singleTop Condicionalmente Se uma instância da atividade já existir no topo da tarefa de destino, o sistema encaminhará o intent àquela instância por meio de uma chamada ao método onNewIntent() em vez de criar uma nova instância da atividade.
Inicializações especializadas
(não recomendado para uso geral)
singleTask Não O sistema recria a atividade na raiz de uma nova tarefa e encaminha o intent a ela. No entanto, se uma instância da atividade já existir, o sistema encaminhará o intent àquela instância por meio de uma chamada ao método onNewIntent(), em vez de criar uma nova instância.
singleInstance Não Igual a “singleTask"”, mas o sistema não inicializa nenhuma outra atividade na tarefa que contém a instância. A atividade é sempre o único membro da tarefa.

Como mostrado na tabela acima, standard é o modo padrão e é adequado para a maioria dos tipos de atividades. SingleTop também é um modo de inicialização comum e útil para vários tipos de atividades. Os outros modos — singleTask e singleInstance — não são adequados à maioria dos aplicativos, pois 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 a ele de outras atividades e tarefas usando o botão Voltar.

Para ver mais informações sobre modos de inicialização e sua interação com sinalizadores 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 tarefa de bloqueio.

O Android pode executar tarefas de maneira imersiva, semelhante à forma pública, com o modo de tarefa de bloqueio. Quando o sistema executa nesse modo, os usuários dos dispositivos normalmente não veem notificações, não acessam 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, na sigla em inglês) podem ser executados quando o sistema está em modo de tarefa de bloqueio. 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 a seguir:

Valor Descrição
"normal" Valor padrão. É o valor padrão. As tarefas não são inicializadas no modo de tarefa de bloqueio, mas podem ser substituídas ao chamar startLockTask().
"never"

As tarefas não são inicializadas no modo de tarefa de bloqueio e o usuário do dispositivo não pode fixar guia a essas tarefas da tela de visão geral.

Observação: esse modo só está disponível para o sistema e para 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 é idêntico a always, exceto pelo fato de a atividade precisar chamar stopLockTask() antes de poder concluir, caso essa seja a última tarefa bloqueada. Se o DPC não autorizar esse pacote, o modo é idêntico ao normal.
"always"

Tarefas com acesso root nessa atividade sempre são iniciadas no modo de tarefa de bloqueio. Se o sistema já estiver nesse modo durante a inicialização da tarefa, a nova tarefa será inicializada na parte superior da tarefa atual. Ao chamar finish(), as tarefas iniciadas nesse modo podem sair do modo de tarefa de bloqueio.

Observação: esse modo só está disponível para o sistema e para aplicativos privilegiados. Aplicativos não privilegiados com esse valor são tratados como normal.

Esse atributo foi introduzido na API de nível 23.

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 removerá a instância menos recentemente usada 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 taxa de proporção máxima suportada pela atividade. Se o aplicativo executar em um dispositivo com proporção mais larga, o sistema colocará automaticamente o aplicativo em uma caixa de texto, deixando de usar partes da tela para que o aplicativo possa executar com a taxa de proporção máxima especificada. A taxa de proporção máxima é expressa como a forma decimal do quociente da maior dimensão do dispositivo dividida pela menor dimensão. Por exemplo, se a taxa de proporção máxima é de 7:3, defina o valor desse atributo como 2.33. Em dispositivos que não são wearable, o valor desse atributo precisa ser de 1.33 ou maior. Em dispositivos wearable, precisa ser de 1.0 ou maior. Caso contrário, o valor definido será ignorado pelo sistema.

Observação: esse atributo será ignorado se a atividade tiver resizeableActivity definido como “true”, uma vez que isso significa que sua atividade é compatível com qualquer tamanho.

Para mais informações sobre esse atributo, consulte Compatibilidade com várias telas.

android:multiprocess
Se for possível inicializar uma instância da atividade no processo do componente que a iniciou — “true” se puder ou, caso contrário, “false”. O valor padrão é “false”.

Normalmente, inicializa-se uma nova instância de uma atividade no processo do aplicativo que a definiu. Assim, todas as instâncias da atividade são executadas no mesmo processo. No entanto, se esse sinalizador for definido 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 nem desejável.

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 será anexado ao nome do pacote especificado no elemento <manifest>.

Não altere o nome do aplicativo depois de publicá-lo (a menos que você tenha definido android:exported="false").

Não há nenhum valor padrão. Deve-se especificar o nome.

android:noHistory
Se a atividade tiver que ser removida da pilha de atividades e encerrada (seu método finish() será chamado) quando o usuário navegar para outro lugar e ela não estiver mais visível na tela — “true” se tiver que ser encerrada ou, caso contrário, “false”. O valor padrão é “false”.

Um valor de “true” significa que a atividade não será incluída no histórico. A atividade não permanecerá na pilha de atividades da tarefa, portanto, o usuário não poderá retornar a ela. Nesse caso, onActivityResult() nunca será chamado se você iniciar outra atividade para o resultado dessa atividade.

Esse atributo foi introduzido na API de nível 3.

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 pressionar o botão “Up” na barra de ações. O sistema também pode usar essas informações para sintetizar uma pilha de retorno de atividades com TaskStackBuilder.

Para compatibilidade com as APIs de níveis 4 a 16, também é possível declarar a atividade pai com um elemento <meta-data> que especifica um valor para "android.support.PARENT_ACTIVITY". Por 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 mais informações sobre a declaração de atividades do pai para comportar a navegação Up, consulte Fornecimento da navegação Up.

Esse atributo foi introduzido na API de nível 16.

android:persistableMode

Define como a instância de uma atividade é preservada dentro de uma tarefa contida entre reinicializações do dispositivo.

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

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

Valor Descrição
persistRootOnly Valor padrão. Quando o sistema é reiniciado, a tarefa da atividade é preservada, mas somente o intent de inicialização da atividade raiz é usado.

Quando o intent de inicialização do seu aplicativo 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 aplicativo em uma reinicialização do dispositivo.

Observação: esse valor de atributo afeta o comportamento do seu aplicativo somente se estiver definido na atividade raiz dele.

persistAcrossReboots

O estado dessa atividade é preservado, juntamente com o estado de cada atividade mais alta na pilha de retorno 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 o sinalizador Intent.FLAG_ACTIVITY_NEW_DOCUMENT, ela, juntamente com todas as atividades mais altas na pilha de retorno, não será preservada.

Quando o intent carrega uma atividade que tenha o atributo persistableMode definido como persistAcrossReboots no seu aplicativo, 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 aplicativo mesmo que ele esteja definido em outra atividade que não seja a raiz do seu aplicativo.

persistNever

O estado da atividade não é preservado.

Observação: esse valor de atributo afeta o comportamento do seu aplicativo somente se estiver definido na atividade raiz dele.

Esse atributo foi introduzido na API de nível 21.

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

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

Para mais informações sobre permissões, consulte a seção Permissões na introdução e o documento 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 em 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 com este atributo, permitindo distribuir os componentes do aplicativo em vários processos.

Se o nome designado a esse atributo começar com dois pontos (“:”), quando necessário, será criado um novo processo, privado para o aplicativo, e a atividade executará nesse processo. Se o nome do processo começar com um caractere minúsculo, a atividade executará em um processo global com esse nome, desde que tenha permissão para isso. Isso permite que componentes em aplicativos diferentes compartilhem um processo para reduzir o consumo 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. Tarefas com atividade raiz em que esse atributo é definido como “true” substituem o Intent da base com o da próxima atividade na tarefa. Se a próxima atividade também tiver esse atributo definido como “true”, ela liberará o Intent da base para qualquer atividade que tiver lançado na mesma tarefa. Isso continuará para cada atividade até chegar a uma delas 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 ActivityManager.TaskDescription para alterar rótulos, cores e ícones na tela de visão geral.

resizeableActivity

Especifica se o aplicativo é compatível com exibição em várias janelas. Você pode definir esse atributo no elemento <activity> ou <application>.

Se você definir esse atributo como verdadeiro, o usuário poderá inicializar a atividade nos modos de tela dividida e forma livre. Se você definir o atributo como falso, a atividade não será compatível com o modo de várias janelas. Se esse valor for “false” e o usuário tentar iniciar a atividade no modo de várias janelas, a atividade ocupará a tela inteira.

Se o aplicativo for direcionado à API de nível 24 ou superior, mas o valor desse atributo não for especificado, o atributo assumirá o valor padrão “true”.

Esse atributo foi adicionado na API de nível 24.

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

O valor pode ser qualquer uma das strings a seguir:

unspecified É o valor padrão. O sistema escolhe a orientação. A política usada e, portanto, as escolhas feitas em contextos específicos poderão diferir 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 na API de nível 9.
reversePortrait É a orientação de retrato na direção oposta do retrato normal. Adicionado na API de nível 9.
sensorLandscape É a orientação de paisagem, mas pode ser 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 na API de nível 9.
sensorPortrait É a orientação de retrato, mas pode ser retrato normal ou invertido, dependendo do sensor do dispositivo. O sensor é usado mesmo se o usuário tiver bloqueado a rotação com base em sensor. Adicionado na API de nível 9.
userLandscape É a orientação de paisagem, mas pode ser paisagem normal ou invertida, dependendo do sensor do dispositivo e da preferência de sensor do usuário. Adicionado na API de nível 18.
userPortrait É a orientação de retrato, mas pode ser retrato normal ou invertido, dependendo do sensor do dispositivo e da preferência de sensor do usuário. Adicionado na API de nível 18.
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 altera-se quando o dispositivo é 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 das quatro orientações. Isso é semelhante a "sensor", exceto por permitir qualquer uma das quatro orientações possíveis, independentemente do que o dispositivo faz normalmente (por exemplo, alguns dispositivos não costumam usar paisagem ou retrato invertidos, mas essa definição ativa essas orientações). Adicionado na API de nível 9.
nosensor A orientação é determinada sem referência a nenhum sensor de orientação físico. O sensor é ignorado, portanto, a tela não 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 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 na API de nível 18.
locked Bloqueia a orientação na rotação atual, qualquer que seja. Adicionado na API de nível 18.

Observação: ao declarar um dos valores de paisagem ou retrato, ele 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 compatíveis com a orientação exigida pelas atividades. Por exemplo: se você declarar "landscape", "reverseLandscape" ou "sensorLandscape", o aplicativo será disponibilizado somente aos dispositivos compatíveis com a 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 compatíveis). A plataforma em si não controla se o aplicativo pode ser instalado quando um dispositivo é compatível somente com determinadas orientações.

android:showForAllUsers

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

Esse atributo foi adicionado na API de nível 23.

android:stateNotNeeded
Se for possível eliminar e reinicializar a atividade sem salvar o estado — “true” se puder ser reinicializada sem referência ao estado anterior e, caso contrário, “false”. 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 objetoBundle, passado a onCreate() quando a atividade é reiniciada. Se este atributo for definido como “true”, não será possível chamar onSaveInstanceState() e onCreate() receberá null em vez do pacote — da mesma forma que no início da atividade pela primeira vez.

A configuração “true” garante que a atividade possa ser reiniciada na falta do estado retido. Por exemplo: a atividade que exibe a tela inicial usa essa configuração para assegurar que não será removida se por algum motivo houver falha.

supportsPictureInPicture

Especifica se a atividade é compatível com a exibição Picture-in-Picture. O sistema ignorará esse atributo se android:resizeableActivity for “false”.

Esse atributo foi adicionado na API de nível 24.

android:taskAffinity
É a tarefa com que a atividade tem afinidade. Atividades com a mesma afinidade pertencem conceitualmente à mesma tarefa (ao mesmo “aplicativo”, na visão 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 novo pai (consulte o atributo allowTaskReparenting) e a tarefa que hospedará a atividade quando esta for inicializada com o sinalizador FLAG_ACTIVITY_NEW_TASK.

Por padrão, todas as atividades de um aplicativo têm a mesma afinidade. É possível definir esse atributo para agrupá-las 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 herdará a afinidade definida para o aplicativo (consulte o atributo taskAffinity do elemento <application>). O nome da afinidade padrão de um aplicativo é o nome do pacote definido pelo elemento <manifest>.

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 herdará o tema definido para o aplicativo como um todo — do atributo theme do elemento <application>. Se aquele atributo também não for definido, será usado o tema do sistema padrão. Para mais informações, consulte o guia do desenvolvedor Estilos e temas.

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

Deve ser um dos seguintes valores:

ValorDescrição
"none"Sem opções adicionais de IU. Esse é o padrão.
"splitActionBarWhenNarrow"Adiciona uma barra à parte inferior da tela para exibir itens de ação na barra de aplicativos (também conhecida como barra de ações) quando houver restrição de espaço horizontal (como no modo retrato em um celular). Em vez de um pequeno número de itens de ação aparecendo na barra de aplicativos na parte superior da tela, a barra de aplicativos se divide na seção de navegação superior e na barra inferior para itens de ação. Com isso, disponibiliza-se uma quantidade razoável de espaço não só para os itens de ação, mas também para elementos de navegação e título na parte superior. Os itens de menu não são divididos nas duas barras e são sempre exibidos juntos.

Para mais informações sobre a barra de aplicativos, consulte a classe de treinamento Adição da barra do aplicativo.

Esse atributo foi adicionado na API de nível 14.

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 redimensionada com tamanho menor para 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...”. A definição de vários valores em um dos grupos — vários valores “state...”, por exemplo — gera resultados indefinidos. Valores individuais são separados por uma barra vertical (|). Por exemplo:

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

Os valores definidos aqui (diferentes de “stateUnspecified” e “adjustUnspecified”) modificam os valores definidos no tema.

Valor Descrição
stateUnspecified O estado do teclado de software (oculto ou visível) não é especificado. O sistema escolherá um estado adequado ou usará a definição do tema.

Essa é a configuração padrão para o comportamento do teclado de software.

stateUnchanged O teclado de software será mantido no estado anterior, visível ou invisível, quando a atividade vier para o primeiro plano.
stateHidden O teclado de software será 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 estará oculto quando a janela principal da atividade tiver o foco de entrada.
stateVisible O teclado de software ficará visível quando isso for adequado (quando o usuário navegar para a janela principal da atividade).
stateAlwaysVisible O teclado de software ficará visível 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.
adjustUnspecified Não é especificado se a janela principal do aplicativo for redimensionada para 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 selecionará automaticamente um desses modos, dependendo de o conteúdo da janela ter visualizações de layout que podem rolar o conteúdo. Se houver uma dessas visualizações, a janela será redimensionada com base na suposição de que a rolagem permitirá 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 para 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, desloca-se o conteúdo da janela 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, pois o usuário pode precisar fechar o teclado de software para acessar e interagir com as partes sobrepostas da janela.

Esse atributo foi introduzido na API de nível 3.

introduzido na:
API de nível 1 para todos os atributos, exceto noHistory e windowSoftInputMode, adicionados na API de nível 3.
veja também:
<application>
<activity-alias>