Olá a todos.
Até este tópico, aprendemos como instalar o Android, criar um projeto e até mesmo criar layouts bem completos. Qual o próximo passo? Até agora, em todos os exemplos vistos, foi utilizada no máximo uma tela por exemplo. O próximo passo a ser dado é aprender a navegar entre mais de uma tela em uma mesma aplicação.
Em Android, cada tela é uma classe Java que estende da classe Activity. Para navegarmos entre mais de uma Activity, devemos utilizar a classe Intent. A melhor tradução para esta palavra é "intenção". Se estamos em uma Activity e queremos ir para outra, temos que chamar uma Intent (ou seja, temos a "intenção" de mudar de uma tela para outra).
Para entender o conceito de Intent, criaremos 3 exemplos bem simples em que basicamente trafegaremos entre várias telas de uma mesma aplicação. No 1º exemplo, criaremos uma transição simples de uma tela para outra. No 2º exemplo, criaremos uma transição de uma tela para outra em que a tela de origem enviará uma variável para a tela de destino. No 3º exemplo, criaremos uma transição de uma tela para outra em que a tela de destino retornará um valor para a tela de origem. Este tópico do blog se dividirá entre esses 3 exemplos.
Transição simples de uma tela de origem para uma tela de destino
Em Android, quando criamos um projeto no Eclipse, é gerado o arquivo AndroidManifest.xml, que é um arquivo de configuração onde relatamos várias informações, como quais telas existem na aplicação, qual é a API mínima e a API máxima do Android que a aplicação poderá rodar, dentre outras. Logo, o primeiro passo a ser dado na criação do nosso exemplo é informar ao AndroidManifest.xml as telas que usaremos em nossa aplicação. Vamos supor que teremos 3 telas em nossa aplicação: Tela1Activity.java, Tela2Activity.java e Tela3Activity.java (é aconselhável, em Android, o nome de uma Activity possuir o posfixo "Activity"). Então, precisamos declará-las no arquivo AndroidManifest.xml, tal qual mostrado abaixo:
Agora que já temos as Activity's declaradas no AndroidManifest.xml, o próximo passo será criar o layout de cada uma dessas telas. De início, criaremos algo bem simples, como uma TextView sendo mostrada no centro da tela. Algo como isso:
Para cada tela, o parâmetro android:text="@ string/tela1_title" será adaptado para os devidos nomes (para a Tela2 por exemplo, o parâmetro será android:text="@string/ tela2_title", e com a Tela3, analogamente).
Em seguida, precisamos criar as Activity's dessas telas (as classes Java estendendo da classe Activity). Elas basicamente seguirão o modelo mostrado abaixo:
Agora que criamos todas as nossas telas, seus layout's, e as declaramos no AndroidManifest.xml, poderemos enfim lidar com as Intent's, que nos permitirão navegar dentre essas 3 telas.
Para navegarmos entre as telas, precisamos criar um dispositivo de entrada ao usuário, para que ele escolha quando essa transição entre as telas ocorrerá. O melhor dispositivo para esse caso é criar um Button que, quando clicado, mude a tela corrente da aplicação. Para isso, criaremos um Button na Tela1Activity.java e outro Button na tela Tela2Activity.java. A idéia é que a transição ocorra da Tela1 para a Tela2, e da Tela2 para a Tela3.
Modificando o layout da Tela1, teremos o seguinte conteúdo em seu arquivo XML:
E seu layout ficará como mostrado abaixo:
Agora, precisamos mapear o id do Button na nossa Activity (tal qual ensinado no tópico anterior). Modificando a estrutura do código-fonte da tela Tela1Activity.java, teremos o seguinte conteúdo:
Agora, nos restar implementar a chamada à Tela2. Para chamarmos outra tela em Android, precisamos usar uma Intent. A sintaxe de uma chamada à uma classe Intent é mostrada abaixo:
O construtor da classe Intent é: Intent intent = new Intent(packageContext, cls). O argumento "packageContext" é o contexto da Activity atual. O argumento "cls" é a classe da Activity para a qual a Activity atual deseja ir. Na imagem acima, os valores desses argumentos são, respectivamente, "Tela1Activity.this" e "Tela2Activity.class". Ou seja, temos a "intenção" de migrar da Tela1 para a Tela2.
O código-fonte completo da Tela1Activity.java é mostrado abaixo:
Agora, basta adaptarmos esse código-fonte para a Tela2Activity.java, para termos implementada a transição entre a Tela2 e a Tela3. E pronto! Teremos implementada uma aplicação com diversas telas, e com a transição entre elas.
Seguindo este tópico, iremos ver como implementar uma transição entre duas telas em que a tela de origem enviará dados para a tela de destino.
Transição de uma tela de origem para uma tela de destino com envio de informações entre elas
Na transição acima, utilizamos o método startActivity() para realizar a transição entre telas. Porém, foi uma transição simples, sem envio de informações. Desta vez, enviaremos informações de uma tela para a outra. Para realizar este tipo de tarefa, ainda utilizaremos o método startActivity(). Porém, modificaremos um pouco sua estrutura, tal qual mostrado abaixo:
A imagem acima é o conteúdo atualizado do evento onClick(). O que mudou aqui é que incluímos um Bundle na Intent que chama a próxima tela. Em Android, Bundle é a classe que armazena o que será enviado de uma tela para outra. Esta classe possui vários métodos. Na imagem acima, podemos notar o método putString(). Este método recebe a "chave" da string que passaremos para a próxima tela e o seu valor. A chave é um valor (sempre em String) que utilizaremos para obter, na tela de destino, os dados passados de uma tela para a outra.
Agora que transmitimos dados da tela de origem para a tela de destino, precisamos captar esses dados na tela de destino (neste caso, na Tela2Activity.java). Isto é feito através do método getIntent().getExtras() , que retorna um Bundle. Abaixo é mostrado o código-fonte de um método customizado que realiza essa leitura.
Algumas observações precisam ser feitas a respeito da imagem acima:
- Temos que verificar se os extras são nulos ou não. Isso é vital, pois podemos chamar uma tela a partir de diferentes telas. Por exemplo, tanto a Tela1 como a Tela2 podem chamar a Tela3. E se a Tela1 enviar dados para a Tela3, os extras da imagem acima não serão nulos. Mas se a Tela2 não enviar dados para a Tela3, os extras da imagem acima serão nulos.
- mTextView é um atributo da Tela2Activity.java, que nada mais é do que a TextView desta tela. Como estamos recebendo dados da tela anterior, para verificarmos se estes dados chegaram da Tela1 para a Tela2, atualizaremos esta TextView.
O código-fonte completo desta tela é mostrado abaixo:
E pronto! Já sabemos como transmitir dados de uma tela para outra. Seguindo este tópico, iremos ver como implementar uma transição entre duas telas em que a tela de destino retornará um valor para a tela de origem.
Transição de uma tela de origem para uma tela de destino, com envio de uma informações da tela de destino para a tela de origem
Nas transições acima, utilizamos o método startActivity(). Desta vez, utilizaremos outro método: startActivityForResult(). Com este método, a Activity de destino consegue retornar informações à Activity de origem. Isso é bem útil em alguns casos.
Por exemplo, suponha que temos uma Tela1, que pode chamar tanto uma Tela2 como uma Tela3 Neste caso, se a Tela1 for uma tela de cadastro de clientes, a Tela2 for uma tela de deleção de clientes, e a TelaC for uma tela de matrícula de clientes, ao abrirmos as telas 2 ou 3 e realizarmos alguma operação, seremos redirecionados à Tela1. Mas nesta tela, precisamos saber se a deleção/matrícula foi feita com sucesso ou não. Neste caso, precisamos enviar alguma informação de retorno à Tela1, a partir do término de execução das telas 2 e 3. Isso é feito com o método startActivityForResult().
Abaixo será mostrado um exemplo mais básico desta funcionalidade. A idéia básica é que uma Activity seja chamada na Tela1, e que a Activity filha chamada retorne uma informação à Tela1. A Tela1 poderá chamar tanto a Tela2 como a Tela3. Esta informação será captada pela Tela1 através do evento: protected void onActivityResult(int codigo, int resultado, Intent intent). Vamos ao nosso exemplo.
Abaixo é mostrado os layout XML das nossas telas.
E agora, o código-fonte da Tela2Activity.java. A Tela3 será análoga à esta tela.
Agora, vamos executar este exemplo, para fixar bem tudo que foi falado acima. Clicando no botão "Ir para Tela 2", eis o que acontece:
Agora estamos na Tela2. Clicando no botão "Voltar à tela anterior", eis o que acontece:
Basicamente, o que aconteceu foi que a Tela1 recebeu retornou de sua Activity filha. Desta forma, conseguimos identificar qual das telas foi chamada pela Tela1.
E pronto! Já sabemos como transmitir dados de uma tela para outra de todas as maneiras possíveis. Mas antes de fecharmos este tópico, iremos falar de uma propriedade de layout muito útil em Android.
Quando um botão é clicado, o ideal seria o usuário ter um feedback do que aconteceu. Ou seja, quando o botão for clicado, ficar de uma cor. Quando for solto, ficar de outra. Desta forma, o usuário saberá se o evento de clique do botão foi acionado ou não. Vamos implementar isso em nosso exemplo.
Inicialmente, iremos implementar o arquivo XML que "anima" o botão. Vamos chamá-lo de "comportamento_botao.xml". Seu código-fonte será o seguinte:
Ou seja, quando o botão for clicado, um drawable será chamado. Quando ele não for clicado, outro drawable será chamado. Agora, precisamos entender o conteúdo dos eventos citados no arquivo acima (comportamento_pressionado.xml e comportamento_normal.xml). Abaixo é mostrado o código-fonte dos respectivos arquivos citados ao lado:
- gradient → Este parâmetro escolhe a cor que o botão terá. Ele pode ter 3 cores diferentes, germinadas. No caso do nosso exemplo, teremos um gradiente de cores idênticas (as mesmas para cada opção de gradiente) em cada drawable.
- corners → Este parâmetro cria contornos suaves no botão. No nosso caso, teremos os cantos do botão levemente arredondados em um tamanho de 3dp.
- stroke → Parâmetro que traça uma borda em nosso botão. Aqui, teremos uma borda preta de 1px de tamanho.
OBS.: Existem outros parâmetros além dos 3 acima. Mas eles não serão vistos neste momento.
Agora, precisamos ativar essa animação nos botões de nosso exemplo. Para fazer isto, basta incluir o parâmetro android:background=" @drawable/comportamento_botao" em cada um dos botões de nosso aplicativo. Fazendo isso, teremos botões muito mais elegantes, e bem intuitivos ao usuário.
-----
E aqui terminamos mais um tópico do blog.
Caso alguém tenha uma dúvida, crítica ou sugestão, sinta-se à vontade.