Ao minimizarmos algum aplicativo onde o mesmo ficara oculto

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>

O valor padrão desse atributo é false.

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 por toda sua vida útil. 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.

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.

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

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.

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.

Observação: use esse atributo apenas em casos especiais para melhorar a performance e a capacidade de resposta do aplicativo. Para mais informações, consulte Gerenciar mudanças 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".

Todas essas mudanças de configuração podem afetar os valores de 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.

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

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

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.

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.

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

Se uma atividade no app incluir filtros de intent, defina esse elemento como "true" para permitir que outros apps a iniciem. Por exemplo, se a atividade for a principal do app e incluir 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.

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.

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

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

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.

"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 estar 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 uma nova instância vai ser criada e colocada na pilha. 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.

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.

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 a ela 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.

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:

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

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

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

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

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

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

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.

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.

Um valor "true" significa que a atividade não vai gerar 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.

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, leia este artigo.

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

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:

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

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.

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

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

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.

O valor pode ser qualquer uma das strings abaixo:

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.

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.

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.

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

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

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.

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.

Precisa ser um dos valores abaixo.

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.

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

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