Intents – Passagem de parâmetros entre telas

As Intents possibilitam que informações possam ser transmitidas de uma tela para outra, conforme o usuário navega pela aplicação. Este é um item bem relevante no desenvolvimento mobile, pois muitas vezes precisamos de uma informação pequena, como a posição de uma lista que o usuário selecionou algum item, para ser utilizada na tela seguinte. E muitas vezes esta informação, por ser pequena, não vale a pena ser salva num banco de dados ou Shared Preferences, pois pode ser descartada na tela seguinte. Pensando nisto, o Android criou as Intents, que possuem não servem somente para passagem de parâmetros, o qual é nosso objetivo aqui.

Vamos imaginar uma lista de produtos de papelaria, onde, ao selecionar um da lista o usuário é direcionado para outra tela, que conterá detalhes do produto, como preço, quantidade de itens em estoque, descontos, etc. Veja a imagem abaixo:

Intents

O Android define as Intens como “uma descrição abstrata de uma operação que pode ser realizada”. O nome é sugestivo: determinam uma intenção de determinada ação. Estas ações podem ser tanto dentro da própria aplicação como chamar outra tela até mesmo compartilhar algo com uma aplicação que possa atender a solicitação. Este tutorial tem o foco de mostrar o uso das intents para passagem de parâmetros entre telas.

Iniciando outra tela

Como foi dito, a intent é uma intenção, e uma das intenções possíveis é inicializar uma outra tela. Para isto é preciso criar uma instância de intent passando o contexto atual e a nova activity desejada.

Com esta instância criada será possível passar os parâmetros desejados, que podem ser de diversos tipos: int, String, float entre outros, a Figura abaixo mostra alguns dos possíveis tipos de valores.

Screen Shot 2016-01-26 at 10.08.11 PM

Depois passamos os parâmetros desejados e iniciamos uma nova activity passando esta “intent” que foi criada.

Mas, mesmo fazendo isto ainda não está completo, perceba, armazenamos dentro de uma intent os valores que estamos passando, mas ainda uma outra activity não foi iniciada. Então usamos o método startActivity(intent) para iniciar nossa nova tela.

Se, a esta altura do campeonato tentar rodar o projeto verá que ocorrerá o seguinte erro, como mostrado na Figura abaixo:

Screen Shot 2016-01-23 at 4.57.08 PM

Este erro ocorre porque ainda falta mais um pequeno passo. Toda tela que uma aplicação utiliza deve ser declarada no Manifest File. Isto porque o Android detecta por este arquivo quais são as telas existentes na aplicação. Se você perceber, toda vez que cria um projeto o Android Studio se encarrega de deixar declarado para a primeira tela o seguinte código:

Vamos analisar cada parte. A primeira tag é uma activity, assim ele sabe que estamos falando de uma Activity. A segunda tag, que está dentro da tag activity é o intent-filter, que pode ser entendido como características que são anexadas à intent, e servirão para o elemento que for tratar esta intent. Difícil de entender!? Calma, vamos lá, o Android possui um jeito peculiar de raciocinar, que é muito útil em muitos aspectos, incluindo as intents.

As intents são “jogadas” para o sistema operacional, e quem puder “responder” a elas poderá ser solicitado. Assim você pode compartilhar (share) um conteúdo com contatos do WhatsApp, Hangouts, Gmail, enfim, várias aplicações podem tratar esta sua solicitação.

Portanto, os filtros servem como características que são adicionadas às intents. No caso, quando uma activity é a primeira de uma aplicação é preciso explicitar que ela é a principal. Você deve ter notado que o intent-filter não trabalha sozinho, existem 3 tipos de informações que podem ser adicionadas a ele: <action>, <category>, <data>, além dos extras e flags (que são setados em tempo de execução via código).

A action é uma string que especifica uma ação genérica como exibir, selecionar ou enviar. A category é uma string que especifica como o componente que receber essa intent deverá tratá-la. E data é uma string que está mais associada a action, ela especifica o tipo de dado, assim se a action for ACTION_EDIT então esta tag, data, deverá conter o dado a ser editado, no formato URI.

Pode haver em uma aplicação intents customizadas, mas o mais comum de ocorrer, é sua aplicação querer responder a uma intent gerada pelo sistema, como escrever, ler, entre outras possíveis ações.

Para ter mais uma activity na aplicação não é necessário declarar ação ou categoria para esta intent, ou seja, ela não precisa de intent-filters neste caso. Veja o código:

Passando objetos do tipo Parcelable

Imagine um objeto “Usuário” que possua diversos atributos, como nome, idade, endereço, e muitos outros. Fica um pouco complicado ficar passando atributo por atributo. O interessante é que tenhamos uma forma de passar um objeto inteiro. Existe uma forma de fazer isto no Android: o Parcelable e Serializable. A diferença entre eles é mais uma questão de processamento, o Serializable que vem do java é mais lento, já o parcelable é uma implementação do Android e é mais performático. A primeira mudança no código é mexer no modelo, neste caso já possuo a classe modelo, e só será modificado o código para implementar um parcelable.

Depois disso devemos mudar a intent que estamos enviando para a outra tela, de detalhe de item.

Feito! Agora precisa-se tratar o lado que vai receber este dados, pois até agora foi visto como enviar, mas não como receber. Na activity da tela seguinte, que está recebendo os valores vamos capturar estes dados que foram enviados.

E então basta setar os valores desejados que vieram da tela anterior, veja abaixo:

Conclusão

As intents são muito úteis no desenvolvimento mobile, estão presentes em diversas aplicações consideradas sucesso em Android. Facilitam consideravelmente a troca de informações entre telas de forma rápida e fácil.

O exemplo usado neste post encontra-se no github no seguinte link: https://github.com/paulacr/Intents

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

SharedPreferences

Muitas vezes precisamos persistir dados durante o uso da aplicação, para que possam ser utilizados posteriormente, como preferências de usuário, indicação de primeira vez do uso do aplicativo, e justamente quando estes dados são consideravelmente pequenos não vale a pena criar um banco de dados, que acaba gerando um trabalho extra. Pensando nisso o Android disponibilizou uma forma de armazenamento de dados denominado SharedPreferences ou Preferências de Usuário.

As SharedPreferences são utilizadas em situações onde não há necessidade de criação de um banco de dados, ou até mesmo quando há pouco número de dados a ser armazenado. Em linhas gerais, este armazenamento pode consistir em diversos tipos de dados, imagine uma aplicação de previsão do tempo, onde o usuário pode escolher entre exibir a temperatura em Fahrenheit ou em grau Celsius, este tipo de preferência é o tipo de dado que deve ser armazenado nas preferências de usuário, pois quando a aplicação iniciar já estará na escala de temperatura escolhida, o que é bem melhor do que perguntar ao usuário a cada vez que ele entre na aplicação. Outra utilização bem comum é uma flag para saber se é a primeira vez que o usuário entra na aplicação, para exibição ou omissão de algum tutorial. Geralmente as informações referentes à configurações da aplicação também podem ser armazenadas nas SharedPreferences.

Nota: Jamais, em hipótese alguma, salve senhas de usuários nas SharedPreferences, inclusive recomenda-se que nenhum dado pessoal de usuário, como cartão de crédito, telefone, e senhas sejam armazenadas de alguma forma no aparelho. Este tipo de prática não está de acordo com boas práticas no desenvolvimento mobile e deve ser tratado de outra forma. Falaremos disso mais a frente.

Entendendo as SharedPreferences

As SharedPreferences consiste em uma interface que permite acessar e modificar dados de preferência de usuário. O valor armazenado apresenta-se sob formato chave-valor ou key-value, ou seja, cada preferência armazenada possui uma identificação ou chave e associada a ela está um valor. Ela permite armazenamento de diversos tipos de valor, como int, float, Strings, booleans e sets de Strings.

getPreferences() versus getSharedPreferences()

Existem basicamente duas formas de se trabalhar com as SharedPreferences, quando há poucas e quando há muitas preferências. Digamos que o que precisa ser salvo sejam dados dentro de uma mesma chave, como preferências de configuração da aplicação, então o método recomendado a ser escolhido é getPreferences(). Já se deverá ser salvas diversas preferências então deve-se escolher o getSharedPreferences().

Criando uma Preferência

Como dito anteriormente, a sharedPreference utiliza o conceito de chave-valor (key-value) para armazenamento de valores. Muitas vezes precisamos armazenar mais de um valor, porém que estejam correlacionados. Digamos que em uma aplicação você possua diversas chaves para serem armazenadas, algumas ligadas à categorias, outras ligadas aos tutoriais do app, outras ligadas a configurações de localização. O ideal é que se tenha uma sharedpreference para cada “categoria” de valores a serem salvos, e que dentro de cada categoria sim salve-se as preferências específicas.

Para criar uma preferência basta chamar o método getSharedPreferences – se houver múltiplas chaves – e passar os argumentos necessários, que são a chave da preferência e o modo de acesso, o qual o mais utilizado é o modo PRIVATE,  que não permite que outras aplicações acessem a preferência salva. Existem também outros modos, como MODE_ENABLE_WRITE_AHEAD_LOGGINGMODE_APPEND, que se aplicam a banco de dados e concatenação de preferências, respectivamente.

Salvando uma preferência

Em determinada situação será preciso salvar uma preferência, e neste momento utiliza-se de um Editor, uma interface que irá salvar a preferência, conforme seu tipo, e deixará armazenada. Para então salvar a preferência desejada, precisa acessar o método edit() no objeto da preferência, criado anteriormente. Depois disso deverá ser colocado a chave e o valor no tipo de preferência desejada, escolhendo entre inteiros, booleans, strings, entre outros.

Nota: Ao salvar uma preferência é preciso chamar o método apply() para que a mudança seja aplicada. 

Buscando uma preferência

Buscar uma preferência também é uma ação que poderá ser requisitada diversas vezes. Como as preferências são salvas baseadas num par chave-valor basta buscá-la informando a chave. Da mesma forma que criam-se preferências passando o modo de acesso, na hora de buscá-las ocorre a mesma coisa, e posteriormente busca-se o valor desejado, também passando a chave, veja o exemplo:

Conclusão

As SharedPreferences auxiliam o desenvolvimento de uma aplicação android, permitem um menor esforço que se teria ao utilizar banco de dados. É preciso considerar a real necessidade de utilizar uma preferência, para não sobrecarregar o arquivo sem necessidade.

Nota: todos os exemplos utilizados neste post encontram-se no seguinte link: SharedPreferences

 

 

Criando uma lista customizada

Você viu no tutorial anterior como criar uma lista simples. Muitas vezes uma lista simples não atende nossa necessidade, pois queremos mostrar mais dados para um usuário do que simplesmente um texto em uma linha. Muitas listas contemplam mais informações por linha (ou célula) como mostra a imagem abaixo:

Lista Customizada
Lista Customizada

Nesta lista consta um ícone que representa a condição do tempo, tem-se também o nome da cidade, um texto com a condição do tempo descrita e a temperatura atual. Para lidar com este tipo de situação, onde queremos mostrar mais informações em uma lista, usamos as listas customizadas.

A ideia principal de uma lista customizada é que se tenha o layout que represente uma célula (ou linha), e este mesmo se aplicará a todas as outras. Observe a imagem abaixo, a célula destacada em vermelho, representa como faríamos um layout da célula.

Representação de uma célula customizada
Representação de uma célula customizada

 

Primeiro passo: Construção da custom view (célula customizada)

A primeira coisa a fazer é construir um layout que represente cada linha de nossa lista. No exemplo criado para este tutorial, pensei num app que mostrasse uma lista dos produtos que você possui na geladeira, pra que quando você vá ao supermercado saiba o que está faltando.

Começamos então construindo o layout de nossa custom view. Para facilitar o entendimento foi criado este mock-up que representa como ficará nossa custom view.

Mock-up da lista customizada
Mock-up da lista customizada

Este mock-up serve meramente para termos uma base, ele não precisa neste momento estar perfeito, até porque a ideia aqui é o aprendizado. Colocando este mock-up num layout xml:

Segundo passo: Construção da lista que receberá cada linha

Este layout representa cada célula ou linha de nossa lista, agora precisa-se de um layout que receberá a lista. Quando se utiliza uma lista customizada se faz necessário este tipo de prática: dois layouts.

 

Terceiro passo: Construção do Adapter

Como foi visto no post anterior, o Adapter é como uma ponte entre a AdapterView (ListView, GridView) e o dado que estará naquela View, como mostra a figura abaixo:

Definição de Adapter
Definição de Adapter

Existem alguns tipos de adapter, para demonstrar esta utilização de lista customizada será utilizado o BaseAdapter, que é uma implementação de Adapter. O BaseAdapter exige a sobreescrita de 4 métodos:

getCount() – Indica quantos itens ou linhas (rows) que serão apresentados na AdapterView

getItem(int position) – Retorna o dado referente aquele item (linha) da AdapterView, o qual é passado como parâmetro no construtor da classe.

getItemId(int position) – Retorna o id referente ao dado, referente ao item (linha) da AdapterView

getView(int position, View convertView, ViewGroup parent) – Este método cria a view, baseado no dado fornecido e na posição.

Vamos agora ver a implementação de cada método, para que fique mais claro estes conceitos. Crie então uma classe que extenda de BaseAdapter.

No construtor foi passado todos itens que trabalharemos em nossa custom view. Perceba que a imagem é uma lista do tipo Integer, isto porque as imagens são inteiros, e os textos são uma lista de Strings.

ViewHolder

Ao criar uma lista, cada linha (row) é criada no momento em que é mostrada ao usuário. Para evitar problemas com processamento do aparelho, já que cada linha é instanciada dinamicamente, utiliza-se o que chamamos de ViewHolder. O ViewHolder só instancia novos dados, se os mesmos já não estiverem instanciados. Deixando o scroll da lista mais suave, não gerado impacto ao usuário na hora de visualizar a lista.

Agora vamos sobreescrever os métodos que citei acima, que na verdade, são obrigatórios serem implementados.

O último método, getView() deixei por último para que falássemos um pouco mais sobre ele.

A primeira coisa a fazer é utilizar o LayoutInflater para obter o inflater.

Depois disso será criada a nossa View customizada, onde realmente o layout é inflado com o layout que criamos para cada linha. Em outras palavras, quando inflamos estamos na verdade transformando um layout xml em uma View.

Ao mesmo tempo também criamos uma instância da nossa classe ViewHolder,  a qual terá os elementos da View customizada.

Agora você precisa dizer ao Viewholder quais elementos correspondem a cada item que serão instanciados. Usamos o método findViewById(). Veja abaixo:

Nesta caso estamos dizendo que, cada elemento do Viewholder possui um correspondente no xml que criamos. Após isto, utiliza-se um método chamado setTag , que recebe um objeto, para armazenar o Viewholder. Quando utiliza-se este método, é como se estivéssemos atribuindo o objeto a uma tag ou uma chave.

Caso a View não esteja nula, ou seja, já tenha sido criada anteriormente, simplesmente chamamos a tag, através do método getTag()

Após feito isto, agora pode-se setar imagens e textos nas Views do Viewholder.

E este método exige que retornemos uma View, que após termos encontrado as views e setados os seus valores, podemos retorná-la.

Agora voltando à activity, precisamos dos itens que farão parte da lista. Somente para efeitos de demonstração, criei as listas na própria activity para facilitar o entendimento.

Primeira coisa a fazer é criar um objeto do tipo ListView e encontrar o id que corresponde a lista, este lista está dentro do layout activity_main.xml, citado anteriormente neste post.

Cria-se então o adapter, que recebe 4 parâmetros: o contexto, lista dos icones, lista da descrição e lista dos itens restantes. Veja:

E agora setamos o adapter, ou seja, dizemos que esta lista receberá em cada uma de suas linhas o adapter criado.

Veja como ficou a MainActivity completa:

E aí está, uma lista customizada. Um dos itens mais utilizados hoje em Android, apresentação dos dados em forma de lista.

Captura de tela: Lista customizada
Captura de tela: Lista customizada

Bom, agora fica mais fácil fazer uma lista conforme a necessidade dos clientes. Veja, a princípio pode parecer mais complicado, mas em termos de manutenção de código, e até mesmo de mudanças repentinas no projeto, este tipo de implementação se torna muito útil. Assim, caso o cliente mudasse ou adicionasse itens afetaria somente o layout row.xml e o adapter. Além de tudo fica um código limpo e fácil de ser entendido.

O link deste projeto encontra-se no meu github: https://github.com/paulacr/ListaCustomizada

Até o próximo.

Criando uma lista simples

Link do projeto no GitHub: https://github.com/paulacr/ListaSimplesExemplo

Olá pessoas, continuando na linha de layouts, vamos ver hoje como criar uma lista simples. As listas são ViewGroups, ou seja, views que armazenam outras views. A Listview serve para exibir outros itens em forma de lista que podem possuir rolagem (scroll).

Os itens são automaticamente inseridos na lista através do uso de um Adapter, componente que obtém conteúdo de uma Array ou consulta de um banco de dados, e converte cada item em uma view, que passa a ser um item da lista.

Neste tutorial irei mostrar como utilizar um default adapter, que é um pouco mais simples, e não oferece muita customização. Depois de aprendido o conceito, farei outro tutorial utilizando um adapter customizado.

Vamos começar então criando um layout, que permitirá colocarmos a nossa lista e os itens dela dispostos em uma tela.

Vamos agora analisar o layout. Um Textview para termos como título da nossa lista, até aí tudo certo. Depois uma ListView com um id, para podermos localizar na nossa classe java e poder manipulá-la.

Agora precisamos manipular esta lista, para ter os valores desejados. Crie uma classe java, se ela já não estiver lá, que esteja chamando o layout que criamos.

A primeira coisa a fazer é encontrar a lista que criamos no layout através do atributo id.

Feito isso agora podemos criar uma lista de valores que serão os itens de nossa lista. Neste caso estes valores estão criados dentro de uma Array de Strings, somente para efeitos de demonstração, porém poderiam ser valores de input inseridos pelo usuário, dados vindos de um servidor, entre outros. Veja abaixo:

A seguir precisa-se colocar este itens em formato de lista. Para isto utiliza-se uma classe denominada ArrayAdapter, que é uma classe do Android capaz de organizar itens em formato de lista simples. Veja como utilizá-la:

O primeiro parâmetro nos informa o contexto, neste caso passamos a própria Activity em que estamos. O segundo parâmetro diz respeito ao formato de lista, neste caso utilizou-se esta lista padrão do Android. O terceiro parâmetro diz respeito ao itens que irão compor a lista, no caso a Array de Strings que fizemos anteriormente.

Se você tentar rodar o projeto neste momento verificará que somente irá aparecer nosso texto de título, e mais nada. Isso ocorre porque ao criar um adapter você incluiu os itens e os dispôs em lista, porém ainda não os colocou dentro da lista que criou no layout. Por isso que em alguns passos anteriores precisamos encontrar o id da lista. Para isto, é chamado o método setAdapter passando o adapter criado anteriormente como parâmetro.

O resultado deste tutorial foi uma lista simples, como mostra a figura abaixo.

Lista simples utilizando ListView
Lista simples utilizando ListView

Para verificar se a lista está funcionando pode-se implementar o evento de click em cada item da lista. Para fazer isto é preciso implementar a interface que possibilitará interceptar o evento de click. Veja o código abaixo, que mostra como implementar o evento de click dos itens da lista.

Um exemplo sempre usado para demonstrar qual item foi clicado é o Toast. Ele é uma mensagem de duração curta ou longa, que irá aparecer no device assim que o evento for interceptado. O Toast tem a ideia de torrada numa torradeira, sobe por alguns instantes, e depois, neste caso, desaparece. Veja abaixo como implementar o Toast.

Observe como é o Toast na imagem abaixo:

Toast
Toast

 

Bom pessoas é isso, espero que tenham gostado, no próximo post faremos uma lista com as células customizadas, será bem interessante. Até a próxima.

 

 

Trabalhando com Recursos da aplicação

Olá pessoas, hoje vamos falar de um tema bem importante: recursos ou “resources”.

Os recursos englobam diversos itens que não fazem parte do código, assim como as imagens, layouts, textos, e valores de dimensões. A ideia é que, tudo que não for código deve estar externalizado, ou seja, em um local separado. Por isso na pasta “src” você encontrará layouts, imagens, enfim, tudo aquilo que é considerado um recurso.

Uma das guidelines do android refere-se a utilização destes recursos e hoje vou falar de como deve ser feito. Vamos fazer um exemplo para demonstrar isto, crie um projeto qualquer, com um layout e algum texto.

Quando você cria uma aplicação pelo Android Studio ele já cria um layout com um texto, e algumas dimensões de layout, estes itens já são os recursos, pois estão externos ao código e ao xml de layout.

Vamos então colocar um botão para que, assim que pressionarmos o botão, trocarmos o texto, mas utilizando recursos. Observe a figura abaixo:

criando um botão com textoDois recursos já estão criados, as dimensões do relativeLayout e o texto Hello World. Criei então um botão e inseri o texto no próprio layout, o que ocasiona um “warning”.

warning_harcoded_textO próprio Android Studio já me recomenda a extrair este recurso em uma String Separada, e justamente isto que vou mostrar como fazer.

Primeira coisa é adicionarmos o nosso recurso no arquivo xml “strings”, pois refere-se a um texto, que fica no menu esquerdo, dentro do diretório values, como a figura abaixo mostra.

Adicionando o recurso
Adicionando o recurso

Adicionando outra tag de string, posso colocar o texto desejado. A referência para este meu texto será name e seu conteúdo será o que está dentro da tag string: Mudar Texto. Fazendo isto, voltemos ao nosso layout novamente, e agora, ao invés de deixar escrito diretamente no layout o nosso texto, buscaremos do recurso strings.

Referenciando o recurso desejado no arquivo de layout
Referenciando o recurso desejado no arquivo de layout

Em arquivos xml este deve ser o padrão de referenciarmos o nosso recurso: @recurso/nomeDoRecurso. Desta forma, estaremos deixando o conteúdo do texto externo, pensando em termos de manutenção de código isto é excelente. Imagine que sua aplicação tenha um texto qualquer , talvez um “Ola, seja bem vindo”, e este texto esteja presente em todas as telas da aplicação, e um belo dia, o designer decide que deve ser trocada a frase para “Ola meu cliente favorito”, já imaginou o trabalho de mudar textos de todas as telas, e isso porque dei exemplo de um texto, agora imagine quantos recursos são utilizado em uma grande aplicação, não faria sentido deixar o texto em cada tela.

Além disso, também ocorrem muitas situações em que os recursos são modificados em tempo de execução, por isso criamos o botão, agora iremos mudar o texto Hello World, para Oi Mundo, depois de clicarmos o botão.

Primeira coisa eu preciso adicionar mais um recurso lá no meu arquivo strings, pois a ideia é deixar externo ao código qualquer texto.

Adicionando recurso para o texto
Adicionando recurso para o texto

Agora vamos lá na nossa classe java MainActivity para fazermos a lógica de clique do botão e mudança do texto.

A primeira etapa é localizar os id´s dos itens que precisarão sofrer mudanças, no caso o texto e o botão.

Encontrando referência dos componentes
Encontrando referência dos componentes

Feito isto agora vamos adicionar um evento que será um Listener do botão, ou seja, assim que o botão for clicado, a execução entrará neste código, executando o que estiver dentro dele.

Mudando o conteúdo do texto
Mudando o conteúdo do texto

Existe um atalho para criação de recursos. O Android Studio auxilia bastante nisto. Vá no seu recurso do texto do botão e delete esta linha, e depois volte no arquivo de layout da aplicação, ele estará com o warning, mostrado anteriormente neste tutorial, e ali digite alt + enter (windows)

Criando um recurso
Criando um recurso

Após selecionar esta opção, abrirá uma nova janela, que você colocará o valor ou o nome do recurso, dependendo do que está no layout. Neste caso como eu só apaguei o recurso, no meu texto está o nome do meu recurso, portanto, na tela de criação do novo recurso me pedirá para colocar o valor, veja na figura abaixo.

Criando um recurso de texto
Criando um recurso de texto

Bom galera, é isso que queria passar hoje. Tenha sempre em mente um código limpo e organizado pode facilitar sua vida no futuro e é obrigação de um bom programador deixar seu código legível e entendível, faça bem a sua parte, mesmo que os outros não façam as deles.

Até a próxima.

MyFirstApp – Seu primeiro aplicativo

Olá pessoas, voltando então a postar no blog, hoje vou ensinar como criar um aplicativo. Para não confundir muito a cabeça, vamos começar bem simples, fazendo uma aplicação com um texto e um botão, e vamos fazer com que o botão mude o conteúdo do texto. Entendendo bem os princípios básicos de cada elemento fica fácil depois fazer qualquer projeto.

Bom primeira coisa é criar um projeto. Não vale a pena aqui toda vez ensinar como cria um projeto, mas dá uma olhada aí no blog que tem um post falando sobre isso: https://paulacr.net/2014/11/19/criando-uma-simples-aplicacao-android/

Depois que você criou uma aplicação vamos começar com o layout, para preparar nossa aplicação. Primeira coisa a fazer é abrir o arquivo de layout. Geralmente quando você cria um projeto o próprio android studio já cria uma classe MainActivity.java e um layout activity_main.xml. O layout estará contido dentro da pasta res/layout. A pasta res é a pasta onde contém os recursos usados pela aplicação como imagens, textos, dimensões, etc. Observem a figura abaixo:

Criando layout e adicionando um botão
Criando layout e adicionando um botão

O item 1 mostra onde está alocado o layout criado, caso você queira criar um novo é só clicar no package layout com botão direito e criar um novo. O item 2 mostra um “Button”. Que é o elemento que iremos adicionar, como o android já faz um layout com um Texto basta somente adicionarmos um botão para fazer nosso app. Percebam o seguinte, existem duas formas de criar este arquivo de layout, uma delas é arrastando os itens desta paleta, outra forma é construir layout via código xml, como mostra a figura abaixo.

Construindo layout via código xml
Construindo layout via código xml

Com a prática acaba ficando mais fácil fazer via código mesmo, mas inicialmente comecei arrastando, aí é mais uma questão de escolha mesmo. Perceba no rodapé da figura destacado em vermelho duas abas “Design” e “Text”, é nesta aba que é possível trocar de modo de layout, ou seja, modo design é arrastando os elementos gráficos e modo text para digitar em código xml. O Android Studio também possui uma grande vantagem que é de mostrar em tempo real tudo que você vem fazendo no layout, então assim que você adiciona um item, ou insere algum atributo para este item, ele já mostra no celular posicionado ao lado do código. Você também pode já escolher um celular que seja mais próximo de seu objetivo com a aplicação. Existem diversos modelos disponíveis.

Insira um botão nesta tela, contendo os atributos mostrados na figura abaixo:

Adicionando um botão ao layout
Adicionando um botão ao layout

Assim então ficará o layout e os atributos de cada elemento. Percebam que além dos atributos que já estavam gerados pela IDE pelo fato de ja ter layout pronto, foram adicionado o id. Vou explicar um pouco cada atributo. O android exige que você determine sempre a altura e comprimento do elemento, nem que seja 0dp, é preciso ser informada. O atributo width por exemplo possui o valor “wrap_content”, que significa dizer que o tamanho do meu botão depende da quantidade de texto que ele tiver. Já se o valor for match_parent significa que a dimensão assumirá a mesma dimensão do layout pai.

O id é necessário para que possamos identificar estes elementos gráficos na nossa classe java, e assim fazer com que o texto mude seu conteúdo após pressionarmos o botão.

Então agora vamos a parte legal: vamos trabalhar em nossa classe java para vermos funcionando. Abra a classe java onde iremos implementar a lógica do nosso código, como mostra a figura abaixo:

Criando a lógica na classe java
Criando a lógica na classe java

Dentro da pasta java, temos o package do app, neste caso temos um só package, mas em projetos normalmente temos vários. E ali temos nossa classe: MainActivity.java, abra esta classe, e vamos a alguns detalhes aqui.

Esta classe é herdada da classe ActionBarActivity que nos mostra que ela é uma activity, ou seja, uma activity representa uma tela (em raríssimos casos não será uma tela). E para ser uma tela eu preciso informar pra ela qual arquivo de layout representa a tela, por isso, no Android é separado entre layout e lógica do app. Existe a possibilidade de criar cada elemento visual do layout em tempo de execução, porém, até mesmo o Google recomenda o uso de layouts em formato xml.

Sublinhei em vermelho uma linha de comando super importante, setContentView(R.layout.activity_main), usando este comando chamamos o nosso layout. Todo elemento gráfico e layout criado possui um correspondente dentro da classe R, caso eu altere, o android gera novamente na classe R. É uma classe onde não devemos mexer, mas toda vez que precisarmos localizar qualquer elemento faremos por ela.

Bom, agora se você tentar rodar a aplicação, ela irá realmente rodar e aparecerá o nosso layout, claro que por enquanto nenhum botão e texto possui nenhuma ação.

Faça isso, plugue seu aparelho na porta usb, e dê o play, caso não possua um aparelho android, siga esta documentação do Google para configurar um. (https://developer.android.com/tools/devices/managing-avds.html).

Rodando a aplicação pela primeira vez
Rodando a aplicação pela primeira vez

OK, agora vamos implementar a lógica que possibilitará pressionarmos o botão e mudar o texto. Volta lá para sua classe java MainActivity.java, e vamos continuar.

Primeira coisa vamos “encontrar” os elementos na classe java, lembra daquele Id que falei anteriormente, no layout xml, então agora ele será muito útil. Para fazer isto, você precisa dar um nome a sua view (todos os elementos gráficos acabam sendo uma view), e encontrar o id. Por exemplo:

Button meuBotao = (Button) findViewById(R.id.botao)

Fazemos isso para os dois elementos: botão e texto (textview), como mostra a figura abaixo:

Encontrando cada elemento gráfico
Encontrando cada elemento gráfico

É necessário fazer um “cast” porque como estes elementos são views, preciso encontrar dentro da classe view o elemento específico que desejo. Agora estou dizendo especificamente quero o botão e texto que estão no layout.

Agora também vamos gerar o evento de pressionar o botão. É necessário implementar a interface de clickListener, pode ser feito direto no código. Mais pra frente mostrarei de outra forma, mas agora vamos pelo mais fácil de entender:

Setando um texto a partir do evento de click do botão
Setando um texto a partir do evento de click do botão

Criamos então um evento para o click do botão. Perceba que, quando o botão for clicado o que estiver dentro do método onClick será executado. Aí vai da necessidade da aplicação, pode ser um edittext, botão, loading, enfim, usem a criatividade. Executa o app aí que você vai ver o que acontece quando clicar no botão.

Rodando o app e pressionando o botão
Rodando o app e pressionando o botão

Então pessoal, aí está o nosso click de botão sendo interceptado por um evento. Pode ser utilizada esta mesma lógica para várias aplicações, com outros componentes de view também, uma boa parte dos componentes permitem essa interação, utilizando o clickListener.

Espero ter ajudado, e dúvidas e sugestões podem entrar em contato, adicionar nas redes sociais.

Até a próxima!!!!

Ententendo Layouts Parte II – Gerenciadores de Layout

Olá pessoas, vamos falar hoje então de gerenciadores de layout. No último post eu já falei um pouco, e agora vamos aprofundar neste conhecimento. Somente relembrando, os gerenciadores de layout serão responsáveis por armazenar todos os widgets (componentes gráficos) que teremos. Falei também que não é preciso se prender a somente um layout, mas sim fazer uma mescla dos gerenciadores de layout que você necessita. Então agora vamos entender um pouco melhor cada um deles.

AbsoluteLayout – Este layout já está obsoleto e não é mais recomendado utilizá-lo. Ele permite posicionar os componentes na tela através de coordenadas x e y.

FrameLayout – Foi projetado para alocar somente um componente gráfico. É recomendado que se utilize o framelayout para alocar somente um componente, já que seria um tanto custoso alocar mais views filhas, pela questão de posicionamento.

LinearLayout – É com certeza um dos layouts mais utilizados em android. Ele organiza suas entidades filhas em colunas ou linhas. Possui uma propriedade que define a orientação, ou seja, vertical ou horizontal: android:orientation=”vertical”. Ideal para quando se quer que os componentes estejam alinhados. O posicionamento dos componentes é relativo ao layout-pai.

LinearLayout
LinearLayout

RelativeLayout – Neste layout há um diferencial. É possível posicionar os componentes gráficos em relação a outros componentes ou ao layout-pai. Ou seja, se você tiver dois textos dentro deste layout e quiser que a posição de um texto seja relativa a posição do outro texto, aqui é possível. Também é um dos layouts mais utilizados.

RelativeLayout
RelativeLayout

Um fato a ser considerado é que a imagem mostrada acima, do RelativeLayout, também é possível obter com o LinearLayout, claro que teríamos então dois layouts lineares dentro de um Linear-pai, e somente trabalhando com algumas propriedades, poderíamos chegar ao mesmo resultado. O mais importante na hora de escolher o layout, é pensar em multi-resoluções de telas. Ou seja, os Layouts foram projetados para que o desenvolvedor pudesse adaptar o mesmo arquivo de layout para diversas dimensões de telas, já que sabemos que no android existem diversos tamanhos com resoluções diferenciadas. O mais importante é isto, o resto só vem com a prática.

Até o próximo tutorial.

Entendo Layouts

Olá pessoas, hoje vamos falar de um assunto bem legal Layouts. Ele compõe a parte visual de uma aplicação android. Entender bem seu funcionamento faz parte do processo e ajuda muito na hora de desenvolver. Primeira coisa a ser entendida é o que é um Layout?

Bom o layout é um arquivo em formato xml que através de “tags” podemos incluir os elementos gráficos que queremos que nossa tela contenha. Cada tag, que é referente a um elemento do layout, pode conter dezenas de atributos tais como margens, espaçamentos entre o item anterior e posterior, alinhamentos, textos, id (que falaremos em seguida), dentre vários outros atributos.

Na imagem abaixo podemos ver como a tela ficou com as tags e os atributos de cada elemento. Só para termos uma ideia.

Entendo layouts
Entendo layouts

Existem atributos que serão aplicáveis em diversos componentes, e outros atributos que serão específicos de um componente. Como eu disse anteriormente, para entender bem os layouts é preciso ir um pouco mais fundo. Todos componentes gráficos herdam de uma classe chamada View (android.view.View), que é nativa do Android. Todos os gerenciadores de layout também herdam desta classe. Cada subclasse de View deve implementar o método onDraw(canvas) que é o método responsável por desenhar os componentes na tela. Então existe uma separação: widgets são os componentes gráficos como textos, imagens, edittext, entre outros. E existem os gerenciadores de layout, que são tipos de layouts aplicados a um arquivo de layout, como LinearLayout, RelativeLayout, FrameLayout, que serão responsáveis por armazenar os widgets.

Cada gerenciador de layout se comporta de forma específica e possui finalidades muitas vezes diferenciadas dos outros. O LinearLayout por exemplo é aplicável quando se quer um alinhamento horizontal/vertical entre os widgets, por exemplo, um formulário de cadastro fica melhor se for feito em um layout Linear. Já o RelativeLayout é aplicável quando se quer deslocamentos diferenciados entre um componente e outro. E o relative layout permite também relações de componente para componente, ou seja, você pode alinhar um texto embaixo de um outro texto, somente comparando estes dois. Falarei nos próximos posts como é o comportamento de cada um. Geralmente o que se aplica num app é a utilização de vários gerenciadores de layout, já que através das tags, você pode determinar que em certo “pedaço” da tela haja um tipo de layout diferente do restante da tela. Assim conforme a necessidade, vamos gerenciando nossa tela com o layout apropriado para cada situação, por isso é bem interessante entender cada um.

E se a questão layout estiver bem entendida, será muito mais fácil adaptar o layout para cada tipo de tela, já que no Android existem muitos devices com tamanhos diferenciados.

Até a próxima.

Criando uma simples Aplicação Android

Oi , Oi, Oi pessoas. Então hoje vamos falar um pouco do que é preciso para criar uma simples aplicação Android. Começando então pelo início, ao abrir seu Android Studio você vai ver a seguinte tela:

create_new_project
Criando um novo Projeto

Depois disso precisamos dar um nome ao projeto e o nome que o pacote terá. O Google Play, ou seja, a loja onde você publica os seus apps Android na verdade salva pelo nome do pacote, ou seja, se você colocar um nome de pacote que já exista lá, terá de mudar futuramente para poder publicar, portanto é bem interessante que já se escolha um nome que não terá duplicado. Geralmente indica-se para que o nome do pacote da aplicação seja o domínio (site) ao contrário e em seguida o nome da aplicação, como por exemplo, meu projeto seria net.paulacr.MeuApp.

Nomeando a aplicação
Nomeando a aplicação

Depois disto precisamos selecionar o tipo de projeto, se será para smartphones/Tablets, para TV, ou Android Wear. Nesta tela também selecionaremos a mínima versão que nossa aplicação estará disponível. Como podemos ver na figura abaixo.

Escolha do tipo de projeto e SDK
Escolha do tipo de projeto e SDK

Feito isso agora podemos escolher o tipo de projeto que queremos, se é uma activity em branco, ou uma tela de mapa. Vale ressaltar o seguinte, esta escolha está valendo somente para a primeira tela a ser criada, o que poderia ser usado uma activity em branco e depois, codificando-a, fazer ela se tornar uma activity de mapa.

Escolha do tipo de activity
Escolha do tipo de activity

Por fim a última tela, onde colocamos nome para esta “primeira” activity que já irá aparecer. Podemos também colocar qualquer nome e modificá-la futuramente.

type_name_of_activity
Nomeando as activties

E por último temos nosso projeto pronto para começar. Percebam na figura abaixo, que o Android Studio já cria algumas coisas para gente de forma automática. Temos também à esquerda toda a estrutura do projeto e no próximo tutorial vamos começar a fazer aplicações na prática, que dará maior visibilidade de como tudo funciona.

Até mais!!!!

Fonte: http://developer.android.com/guide/components/activities.html

Activity e seu ciclo de vida

As activities são com certeza um dos pontos chave no conhecimento da plataforma Android. Entendendo bem seu funcionamento, fica bem mais fácil desenvolver para Android. A activity pode ser entendida como uma atividade, e geralmente ela representa uma tela da aplicação (pelo menos na maioria dos casos).

A activity promove uma interação entre usuário e aplicação. Pode mostrar conteúdos estáticos ou dinâmicos, ou a mistura destes. Quando se quer, por exemplo, mostrar uma tela, utiliza-se o método setContentView(R.layout.meu_layout);

Então pra começar a entender como funciona a activity é necessário entender o seu ciclo de vida. É só você parar pra pensar, como que quando você volta de uma ligação por exemplo para a aplicação que estava anteriormente aberta, suas informações ainda continuam lá, isto ocorre por causa do ciclo de vida da activity. Nada melhor que uma imagem para exemplificar tudo isto.

Fonte: http://developer.android.com/guide/components/activities.html
Ciclo de vida de uma activity

Então vamos tentar entender como tudo funciona. O primeiro método do ciclo de vida é o método onCreate. Neste método a activity é criada pela primeira vez , assim como os componentes gráficos que irão aparecer na tela, isso mesmo, irão aparecer pois neste método eles ainda não mostrados para o usuário. O segundo método a ser chamado é o método onStart, que é chamado antes dos componentes ficarem visíveis na tela, obrigatoriamente, SEMPRE depois do método onCreate é chamado o método onStart. O próximo método é chamado onResume, e nele sim, os componentes de tela são mostrados para o usuário, permitindo interação do mesmo com a aplicação.

Quando você abre outra aplicação ou recebe uma ligação, por exemplo, o método onPause é chamado, e é recomendado que todo dado que deva ser persistido, utilize esse método para o fazer. Por exemplo, o usuário está preenchendo um formulário na sua aplicação e atende uma ligação, antes que este usuário possa perder os dados que estava digitando, quando a activity entrar no método onPause, você persiste aqueles dados para que o usuário não tenha que os digitar novamente.

Logo depois é chamado o método onStop, que significa que a aplicação já não está mais visível para o usuário. E aqui sim é uma incógnita, pois não há como ter certeza se depois desta etapa a aplicação voltará a ser mostrada ou poderá ser destruída pelo sistema. Não há como saber,portanto , se tiver dados para serem salvos, que sejam salvos no onPause.

Mas quando ela somente está na fila, e você finaliza aquela ligação telefônica, ela retorna para o usuário e entra no método onRestart, significa que ela está voltando a ativa. Mas ainda seu conteúdo não está visível, e então vai para o método onStart e onResume consequentemente. Se ela não ir para o método onRestart é então destruída. Ou até mesmo quando o usuário finaliza o app ela entra no método onDestroy.

É bem interessante o sistema android, e como ele gerencia tudo isto. Funciona como uma pilha, onde cada nova activity que é criada é adicionada a esta pilha, e sempre a mais nova activity está por cima da mais antiga. Assim você sabe com certeza que quando finalizar a activity atual, será movido para a activity anterior.

Então pessoas é isto até o proximo post, em breve mostrarei na prática como lidar com cada parte do ciclo de vida, e como isto pode ser útil para sua aplicação. Até mais.

Estrutura de uma aplicação Android

Paula Caroline

Olá pessoas, voltando a postar neste blog. Mas agora com um diferencial: muitos conhecimentos foram adquiridos neste tempo que serão revertidos aqui.

Hoje eu vou falar um pouco sobre a estrutura de um projeto Android. Só para situar vocês, a IDE que estou utilizando é o Android Studio, na versão 0.9.2, mas porque estou dizendo isto? Porque é o seguinte galera, a estrutura do projeto android pode mudar conforme a IDE, por exemplo na versão anterior do Android Studio tínhamos outra estrutura, e também no eclipse a estrutura de pastas é um pouco diferente. Mas vamos lá.

Estrutura de uma Aplicação Android Estrutura de uma Aplicação Android

Então vamos analisar um pouco esta estrutura. Na imagem a primeira pasta refere-se aos Manifests, e contém um arquivo AndroidManifest.xml. O Manifest file, é um arquivo bem importante, usaremos ele para por exemplo, adicionar permissões à aplicação, definir o tema da aplicação, definir quais activities estarão na aplicação…

Ver o post original 233 mais palavras

Estrutura de uma aplicação Android

Olá pessoas, voltando a postar neste blog. Mas agora com um diferencial: muitos conhecimentos foram adquiridos neste tempo que serão revertidos aqui.

Hoje eu vou falar um pouco sobre a estrutura de um projeto Android. Só para situar vocês, a IDE que estou utilizando é o Android Studio, na versão 0.9.2, mas porque estou dizendo isto? Porque é o seguinte galera, a estrutura do projeto android pode mudar conforme a IDE, por exemplo na versão anterior do Android Studio tínhamos outra estrutura, e também no eclipse a estrutura de pastas é um pouco diferente. Mas vamos lá.

Estrutura de uma Aplicação Android
Estrutura de uma Aplicação Android

Então vamos analisar um pouco esta estrutura. Na imagem a primeira pasta refere-se aos Manifests, e contém um arquivo AndroidManifest.xml. O Manifest file, é um arquivo bem importante, usaremos ele para por exemplo, adicionar permissões à aplicação, definir o tema da aplicação, definir quais activities estarão na aplicação (não se assuste neste primeiro momento entrarei detalhadamente em cada termo no decorrer dos posts).

A segunda pasta é Java. Nesta pasta é onde colocaremos todo o código, ou seja, toda a lógica de negócio de nossa aplicação. Ou seja, todo código que não se refere a arquivos de layout ficarão aqui nesta pasta.

A terceira pasta é Res, que vem da palavra “resources” ou traduzindo: recursos. Nela colocaremos nossos layouts. Veja como fica interessante separar lógica de negócio dos layouts, traz muito mais clareza. Como vocês podem ver há algumas pastas dentro desta pasta Res. Temos a pasta drawable, layout, menu e values. Na pasta drawable adicionaremos todas as imagens que a aplicação terá e também algumas customizações como quando queremos adicionar bordas a um botão, por exemplo. Na pasta layout colocaremos os layouts de telas da aplicação. Na pasta menu colocaremos os componentes que ficarão na Actionbar, ou seja que fazem parte do Menu da aplicação. E por fim, na pasta values colocaremos recursos de texto, cores , dimensões. Conforme cada tutorial irei explicando melhor como se fazer a utilização de cada um destes itens.

Então pessoas é isso, acho que já deu pra perceber que tem bastante detalhes para serem vistos, mas não se assustem, não é nada que com o dia-a-dia você não vá pegando o jeito. No início parece meio complicado mesmo.

Um abraço e até a próxima.

Tutorial # 1 – Desenvolvedor Android: por onde começar??

Você decide então entrar pra esse mundo de desenvolvimento Android. Mas por onde começar? Bom aqui neste tutorial vou descrever um pouco sobre onde encontrar referências, quais são as ferramentas necessárias pra começar a desenvolver.

Referências Técnicas

A sua maior referência deve ser este site: http://developer.android.com , que é onde você irá encontrar toda documentação oficial, além de conter tutoriais bem interessantes, e não menos importantes as guidelines (que serão abordadas no próximo tutorial). Sempre priorize verificar toda documentação do que você quer implementar neste site, afinal, além de ser a documentação oficial do android, ele possui muitos tutoriais também.

Android Developers Website
Android Developers Website

Outra referência que utilizo bastante, que serve mais para dúvidas é o fórum http://stackoverflow.com/ , que, na minha opinião, é um dos fóruns mais acessados por desenvolvedores Android. Já consegui resolver muitos problemas, e aí tem um galera super legal pra te ajudar.

Preparando o ambiente de desenvolvimento

Existem 3 Passos básicos a serem seguidos: instalação da IDE e instalação da SDK.

Instalação da IDE e SDK

Existem 3 IDE´s mais utilizadas no desenvolvimento Android: Eclipse, Eclipse ADT e Android Studio. Na minha opinião é uma questão de gosto mesmo. Eu utilizo o ADT Bundle que é uma versão do eclipse destinada à desenvolvimento Android, mas por um tempo também usei o Eclipse convencional. Nesse link (http://developer.android.com/sdk/index.html). E se você já possui o Eclipse instalado basta fazer o download da SDK do Android.

Instalando a IDE
Instalando a IDE

Bom Galera, esse foi só o primeiro tutorial, no próximo vou mostrar a importância das Guidelines, Estrutura de um Aplicativo Android e os primeiros passos pra você começar a pôr a mão na massa. Aqui é assim: conforme eu vou aprendendo eu vou te ensinando. A ideia era mesmo fazer uma série de tutoriais pra compartilhar aquilo que já sei, mas não significa que eu domine a programação Android, bem pelo contrário. Espero que gostem e mandem dúvidas e sugestões!!!

Tutoriais

O objetivo desta seção do blog é compartilhar o que já sei de desenvolvimento Android. Todo aprendizado que hoje sei, foi proveniente de muito estudo e dedicação, que em 3 meses, me fizeram aprender o suficiente para publicar minha primeira app Android na Play Store. Aqui, descreverei de uma forma simplificada, tudo que aprendi, tentando proporcionar ao leitor do blog, uma oportunidade de aprender de um jeito mais fácil a programação da plataforma. Gostou, não gostou, quer sugerir ou opinar? Entre em contato comigo através de minhas redes sociais. Eu por enquanto, apesar de estar no nível básico, acredito que este pouco conhecimento servirá de base para quem não sabe muita coisa.

 

Espero que gostem!!!