Introdução às atividades

A classe Activity é um componente crucial de um sistema Android e a forma como as atividades são iniciadas e reunidas é um conceito como parte do modelo de aplicativo da plataforma. Ao contrário dos paradigmas de programação quais apps são iniciados com um método main(), o Android sistema inicia o código em uma instância do Activity invocar métodos de callback específicos que correspondem a estágios específicos de o ciclo de vida dele.

Este documento apresenta o conceito de atividades e traz algumas orientações simples sobre como trabalhar com elas. Para mais informações sobre as práticas recomendadas ao arquitetar seu app, consulte Guia para a arquitetura de apps.

O conceito de atividades

A experiência no app para dispositivos móveis é diferente da versão para desktop porque a interação de um usuário com o aplicativo nem sempre começa no mesmo lugar. Em vez disso, a jornada do usuário geralmente começa de forma não determinista. Por exemplo, se você abrir um app de e-mails na sua tela inicial, poderá ver um lista de e-mails. Por outro lado, se você estiver usando um app de mídia social que iniciar seu aplicativo de e-mail, você pode ir diretamente para a tela do aplicativo de e-mail para escrever um e-mail.

A classe Activity foi desenvolvida para facilitar esse paradigma. Quando um app invoca outro, o app de chamada invoca uma atividade no outro em vez do app como um todo atômico. Dessa forma, a atividade serve o ponto de entrada para a interação de um aplicativo com o usuário. Você implementa um atividade como uma subclasse da classe Activity.

Uma atividade fornece a janela em que o app desenha a interface. Essa janela normalmente preenche a tela, mas pode ser menor do que da tela e flutuar sobre outras janelas. Geralmente, uma atividade implementa uma tela em um app. Por exemplo, uma das atividades de um aplicativo pode implementam uma tela de Preferências, enquanto outra atividade implementa na tela Selecionar foto.

A maioria dos apps tem várias telas, ou seja, elas abrangem atividades. Normalmente, uma atividade em um app é especificada como a atividade, que é a primeira tela a ser exibida quando o usuário inicia o app. Cada atividade pode então iniciar outra para e realizar ações diferentes. Por exemplo, a atividade principal em um simples e-mail aplicativo pode fornecer a tela que mostra uma caixa de entrada de e-mail. A partir daí, o principal pode iniciar outras atividades que fornecem telas para tarefas como escrevendo e-mails e abrindo e-mails individuais.

Embora as atividades trabalhem juntas para formar uma experiência do usuário coesa em uma app, cada atividade é vagamente vinculada às outras atividades. existem geralmente dependências mínimas entre as atividades em um aplicativo. Na verdade, atividades muitas vezes iniciam atividades pertencentes a outros aplicativos. Por exemplo: um app de navegador pode iniciar a atividade de compartilhamento de um app de mídia social.

Para usar as atividades no seu app, é necessário registrar informações sobre elas no o manifesto do app e é necessário gerenciar os ciclos de vida da atividade adequadamente. O restante deste documento introduz esses assuntos.

Como configurar o manifesto

Para que seu app possa usar atividades, é necessário declará-las, e alguns dos atributos delas no manifesto.

Declarar atividades

Para declarar sua atividade, abra o arquivo de manifesto e adicione um <atividade> como um filho do <aplicativo> . Exemplo:

<manifest ... >
  <application ... >
      <activity android:name=".ExampleActivity" />
      ...
  </application ... >
  ...
</manifest >

O único atributo obrigatório para esse elemento é android:name; que especifica o nome da classe da atividade. Também é possível adicionar atributos que definem as características da atividade, como rótulo, ícone ou tema da interface. Para mais informações sobre esses e outros atributos, consulte a <atividade> documentação de referência do elemento.

Observação : depois de publicar o app, você não deve mudar a atividade nomes de domínio. Se fizer isso, você poderá corromper alguma funcionalidade, como atalhos de apps. Para mais informações sobre as mudanças que devem ser evitadas após a publicação, consulte coisas que não podem mudar.

Declarar filtros de intent

Filtros de intent são um recurso muito poderoso da plataforma Android. Eles permitem iniciar uma atividade com base não apenas explicit, mas também implícita. Por exemplo: uma solicitação explícita pode dizer ao sistema para “Iniciar a atividade de envio de e-mail no app Gmail". Por outro lado, uma solicitação implícita diz ao sistema para "Iniciar uma tela de envio de e-mail atividade que pode fazer o trabalho”. Quando a interface do sistema pergunta ao usuário qual app usar. na execução de uma tarefa, isso é um filtro de intent em ação.

Para aproveitar esse recurso, declare um <intent-filter> no atributo <activity>. A definição desse elemento inclui um elemento <action> e opcionalmente, um <categoria> e/ou um elemento <data> . Esses elementos são combinados para especificar o tipo de intent ao qual a atividade pode responder. Para exemplo, o snippet de código a seguir mostra como configurar uma atividade que envia dados de texto e recebe solicitações de outras atividades para fazer isso:

<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <category android:name="android.intent.category.DEFAULT" />
        <data android:mimeType="text/plain" />
    </intent-filter>
</activity>

Neste exemplo, a função <action> especifica que essa atividade envia dados. Declarar a <category> como DEFAULT ativa a atividade para receber solicitações de lançamento. A tag <data> especifica o tipo de dados que que esta atividade pode enviar. O snippet de código a seguir mostra como chamar a função atividade descrita acima:

val sendIntent = Intent().apply {
    action = Intent.ACTION_SEND
    type = "text/plain"
    putExtra(Intent.EXTRA_TEXT, textMessage)
}
startActivity(sendIntent)

// Create the text message with a string
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.setType("text/plain");
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
// Start the activity
startActivity(sendIntent);

Declarar permissões

É possível usar o arquivo <activity> para controlar quais apps podem iniciar uma atividade específica. Uma atividade pai não pode iniciar uma atividade filha, a menos que as duas tenham as mesmas permissões no manifesto do aplicativo. Se você declarar um <uses-permission> para uma atividade pai, cada atividade filha deve ter um elemento <uses-permission> .

Por exemplo, se seu aplicativo quiser usar um aplicativo hipotético chamado SocialApp para compartilhar uma postagem nas redes sociais, o SocialApp precisa definir a permissão que o app que fez a chamada precisa ter:

<manifest>
<activity android:name="...."
   android:permission=”com.google.socialapp.permission.SHARE_POST”

/>

Então, para poder chamar o SocialApp, seu aplicativo deve corresponder à permissão definida em Manifesto do SocialApp:

<manifest>
   <uses-permission android:name="com.google.socialapp.permission.SHARE_POST" />
</manifest>

Para mais informações sobre permissões e segurança em geral, consulte Segurança e permissões.

Como gerenciar o ciclo de vida da atividade

Ao longo da vida útil de uma atividade, ela passa por vários estados. Uma série de callbacks são usados para lidar com transições entre estados. As seções a seguir introduzir esses callbacks.

onCreate()

Você precisa implementar esse retorno de chamada, que é acionado quando o sistema cria seu atividades. Sua implementação deve inicializar os componentes essenciais sua atividade: por exemplo, o app precisa criar visualizações e vincular dados a listas aqui. Mais importante, é aqui que você deve chamar setContentView() para definir o layout da interface do usuário da atividade.

Quando onCreate() terminar, o o próximo callback será sempre onStart().

onStart()

Quando onCreate() sai, a atividade entra no estado Iniciado, e a atividade se torna visível para o usuário. Esse callback contém o que equivale aos preparativos finais da atividade para ficando em primeiro plano e se tornando interativo.

onResume()

O sistema invoca esse callback pouco antes da atividade começar a interagir. com o usuário. Neste ponto, a atividade está na parte superior da atividade. empilhamento e captura todas as entradas do usuário. A maior parte da funcionalidade principal de um app é implementado no método onResume().

O callback onPause() sempre segue onResume().

onPause()

O sistema chama onPause() quando a atividade perde e entra em um estado Pausado. Esse estado ocorre quando, por exemplo, o usuário toca no botão "Voltar" ou "Recentes". Quando o sistema chamar onPause() para sua atividade, isso tecnicamente significa que sua atividade ainda está parcialmente visível, mas na maioria das vezes é uma indicação de que o usuário está saindo da atividade e ela em breve entrará no Estado interrompido ou retomado.

Uma atividade no estado Pausado pode continuar atualizando a IU se o usuário está esperando a atualização da interface. Exemplos desse tipo de atividade incluem a tela do mapa ou um player de mídia em reprodução. Mesmo que essas atividades percam o foco, o usuário espera que a IU continue sendo atualizada.

Você não deve usar onPause() para salvar o aplicativo ou usuário fazer chamadas de rede ou executar transações de banco de dados. Para obter informações sobre como salvar dados, consulte Como salvar e restaurar o estado da atividade.

Quando a execução de onPause() terminar, o próximo callback será onStop() ou onResume(), dependendo acontece depois que a atividade entra no estado Pausado.

onStop()

O sistema chama onStop() quando a a atividade não fica mais visível para o usuário. Isso pode acontecer porque a atividade está sendo destruída, uma nova atividade é iniciando ou que uma atividade existente esteja entrando o estado "Retomado" e abrange a atividade interrompida. Em todos esses casos, a atividade interrompida não é mais visíveis.

O próximo callback que o sistema chama é onRestart(), se o a atividade retorna para interagir com o usuário ou onDestroy() se esta atividade estiver sendo completamente encerrada.

onRestart()

O sistema invoca esse callback quando uma atividade no estado Interrompido é prestes a reiniciar. onRestart() restaura o estado da atividade desde o momento em que ela foi interrompida.

Esse retorno de chamada é sempre seguido por onStart():

onDestroy()

O sistema invoca esse callback antes que uma atividade seja destruída.

Esse é o último callback que a atividade recebe. onDestroy() é geralmente implementados para garantir que todos os recursos de uma atividade sejam liberado quando a atividade ou o processo que a contém é destruído.

Esta seção é apenas uma introdução a esse tema. Para uma tratamento detalhado do ciclo de vida da atividade e seus callbacks, consulte A atividade Lifecycle.