Android parte 2: avançando com listeners, menu e UI

Carregando aluno no formulário - Introdução

Opa, pessoal. Beleza? Eu sou o Alex Felipe, instrutor aqui da Alura, e vou apresentar para vocês a segunda parte do curso de fundamentos do Android. Isso significa que daremos continuidade ao mesmo projeto que foi desenvolvido no primeiro curso de fundamentos do Android, portanto, eu vou exigir que você tenha todo o conhecimento que foi visto dentro do primeiro curso, dado que nesse curso a gente vai avançar com o que já foi implementado. Então, dada essa ideia de avanço, o que a gente vai fazer aqui durante esse curso? A nossa ideia, a princípio, vai ser completar um CRUD, que é justamente aquela ideia de poder inserir, poder pegar os dados, fazer atualizações e também remover aqui os nossos dados. No primeiro curso, o que a gente conseguiu fazer? A gente conseguiu fazer a nossa listagem, que seria justamente a seleção, e a gente conseguiu também adicionar alunos. Por exemplo, eu vou adicionar o Gui e a gente consegue fazer isso sem nenhum problema. Conseguimos fazer isso tudo no primeiro curso. Agora, nesse curso, a gente vê que existe uma necessidade, por exemplo, de poder editar essas informações, dado que, de repente, o Gui, você também queria colocar um sobrenome. Então, você vai ter a possibilidade agora, tocando aqui no aluno, então colocando a informação que você espera, que, no caso, é o Gui Silveira que está participando com a gente. A gente vai lá e salva de novo. A gente vai aprender como a gente pode estar fazendo isso, seja essa técnica de clicar no aluno específico, seja essa técnica de mandar em formulário e também editar. Percebe que agora o nosso formulário vai ter essa capacidade flexível de tanto inserir aluno como também editá-lo. Isso a gente vai acabar aprendendo durante o curso. Claro, para poder remover a gente sabe que também precisa fazer uma ação, dado que gente já usa o click, o que a gente poderia fazer? Para isso, a gente vai aprender que, aqui no Android, existem outros tipos de ações que são comuns, como é o caso dessa ação que a gente clica, segura e pressiona aqui o elemento. Essa técnica a gente conhece como “clique longo” aqui como desenvolvedor, tudo bem? A gente vai aprender como a gente pode estar explorando ela justamente para dar essa opçãozinha que eu estou mostrando para você, que é esse menuzinho, que é conhecido como menu de contexto. A gente vai ver que ele é referente aos nossos menus de botão direito dos sistemas operacionais. Quando a gente toca em um botão direito, a gente tem a equivalência nesse menu de contexto. Ambos são menus de contexto e a gente vai ver como a gente pode implementar aqui no Android. Como a gente pode ver aqui, nosso menu de contexto, a gente tem a opção de remover. Se a gente tocar aqui em “remover”, ele vai lá e remove. Da mesma maneira, se a gente não tocar na opção, ele vai lá e não remover. A gente vai ver que isso se faz necessário justamente para que os nossos usuários, que usam o nosso aplicativo, ele tenha consciência suficiente do quão impactante vai ser aquela opção, tudo bem? E a gente vai ver como a gente pode estar lidando com isso e deixando de uma maneira ideia para o nosso usuário. Claro, também como a gente pode ver aqui, o nosso formulário teve uma certa diferença: antes a gente tinha um botãozinho aqui embaixo e agora a gente tem esse menuzinho aqui em cima, que é um menu de opções. Então, perceba que, durante esse curso a gente vai explorar um pouquinho mais sobre essa ideia de menus. Como a gente pode estar criando menus, quais são os cuidados que a gente precisa ter e qual é o benefício de utilizá-los, afinal, por que a gente migrou de um botão para esse menu? A gente vai entender que isso pode ser beneficente dependendo do dispositivo, como é o caso do tamanho do dispositivo, quanto da tela que vai ocupar, entre outros detalhes. Perceba que a gente vai realmente avançar no conteúdo. Vão ser novos desafios que a gente vai acabar encarando, vão ser novos detalhes que vão ser comuns no seu dia-a-dia, independente do seu projeto Android. Eu espero que você esteja contente com a proposta do curso, eu espero que você esteja animado para começar a fazer e eu conto com a sua participação. Até já.

Carregando aluno no formulário - Encontrando erros com o logcat

Atualmente o nosso app é capaz tanto de listar como também cadastrar alunos, porém se a gente adicionou o aluno com alguma informação que a gente não espera ou se, de repente, a gente quer adicionar informações a esse aluno, atualmente a gente não tem essa capacidade, dado que o nosso aplicativo não permite editar os nossos alunos, portanto agora para possibilitar mais opções para o nosso usuário, a gente vai começar a implementar essa feature de uma tal maneira que vai facilitar a edição dessas informações quando for necessário, está bom? Então vamos lá. Considerando aí as abordagens que a gente já conheceu no curso anterior de android o que é que a gente pode estar fazendo para poder começar a implementar esse tipo de funcionalidade, para isso a gente precisa ali começar com uma ação, certo? Como, por exemplo, para cadastrar a gente clica aqui no nosso floating action button e ele abre o formulário para gente colocar o novo aluno, bacana. Só que agora a gente precisa editar, então a gente tem que ter uma ação exatamente no momento que a gente quer editar ali um aluno no próprio aluno, então aqui, nessa caixinha aqui do aluno, certo, a gente também precisar adicionar agora um listener de clique, que aí dessa maneira a gente vai ter a capacidade de adicionar um comportamento novo que vai permitir a edição. Então vamos trabalhar primeiro com o listening e vamos ver o que acontece para poder implementar aqui esse listener, está bom. Então vamos lá, como a gente já viu, para adicionar o listening a gente precisar setar esse listening a partir do setOnClickListener. Então vamos voltar lá na nossa activity, crtl n para entrar numa classe, lista alunos activity, e agora aqui dentro dela a gente precisa achar, por exemplo, o método no qual ele busca ali a referência ali da nossa ListView para que então a gente set o listener, para isso a gente já sabe que a gente está ali no nosso onResume e dentro do onResume a gente tem o configura lista, aí aqui dentro do configura lista a gente pega a referência dele que a gente chamamos aqui de lista de alunos. Então depois que a gente seta o adapter agora a gente vai setar o nosso listener, para isso a gente chama aqui a referência lista de alunos.setOnClickListener. A gente já sabe que a gente vai implementar aqui via classe anônima com o nosso View.OnClickListener, bacana. E aqui a gente tem o nosso OnClick que representa ali a ação que vai ser executada quando o clique acontecer, para a gente ver se realmente está funcionando, certo, a gente pode estar colocando aqui um Toast como a gente fez ali anteriormente no nosso floating action button. Então aqui eu coloco um Toast, a gente vai usar aquele templete que ele já oferece para a gente, ele já completa o que ele consegue completar, aí na parte aqui da String vai sair a mensagem, a gente pode colocar alguma coisa diferente para identificar que é o click do nosso ListView. Então click do ListView, beleza? Bacana. Aí eu só vou estender um pouquinho o código para ficar mais fácil de ver, dá uns enters aqui nesses argumentos para ficar também fácil de ver o código numa única view aqui sem ter que ficar fazendo o init. E agora que a gente fez essa implementação a gente pode testar o nosso aplicativo para ver o que acontece, está bom. Para isso o que é que a gente vai fazer? A gente vai executar aqui, vou escolher o emulador que já está de pé e quando ele terminar aqui a gente vai ver o que vai acontecer, está bom? Nesse primeiro momento eu quero aguardar até o final para mostrar uma coisa nova para vocês. Então vamos lá, a gente está aguardando, ele executou, ele tentou abrir e percebe que ele vai tentar abrir, mas não consegue, esse é realmente o comportamento novo que eu quero mostrar para vocês, está bom? Eu vou executar de novo e vocês vão ver acontecendo. Então executando aqui de novo, vamos ver o que acontece, ele vai tentar executar tudo bonitinho e ele vai abrir ali o aplicativo e ele vai sair, tudo bem. O que é que significa isso? Veja que ele até apareceu essa mensagem nova falando que o agenda, que é o nosso aplicativo, ele está se mantendo de uma maneira que ele está sempre ali parando, tudo bem, e ele está falando: “Olha, você quer fechar essa aplicativo?”, sim, a gente quer fechar nesse momento e agora a gente vai começar a entender o que isso significa. Bom, cada vez que a gente está executando aqui o nosso aplicativo a gente sabe que no momento que ele tudo funciona realmente ele vai aparecer ali a tela, a gente vai ter as interações esperadas, porém vai existir situações nas quais algum comportamento que a gente quer que funcione ele não vai funcionar e nessa situação que ele não vai funcionar ele vai lançar aquelas famosas exceções do Java fazendo com que o nosso aplicativo quebre, que foi exatamente o que aconteceu aqui, tudo bem. Então quando o nosso aplicativo ele quebra ele vai tentar executar e ele vai lá e fecha automaticamente, é dessa maneira que o android acaba funcionando aqui como sistema operacional para controlar aqui os aplicativos. Então se tiver uma exceção ele vai lá e vai quebrar o aplicativo. Vai ser muito comum também você escutar que nesse tipo de situação vai ser chamado de crash do aplicativo ou crash do app, então toda vez que você escutar: “O aplicativo ele crashou” ou algo do gênero é justamente essa ideia de que o aplicativo quebrou, teve algum problema que não foi tratado muito bem ou então o código mal escrito entre outras possibilidades, está bom. Mas agora vem a questão: como que a gente pode identificar o problema que aconteceu, certo? Dada as abordagens que a gente viu nesse momento, para isso o Android Studio ele também tem uma ferramenta de análise de log que vai permitir com que a gente veja todo o log durante a execução do nosso aplicativo, para acessar esse log, certo, a gente vem aqui nessa parte de baixo do Android Studio e aqui nessas abinhas que tem aqui terminal, a gente tem aqui o build e temos esse aqui logcat, entre essas outras possibilidades, dentre elas a gente tem esse logcat que é justamente esse carinha que vai ficar responsável em analisar todo o logo do nosso dispositivo, está bom? Então se a gente vê aqui algumas das opções a gente percebe que logo aqui no começo ele está selecionando qual que é o dispositivo que ele está ali investigando o log, se de repente você tivesse mais de um dispositivo de pé, seja outro emulador ou seja um dispositivo físico, ele também abriria essa possibilidade e mostraria de qual o dispositivo que ele está fazendo log. Então é muito importante você primeiro olhar qual que é o dispositivo para ver se é realmente o que você espera, porque se de repente você quiser encontrar um log e o dispositivo que você está executando, mas aqui está marcando um outro dispositivo que está em tempo ocioso você não vai conseguir investigar isso, está bom. Então fique bem atento nessa primeira opção. Bacana. Logo em seguida ele fala exatamente qual que é o pacote do aplicativo que ele está analisando, percebe que ele tentou analisar ali do nosso aplicativo e ele está falando com essa mensagem de dead, que ele está morto porque realmente esse foi fechado. E aí ele não está fazendo só essa análise, ele está pegando também de outros pacotes aqui também que aí vai de outros aplicativos, serviços disponíveis aqui no nosso celular. Aí beleza, bacana, a gente tem todos esses logs e realmente fica muito difícil de analisar, certo, dado que esses logs aqui podem ser de qualquer outra coisa que não tem relação com o nosso aplicativo, aí para isso, para a gente facilitar essa busca a primeira coisa que eu vou sugerir para vocês é o seguinte: é logo aqui nessa última opção a direita que está indicando “no filters” é você clicar nela e mostrar... e, aliás, selecionar a opção show only selected application, o que é que isso significa? Que ele vai mostrar apenas o log da nossa aplicação, está bom? Que aí dessa maneira a gente vai ter uma capacidade muito mais poderosa de analisar aqui o nosso log porque vai mostrar apenas o que aconteceu do nosso aplicativo em relação ao que a gente implementou, está bom? Então eu vou clicar nessa primeira opção e olha só ele já filtra bastante aqui esses logs e agora só mostra logs que estão relacionados ao nosso pacote, está vendo? BR com Alura agenda. Então é dessa maneira que a gente facilita a busca aqui de log que se acaso acontecer algum problema, isso a gente vê, como eu havia comentado, a gente tem aqui uma exception, a gente tem uma RuntimeException nesse caso e ele está falando que foi exatamente ali no resumo da nossa activity, no momento em que tentou ali configurar a nossa lista. Se a gente vir um pouquinho mais à direita a gente sabe que a gente tem a descrição aqui da nossa exception e aqui ele está falando o seguinte, ele está falando exatamente aqui a mensagem que essa RuntimeException passou, que ele está falando: olha, não chame o setOnClickListener para um AdapterView. Então a gente fez isso e foi exatamente isso que desencadeou ali aquela expection. E além disso ele está falando: olha, muito provavelmente aí você está querendo fazer a configuração do setOnItemClickListener ao invés de você usar ali o seu OnItemClickListener. O que é que isso significa, pessoal? Significa que cada vez que a gente quiser aplicar um tipo de listener para um AdapterView a gente não vai conseguir usar o setOnClickListener, a implementação de setOnClickListener é por padrão lançar essa exception e aí sugerir a implementação desse setOnClickListener. Porque é que isso acontece? Porque quando a gente faz ali o set de click listener para um ListView muito provavelmente a gente não quer que o componente inteiro ListView ele tenha o listenter, a gente quer que seus elementos, seus itens tenham o listener que é o que a gente quer realmente para os nossos alunos, clicar em cada um deles. Então por isso que já foi implementado essa ideia de que se a gente vai colocar um listener por ListView faz ali o crash da aplicação e já indica: olha, você não usar isso e use, sim, esse outro carinha aqui que vai perceber o listener para cada um dos elementos. Então ao invés de a gente usar ali o nosso OnClick aqui que é o nosso OnClickListener a gente vai usar esse outro método aqui, está bom. Então vamos lá, para isso eu vou copiar aqui já para facilitar a nossa vida, eu vou remover esse código aqui, deixa eu só estender aqui, ctrl shift F12, e agora eu vou implementar esse outro método aqui, está bom. Aí veja que ele já tem esse outro método, repare também que esse método é exclusivo aqui de AdapterViews está bom, então se de repente você tentar fazer isso em uma outra view talvez não exista ele, então é um fato bem importante. E agora aqui dentro a gente vai implementar uma outra interface para a gente ver aqui, a gente pode tentar autocompletar e ele mostra que agora ele vai implementar uma interface do AdapterView e não da view, que é o AdapterView.OnItemClickListener. Vamos dar um enter aqui e vamos ver o que acontece. Aí percebe agora é um outro método totalmente diferente do OnClick, certo? Porque o OnClick ele aparecia apenas a view, a gente pode ver aqui diretamente quando a gente tem a implementação do setOnClickListener do floating action button e agora a gente tem esses quatro argumentos, certo? A gente tem bastante argumento aí que a gente pode estar tentando trabalhar, bacana. E vamos agora tentar entender esses argumentos. Como a gente pode ver esse primeiro argumento ele refere-se justamente ao AdapterView que nesse caso é nossa ListView, esse outro elemento ele representa a view que foi clicada, então, por exemplo, se eu clicar aqui no Alex, que é aquele que está aparecendo, ele não vai fazer isso agora porque ele quebrou, mas se eu clicasse nele ele representaria por meio dessa view. E aqui esses dois que está como I e L ainda não tem muito significado para a gente. E agora eu vou tentar traduzir aqui para vocês e a gente já vai colocar um nome que faça sentido. Nesse terceiro argumento a gente tem a posição do elemento, tudo bem? Então, por exemplo, quando a gente teve aí o Alex muito provavelmente ele tem a posição zero, dado que o índice aqui em programação costuma ser zero, e aqui no final a gente tem uma informação que representa o ID, está bom? Em AdapterViews quando a gente acaba utilizando ali os adapters muito internamente tem a capacidade de trabalhar também com IDs. Nesse momento a gente não vai falar muito a respeito, mas entenda que tem essa possibilidade e é por isso que ele vem também aqui na ação de clique do item, está bom? Bacana, então a gente tem essas informações, mas agora, dado que a gente tem essas informações, o que é que a gente pode estar utilizando delas para poder ali começar com o que a gente espera que é pegar um aluno e poder editar. Se a gente perceber bem a gente sabe que a posição é um grande candidato para que a gente consiga recuperar esse aluno, dado que a gente tem uma lista de alunos aqui disponível, certo? Então vamos fazer o seguinte, dado que a gente quer explorar essa parte da posição, ver se realmente funciona como o esperado, vamos agora imprimir essa mensagem aqui com a posição do aluno e vamos ver se realmente ele vai ali obedecer conforme o que é esperado. Então, por exemplo, é um aluno que está na primeira posição vai aparecer a posição zero, é um aluno que está segunda posição vai aparecer a posição um, vamos ver como é que isso funciona. Aí a gente para poder colocar isso a gente colocaria ali um Toast, certo? Só que agora eu vou mostrar uma abordagem um pouquinho diferente agora que a gente aprendeu sobre aqui o nosso logcat, tudo bem? Eu vou ensinar para vocês como que a gente pode estar colocando aqui logs diretamente aqui no logcat para a gente conseguir fazer esses testes, está bom, que aí dessa maneira se caso você precisar debugar o seu aplicativo ou então você quer colocar uma mensagem de feedback, mas que não fique visual assim como é o Toast você pode estar usando essa ferramenta, está bom? E aí para a gente colocar esse log, pessoa, a gente tem um templetezinho também, então deixa eu estender aqui o código, que é esse templete aqui: log, está vendo? Log. Então quando a gente coloca esse log aqui, log e i no final ele já fala que ele já vai colocar esse templete que é da classe log.i, então se a gente colocar aqui, olha só, log i e aí ele já tenta autocompletar aqui para a gente. Essa tag aqui ele vai indicar o seguinte, vai ser uma chave na qual a gente vai conseguir identificar esse nosso log ali dentro do logcat, porque como a gente viu é um log muito grande e as vezes fica difícil de a gente identificar, tem que ficar fazendo ação e assim por diante, aí se a gente coloca aqui essa tag a gente tem a capacidade até mesmo de filtrar por meio desse filtro aqui que temos aqui em cima, está bom? Então é por isso que temos essa tag aqui. Então nessa tag a gente pode implementar aqui uma constante que tenha essa tag ou então a gente pode colocar até mesmo uma string, por exemplo, a posição do aluno, a gente pode colocar posição aluno por exemplo, aí aqui do lado a gente pode colocar realmente o valor que a gente espera para esse log, então para esse log a gente quer pegar exatamente a posição concatenada, então eu vou concatenar a posição aqui. Então é dessa maneira que a gente acaba colocando aqui uma mensagem de via log que vai ser acessível aqui no nosso logcat. Então agora que a gente colocou o listener no item e também a gente colocou um log vamos executar o nosso aplicativo e vamos ver o que acontece, está bom? Então shift F10 para executar o nosso aplicativo, eu vou deixar o logcat aberto para a gente ver o que é que vai acontecendo aqui durante essa execução, está bom. Então eu vou até deixar ele aberto aqui bem grandão e percebe que ele vai mostrando aqui vários logs, aparentemente ele não quebrou, então não quebrou mesmo o nosso aplicativo e aqui ele apareceu tudo bonitinho para a gente. Então agora o que é que eu vou fazer, eu vou cadastrar um aluno da maneira como a gente estava acostumado, então eu vou colocar o Alex aqui, eu vou salvar e beleza, a gente tem nosso Alex. Agora a gente quer testar aquele novo comportamento, certo, que é o nosso novo listener, então eu vou clicar aqui e vamos ver o que acontece. Olha só que bacana, ele está aparecendo aqui, eu vou clicar várias vezes e olha só: ele aparece aqui o Alex, está bom. Então percebe que agora a gente tem uma outra maneira de pegar um feedback aqui por meio do Android Studio quando a gente está desenvolvendo, porque o Toast por mais que ele funcione, ele já fica ali no emulador, a gente não precisa nem usar o Android Studio, ele tem também um probleminha que é justamente a gente ter que ficar ali vendo a parte visual, de repente a gente clica, ele passa o tempo, a gente não consegue ver da maneira esperada. Com o log a gente tem a capacidade de fazer os cliques, saber quantos cliques aconteceram, isso é uma informação importante também e essa informação ela não se perde. Então a gente vai conseguir testar, a gente vai conseguir fazer o mapeamento, a gente vai ter maior poder em relação a essa parte de log, em relação ao feedback da nossa implementação, está bom? Bacana. Vamos só cadastrar agora mais um aluno para ver se realmente ele funciona como o esperado, então eu vou colocar aqui a Fran por exemplo e vamos só ver se nessa parte, a posição, então aqui no Alex é posição zero e na Fran a posição um, a gente consegue ter o que a gente espera, sim, a gente consegue. Então agora sim a gente conseguiu dar o primeiro passo e também a gente aprendeu a usar aqui o nosso logcat. Aí só para poder fechar essa parte do logcat e aí logo em seguida a gente avançar nessa parte da edição do nosso aluno, um outro fator bem importante é que a gente tem aqui os tipos de logs, então ali quando a gente fez esse log.i o que a gente implementou foi esse de info, então se a gente só colocar esse de info não vai aparecer nenhum outro tipo de log a não ser o de info, também da mesma maneira se fosse esse também a gente teria só informações. A gente percebe também que para poder identificar tem esse w/, também no caso do i a gente vai ter o i/, então é dessa maneira que a gente acaba trabalhando aqui com os logs, de repente você quer colocar um log que realmente ele vai acontecer por causa de um erro, aí você vai lá, coloca o log e filtra aqui por erro, então, por exemplo, se eu colocasse aqui um e ele mostraria ali e seria um erro. Eu vou só executar por questões de teste mesmo, inclusive para poder testar posteriormente o que é que eu vou fazer para a gente não ter que ficar cadastrando na mão. Logo no começo do onCreate mesmo eu vou pegar aqui a nossa referência e vou salvar dois alunos, que aí dessa maneira a gente consegue ficar testando sem ter que ficar colocando no formulário. Então eu vou deixar Alex, aqui as informações de telefone eu vou deixar aqueles padrões que eu estou acostumado a deixar, e aí dessa maneira facilita o nosso teste ao invés de a gente ficar ali colocando manualmente via formulário. Então eu fiz o primeiro aluno, agora eu vou fazer o segundo aluno, que vai ser aluna, vai ser a Fran. Então eu vou deixar o mesmo telefone e a coisa que eu vou mudar é o e-mail, o e-mail eu vou deixar fran@gmail.com, está bom? Então esses são dos dois alunos que eu vou usar como exemplo porquê dessa maneira a gente vai facilitar aqui o nosso teste. Então agora eu coloquei um log de erro para a gente ver o que acontece, para ver se realmente ele filtra aqui para a gente, e assim que ele executar aqui o nosso aplicativo a gente vai fazer esse teste. Vamos ver se ele coloca os alunos para a gente, já colocou os alunos, dado que a gente está usando, agora eu cliquei e ele já mostra aqui o Diego. Agora eu vou deixá-lo que ele vai mostrar todas as possibilidades e agora sim a gente vê que a gente tem os nossos logs aqui, cada vez que a gente clica aqui no nosso aluno ele já faz ali o log bonitinho para a gente. Aí só para poder estar reforçando: se você não vai ser um erro, deixa o i mesmo que é o log de info que é o que é esperado, está bom? Sempre entenda, que cada vez que você usar esses logs você tem que usar consciente, então no geral vai ser o de info, mas aí se tiver alguma outra ação em relação a essas outras possibilidades, aí você pode estar usando sem nenhum problema. Bacana, a gente aprendeu sobre log, a gente aprendeu sobre o listener para cada um dos elementos do AdapterView, a seguir a gente vai trabalhar em cima desse carinha aqui, desse nosso novo listener para possibilitar a edição. Então até já.

Carregando aluno no formulário - Transferindo dados entre Activities

Conseguimos implementar um listener para cada um dos alunos, pegamos a sua posição, mas até agora a gente não conseguiu pegar a referência do aluno aqui dentro do nosso código, sendo assim, antes de a gente começar a implementar a solução que vai editar esse aluno, primeiro a gente tem que ter ele, certo? Então vamos pegar esse aluno, para isso o que é que a gente precisa fazer? A gente tem que ter acesso a lista que está todos os alunos, que é justamente a lista que é devolvida aqui nesse dao .todos. Então o que é que eu vou fazer, pessoal? Eu vou fazer o seguinte, eu vou extrair esse dao. Todos para uma variável, que aí ela vai ser acessível, tanto dentro do argumento aqui da init adapter como também no nosso lister, está bom? Então vamos lá. Para isso eu vou usar o .var que ele vai criar uma variável local e vou chamar ela de alunos, está bom? Bacana. Agora que a gente acesso aos alunos o que é que eu vou fazer vai ser o seguinte: logo antes de chamar aqui o log eu vou chamar os alunos get e vou passar a posição. E aí dessa maneira a gente identifica que esse aluno aqui é justamente o aluno escolhido, certo? Então vai ser a partir desse aluno escolhido que a gente vai trabalhar aqui com a ação de editar, e aí como a gente já sabe dado que a gente está usando uma variável local dentro de uma implementação de classe anônima ela tem que ser final, certo? E a gente pode usar a técnica do Android Studio ou simplesmente escrever final que aí já possibilita, está bom? E aí ao invés de usar ali a posição a gente pode até colocar diretamente o aluno escolhido, tudo bem. Se a gente deixar dessa maneira ele vai usar o to string que, por padrão, faz o print do nome. Ao invés de deixar a tag como posição do aluno a gente coloca apenas aluno, está bom? Bacana. Vamos só testar, antes de a gente continuar com os próximos passos para a gente ter certeza se funciona como o esperado. Então vou dar um shift F10 aqui, como a gente sabe a gente está trabalhando com o log, então para a gente testar a gente vai abrir aqui o logcat, está bom, e vamos abrir aqui o nosso emulador. Um detalhe que é bem bacana, pessoal, é o seguinte: percebe que esses logs que acontece logo no começo a gente não quer muito utilizá-los dado que não tem tanta importância para a gente, portanto o que a gente pode fazer é apagá-los. Então a gente vem aqui nesse botãozinho que é chamado de clear logcat e ele já limpa ali todos os logs que aconteceram durante a execução, e agora só vão aparecer os novos logs que seria referente, por exemplo, aos cliques, está bom? Isso facilita justamente para poder identificar ali o log que a gente quer identificar, está bom? Então vamos lá, voltando aqui o nosso aplicativo se eu clicar aqui no Alex ele está falando que pegou o Aluno Alex, tudo bem, agora se eu clicar aqui na Fran ele também indica que pegou o aluno Fran, está bom. Então realmente a gente tem a capacidade agora de pegar esses alunos dado o clique que a gente faz neles, e agora sim a gente precisa encontrar algum tipo de solução que vai permitir essa edição, está bom. Se a gente pensar nas possibilidades do nosso aplicativo uma das ideias bacanas que a gente poderia considerar seria a seguinte: quando a gente clica, por exemplo, em um aluno a gente poderia abrir o nosso formulário que a gente já tem pronto, está bom, e nesse formulário que a gente já tem pronto a gente já poderia preencher esses campos com as informações do aluno, então quando a gente tivesse as informações do aluno e fizesse as alterações a gente clicaria novamente em salvar e ao invés de salvar esse aluno novamente ele iria lá e faria a edição, está bom? Então é justamente esse comportamento que a gente vai implementar para poder editar o aluno. Então agora que a gente tem o aluno a gente vai abrir essa nossa activity enviando esse aluno, que aí dessa maneira a activity vai ter acesso a ele vai conseguir fazer as edições da maneira esperada, está bom. Então vamos fazer esse tipo de implementação, vamos lá. Para isso o que é que a gente tem que fazer, pessoal? A gente tem que abrir ali a nossa activity, a gente já aprendeu que para abrir uma activity a gente tem que usar ali o nosso intent, certo? Então deixa eu apagar aqui o nosso log e agora vamos colocar ali a nossa instância da intent, então new intent e vamos colocar que aqui a gente está na referência da nossa lista alunos activity como contexto, certo, então o this dela e a gente vai entrar justamente no nosso formulário, então é formulário aluno activity.class, está bom? Bacana. A gente tem aqui agora o nosso intent que ele vai representar a nossa intenção que é vai para formulário activity, certo? E agora a gente tem que fazer a inicialização, bacana, então a gente vai lá e coloca o start activity. Beleza. Se a gente só colocar desse jeito, pessoal, a gente vai ter exatamente o mesmo comportamento que o nosso floating action button faz, certo? O que é que ele faz? Ele vai lá, abre o formulário e ele faz exatamente o que a gente está fazendo aqui agora, tudo bem, a gente está fazendo apenas a inicialização. E o que é que a gente precisa fazer de diferente? A gente precisa mandar essa informação e até o momento a gente não executou isso, e para a gente conseguir mandar essa informação a gente vai ter que explorar um pouquinho mais sobre o que a intent tem aqui para nos oferecer. Dentre as opções existentes uma que é bem comum para transferir dados entre as activitys é um recurso conhecido como extra, nesse extra a gente vai ter a capacidade de transferir qualquer tipo de dado, então a gente vai ter a capacidade de transferir dados primitivos como também objetos. Então se a gente utilizar aqui o nosso vai para formulário activity a gente percebe que eles têm alguns métodos que se tratam desse extra a partir de um put, esse put ele refere-se justamente aquela estrutura de dados conhecido como map que vai ter uma chave e um valor. Então aqui, olha só, a gente tem um put extra que ele recebe uma string, que ele recebe um inteiro, recebe um char, está vendo, então a string ela representa aqui a chave justamente da mesma maneira que a gente usou ali no nosso log e logo na parte direita, que é o segundo argumento, seria o valor, então veja que ele tem diversos tipos de valores que ele recebe, está bom? Então agora vamos implementar aqui um que vai receber uma chave que vai receber uma chave que vai representar o nosso aluno e como segundo argumento ele vai mandar ali o nosso aluno, está bom. Então vamos lá, put extra, agora a gente tem diversas sobrecargas aqui para poder estar preenchendo, então aqui a gente vai colocar uma chave para poder identificar o aluno a gente pode escrever aqui uma string chamada aluno, não tem nenhum problema. E agora a gente tem que mandar o nosso aluno escolhido, então a gente coloca aqui aluno escolhido, está bom, aí dessa maneira a gente vai estar mandando vai extra para outra activity. Aí perceba o seguinte: quando a gente utilizou essa abordagem ele acabou dando erro de compilação, porque é que isso acontece? A gente tentar ver um pouquinho do erro ele não dá muitas informações porque é que esse erro acontece, e realmente é bem comum isso acontecer, não se assuste, então agora eu vou passar para vocês o motivo de isso acontecer. É que é o seguinte, pessoal, para a gente conseguir mandar dados via extra esse tipo de dado ele tem que ser serializado, ou seja, ele tem que ser capaz de ser transformado em bytes e de bytes para objetos, e da maneira como a gente implementou a nossa classe aluno ela não tem essa capacidade, e como é que então a gente consegue fazer com que ela seja seriável, que ela consiga aí se transformar em bytes e de bytes voltar para o objeto aluno? Para isso a gente pode usar uma técnica bem simples, então se a gente vim aqui no nosso aluno, certo, ctrl N aluno a gente tem uma interface do próprio Java que já permite isso, então a gente coloca implements serializable. Então esse serializable ou da maneira que você preferir chamar, ele tem essa capacidade aí de converter os nossos objetos para bytes e daí de bytes para objetos, e aí quando a gente faz essa implementação do serializable a gente volta aqui para o nosso put extra e ele volta a compilar, e é dessa maneira que a gente consegue transferir objetos nossos para outras activitys. Se fosse, por exemplo, inteiros, strings ou valores primitivos não teríamos esse problema, mas para objetos exclusivos nossos a gente tem que estar transformando eles em um tipo de objeto que é capaz de serializar, está bom? Bacana, pessoal. Então agora que a gente está mandando esse dado, lá no nosso formulário a gente precisa recebê-lo, certo, porque se a gente executar o nosso aplicativo olha só o que vai acontecer, ele vai ter exatamente o mesmo comportamento do floating action button, certo, eu posso mostrar para vocês, para vocês verem acontecendo, não vai ter nenhuma diferença a não ser que dê algum tipo de crash, eu imagino que não, mas é realmente o mesmo comportamento, não muda nada. Então o que a gente precisa fazer agora é preencher essas informações, certo? Então agora a gente vai entrar no nosso formulário, então ctrl B na referência dele, e logo no começo quando ele cria aqui tudo bonitinho para a gente, a gente vai agora preencher esses campos, está bom, então vamos lá. Para isso eu vou fazer logo depois que ele faz toda a configuração necessária, que ele faz as inicializações e assim por diante e aí para que então a gente não tenha nenhum tipo de problema, porque de repente ele não encontrou ali as views ou alguma coisa do gênero, está bom. Então agora vem a questão: como a gente pode pegar esse aluno, certo? Como que a gente pode pegar aquela informação que a gente está mandando? Da mesma maneira a gente tem a capacidade pegar a capacidade de pegar a intent também dessa nossa activity, então se a gente chamar o método get intent a gente vai ter a capacidade pegar a intent que veio para ele, então aqui a gente pode extrair uma variável para chamar de dados, por exemplo, que é o que a gente está querendo lidar aqui. E agora, a partir desses dados, além de fazer o put extra que a gente conseguiu ver ali a gente tem também o get extra, então se a gente fazer aqui dados.get extra a gente vai ter a capacidade de pegar essas informações, está bom. Aí percebe que quando eu fiz esse get extra, diferente de um put extra, ele tem vários tipos de implementações diferentes, então extra seria ali um init que seria tudo completo, todos os extras possíveis, e aqui tem extras especializados, que é justamente a partir desses que a gente vai conseguir pegar a informação diretamente que a gente precisa, está bom. Então veja que a gente tem um boolean, a gente tem um init, um byte, e assim por diante. E dado que a gente mandou esse serializable extra a gente vai usar exatamente ele, porque foi exatamente esse tipo de dado que a gente mandou, está bom? Se fosse algum outro tipo de dado você usaria esse outro tipo de dado. Então vamos lá, get serializable extra, aí agora o que é que ele espera é o seguinte, é exatamente aquela chave que a gente mandou, está bom, que ele refere-se como name. Então aqui a gente vai deixar como aluno e o que a gente espera aqui é que ele devolva um aluno, é claro que se a gente usar ali o var para poder extrair uma variável aqui a partir desse retorno ele vai devolver como serializable porque é essa interface que ele utiliza, mas a gente tem a certeza de que esse aluno aqui é o aluno que a gente está mandando. Então, por exemplo, a gente pode deixar como informação de aluno como nome da variável e podemos mudar manualmente de serializable para aluno, está bom, a gente pode estar fazendo isso. Mas é claro, quando a gente faz essa conversão percebe que ele dá esse erro de compilação, isso acontece justamente porque a interface que foi utilizada aqui ela não está utilizando o generics, certo, ela exige que seja exatamente um serializable, está bom? Então por isso que está dando esse problema. Para poder resolver isso a gente tem que usar o nosso famoso cash, não é a maneira mais segura que a gente conhece, certo, mas é dessa maneira que a gente acaba abordando usando aqui essa interface do get serializable extra. Legal, a gente tem o aluno, agora que a gente tem acesso a esse aluno a gente pode preencher os nossos campos, certo? Então podemos, por exemplo, pegar a referência do campo nome, dado que ele já faz a inicialização dos campos aqui, então a gente não precisa se preocupar, e podemos setar o texto, então set text pegando aqui o aluno get name, get name não, get nome, acabei falando inglês, mas é get nome. Mas a gente ainda não tem esses getters, certo, dado que a gente não estava utilizando eles. Então antes de tudo o que é que eu vou fazer? Eu vou entrar aqui na nossa classe aluno e vou gerar os getters dessas informações, que aí dessa maneira a gente vai conseguir preencher todos os campos, para isso eu vou usar o template aqui que é o out insert getter, está vendo, aí aqui eu vou selecionar todos eles, está bom? Eu coloquei o shift e setinha para baixo e selecionou todos, eu vou dar um ok e ele gera aqui todos os getters para a gente, aí agora assim a gente pode pegar essas referências. Então get nome, aí agora a gente vai ter o campo telefone.setText, aluno get telefone e logo em seguida a gente vai ter o campo e-mail set text, vamos lá, opa, setText aluno get e-mail, está bom. Então agora sim a gente está colocando as informações desse aluno, vamos testar e ver o que acontece. Shift F10 para poder testar aqui, está bom, então a gente está testando aqui bonitinho, vamos ver o que acontece ao executar, aparentemente foi uma execução rápida, então não precisa nem fazer corte aqui, está bom, e vamos ver se ele preenche as informações do aluno, então eu vou clicar aqui no Alex e vamos ver o que acontece. Olha só, ele colocou aqui as informações, está bom, se eu voltar lá novamente na nossa lista e entra na Fran vamos ver o que acontece ele colocou aqui as informações da Fran. Aí é claro, pessoal, se a gente tentar fazer a edição ela não vai acontecer, eu posso até mostrar para vocês aqui, então, por exemplo, a Fran aqui eu vou colocar como Fran Silva, então quando eu coloquei como Fran Silva, por exemplo, imaginando que esse seja o sobrenome dela, eu vou clicar em salvar e olha só o que acontece, ele vai salvar um novo usuário, um novo aluno. Então da maneira como está a gente ainda precisa fazer alguns ajustes, mas a gente já conseguiu fazer ali as primeiras partes que foi justamente fazer essa transferência aqui das informações, a gente já conseguiu fazer isso daqui e agora que a gente tem acesso a esse aluno, a essa nova técnica que é transferir dados para a nossas activitys com a intenção de digitar as informações a seguir a gente vai refinar esse código para que ele permita essa edição, está bom. Então até já.

Sobre o curso Android parte 2: avançando com listeners, menu e UI

O curso Android parte 2: avançando com listeners, menu e UI possui 165 minutos de vídeos, em um total de 46 atividades. Gostou? Conheça nossos outros cursos de Android em Mobile, ou leia nossos artigos de Mobile.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Carregando aluno no formulário
• Editando aluno pelo formulário
• Removendo aluno da lista
• Aplicando menus do Android
• Melhorando experiência do formulário