Juliana Corá

Android: Passagem de parâmetros entre Activities(Telas)

2012-04-25T11:13:00.001-07:00

Neste artigo irei demonstrar a passagem de parâmetros entre duas Activities(Telas). No post anterior utilizamos o método startActivity(intent) para navegar entre as telas da aplicação.

Irei criar uma aplicação básica como exemplo para demostrar a passagem de parâmetros entre Telas. Na primeira tela terá um campo para receber um texto e um botão que ao clicar passará o valor para a segunda tela.

Crie um novo Projeto com o nome "PassagemParametros".
Na Primeira Activity "PassagemParametros.java" será a nossa primeira Tela.

package br.com.juliana;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

public class PassagemParametros extends Activity 
{
    @Override
    public void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        //CRIA OS OBJETOS
        final EditText campoTexto = (EditText) findViewById(R.id.editText);
        Button botao = (Button) findViewById(R.id.envio);
        
        //CLICK DO BOTÃO
        botao.setOnClickListener(new Button.OnClickListener () 
        {
            public void onClick(View v)
            {
                Intent intent = new Intent(v.getContext(), SegundaTela.class);
                Bundle params = new Bundle();
                
                String resposta = campoTexto.getText().toString();
                params.putString("mensagem", resposta);
                intent.putExtras(params);
                startActivity(intent);
            }
        });
    }
}

Para passar parâmetros se usa a classe android.os.Bundle e o método putExtras(Bundle) na intent que será passado como parâmetro para a próxima tela.

O método putString(chave, valor) utilizei uma String como parâmetro, mas poderia ter usado putInt no caso o valor ser um integer. A classe Bundle tem métodos para diferentes tipos primitivos como o putBoolean, putChar, putFloat e vários outros. A variável "valor" recupera o texto da EditText do "campoTexto" utilizando os métodos "getText" e "toString".

Ao executar vejamos como ficou:

Agora irei criar a segunda Activity "SegundaTela.java" que receberá o valor da primeira tela.

O método getIntent() recupera os parâmetros enviados. Depois de recuperada o método getExtras() retorna o mesmo bundle criado para enviar os parâmetros.
Para ler os parâmetros passados pelo bundle basta chamar o método getString e passar o parâmetro String "mensagem" da activity anterior.

Ao executar novamente vejamos como ficou:

Até a próxima, espero que tenham gostado.

Android - Criando Múltiplas Activities

2012-04-12T09:32:00.000-07:00

No post anterior vimos sobre o ciclo de vida de uma Activity, e hoje iremos aprender como criar múltiplas Activities(Telas).

Exemplo: Iremos criar duas activities. A classe “Exemplo1” é a activity(atividade) principal do projeto e a classe "Exemplo2" que será chamada pela primeira tela. A primeira atividade é simplesmente um botão, que quando clicado abre a segunda atividade, que por sua vez consiste em um simples campo de texto editável. Ela não precisa de um botão "Sair", pois o usuário pode simplesmente clicar no botão "Voltar" do emulador . Para simplificar não iremos usar o arquivo de layout XML para criar a nossa tela. Iremos criar dentro da classe Activity.

Crie um projeto com o nome “ExemploActivity” ou dê o nome que achar melhor e quando chegar na etapa abaixo, segue o exemplo.

Quando você cria um novo projeto o campo “Create Activity” vem checado e cria a classe Activity, então não deixamos checado.

Depois do projeto criado, iremos criar a nossa primeira classe. Clique com o botão direito em cima do pacote que o meu é “br.com.juliana” vai em “New/Class” e no campo “name” dê o nome de "Exemplo1".

A chamada para iniciar a segunda atividade ocorre no método "handleButtonClick()".

startActivity(new Intent(this, Exemplo2.class));

Depois crie uma outra classe chamada “Exemplo2” como segue abaixo:

No arquivo AndroidManifest.xml

No código acima, eu declarei as duas Activities “Exemplo1” e “Exemplo2”. Toda vez que criar uma nova atividade é preciso que declare no arquivo “AndroidManifest.xml”.

Vamos executar a nossa aplicação para ver o resultado:

Ao clicar no botão irá chamar a segunda tela(activity):

Então pessoal por hoje é só, espero que tenham gostado. Caso ficaram com dúvida é só comentar. Ate +.

Android: Activity - Ciclo de Vida

2012-04-11T09:51:00.000-07:00

Entender o que é um ciclo de vida de uma Activity é fundamental para a criação de uma aplicação mais robusta. Caso sua aplicação é interrompida por uma ligação, e como sua aplicação irá se comportar após sua ligação for finalizada. Após está interrupção, teria que voltar ao mesmo ponto onde sua aplicação parou. Então precisamos entender cada ciclo de vida de uma Activity.

O diagrama a seguir mostra os caminhos importantes de uma Activity e seu ciclo de vida.

Abaixo iremos ver os métodos que controlam os estados da sua aplicação.

onCreate() É a primeira função a ser executada quando uma Activity é lançada. Geralmente é a responsável por carregar os layouts XML e outras operações de inicialização. É executada somente uma vez durante a “vida útil” da Activity.
onStart() É chamada imediatamente após a onCreate() – e também quando uma Activity que estava em background volta a ter foco.
onResume() Assim como a onStart(), é chamada na inicialização da Activity (logo após a própria onStart()) e também quando uma Activity volta a ter foco. Qual a diferença entre as duas? A onStart() só é chamada quando a Activity não estava mais visível na tela e volta a ter o foco, enquanto a onResume() sempre é chamada nas “retomadas de foco”.
onPause() É a primeira função a ser invocada quando a Activity perde o foco (ou seja, uma outra Activity vem à frente).
onStop() – Análoga à onPause(), só é chamada quando a Activity fica completamente encoberta por outra Activity (não é mais visível).
onDestroy() A última função a ser executada. Depois dela, a Activity é considerada “morta” – ou seja, nao pode mais ser relançada. Se o usuário voltar a requisitar essa Activity, outro objeto será contruído.
onRestart() Chamada imediatamente antes da onStart(), quando uma Activity volta a ter o foco depois de estar em background.

Segue um exemplo de como ocorre um ciclo de vida de uma Activity. Cada método mostra no Log quando cada um foi executado.

Crie um novo projeto e cole o código em sua Classe Activity gerada.

package br.com.juliana; import android.app.Activity; import android.os.Bundle; import android.util.Log; public class CicloDeVidaActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Log.v("TAG", "onCreate()"); } @Override protected void onDestroy() { super.onDestroy(); Log.v("TAG", "onDestroy()"); } @Override protected void onPause() { super.onPause(); Log.v("TAG", "onPause()"); } @Override protected void onResume() { super.onResume(); Log.v("TAG", "onResume()"); } @Override protected void onStart() { super.onStart(); Log.v("TAG", "onResume()"); } @Override protected void onStop() { super.onStop(); Log.v("TAG", "onStop()"); } @Override protected void onRestart() { super.onRestart(); Log.v("TAG", "onRestart()"); } }

Execute a aplicação e visualize o Log.

Para visualizar as mensagens do Log, vá em “Window/Show View/Other/LogCat”.

1 - Ao executar sua aplicação observe que no Log mostrou:

2 - Depois disso clique no botão voltar do emulador e veja novamente o Log:

3 - Clique novamente na sua aplicação:

Note que na 1° etapa os métodos onCreate e onResume foram criados.
Depois na 2° etapa os métodos passaram para onPause, onStop e onDestroy.
E quando voltou novamente na sua aplicação chamou os métodos onCreate e onResume.

Hoje vimos detalhes sobre o ciclo de vida de uma Activity. No próximo post será Criando mais que uma Activities. Até +.

Android: Conceito de uma Activity

2012-04-05T04:53:00.000-07:00

Aqui no blog você já aprendeu como instalar e configurar o SDK Android no Eclipse e criar o seu primeiro projeto Android e agora iremos aprender mais sobre a classe Activity que usamos em nosso projeto inicial.

O que seria uma Activity?

Uma activity é um componente chave do Android. É basicamente uma classe gerenciadora de UI (interface com o Usuário). Para ter uma interação com a interface de usuário, uma classe deve ser herdada de uma Activity. Todo aplicativo android começa por uma Activity.

Exemplo de uma Activity

Registrando Activity no arquivo AndroidManifest.xml

Após criar uma classe é necessário registrar a Activity para que o Android precise saber quais classes são atividades. Para registar uma Activity, abra o arquivo AndroidManifest.xml, e incluir o registro da Activity.

Ou seja, quando uma aplicação android é executada, na verdade é a sua Activity principal que é lançada. A activity é definida como padrão na criação do projeto quando é lançada.

Hoje vimos detalhes sobre a classe Activity. No próximo post iremos aprender sobre o ciclo de vida de uma Activity. Espero que tenham gostado. Até +.

Criando o Primeiro Projeto Android no Eclipse

2012-03-25T18:01:00.000-07:00

No post de hoje estarei ensinando de como criar seu primeiro projeto Hello World no Android.
Caso você não instalou os respectivos arquivos necessários veja este tutorial.

Caso já tenha tudo instalado, vamos dar início ao primeiro projeto.

Abra o Eclipse e clique em File>New>Project.... Selecione Android>Android Project.

Clique em Next> e no campo Project Name: (nome de seu projeto).

Clique em Next>. Nesta tela escolha a versão do Android que queira usar. Escolhi a versão 2.3.3, utilize a versão que você tenha criando no dispositivo com a versão correspondente.

Clique em Next>. Em Package Name: (pacote do projeto) coloquei br.com.juliana mais de o nome que achar melhor. Para finalizar clique me Finish>.

Pronto! Criamos nosso primeiro projeto. Antes de dar continuidade vamos entender a estrutura do projeto.

src - Pasta do Projeto que contém as classes Java. Contém a classe HelloWorld que foi criada pelo Wizard.
gen - Contém a classe R.java que é gerada automaticamente e permite que a aplicação acesse qualquer recurso como arquivos e imagens.
assets - Contém arquivos opcionais ao projeto, como por exemplo, uma fonte customizada.
res - Pasta que contém os recursos da aplicação, como imagens, layouts de telas. Tem 3 subpastas: drawable, layout e values.
drawable - Pasta com as imagens da aplicação. Existe 3 pastas: drawable-ldpi, drawable-mdpi e drawable-hdpi para cada resolução de telas diferentes.
layout - Contém arquivos XML de layouts para construir telas da aplicação.
values - Onde estão localizadas as variáveis do layout(XML).

Observe o código-fonte abaixo, está classe Hello World foi gerada pelo wizard é onde fica toda a lógica da aplicação. A constante R.layout.main é o que gera a abertura da tela identificada pelo arquivo main.xml (inicia uma Activity) que se localiza dentro da pasta layout. No próximo post explicarei melhor o que seria uma classe Activity.

Agora abra o arquivo strings.xml que se localiza dentro da pasta values, e altere a linha:

<string name="hello">Hello World, HelloWorld!</string>

por:

<string name="hello">Hello World, Seja bem vindo ao Blog!</string>

Dentro do arquivo main.xml contém uma tag <TextView> que exibe um texto na tela. Essa tag define o atributo android:text="@string/hello", que utiliza uma mensagem identificada pela chave hello
localizada no arquivo strings.xml que foi citado acima.

Agora iremos executar nosso projeto. Clique com o botão direito sobre o projeto e selecione Run As>Android Application.

Na primeira execução o emulador demora para abrir, mais a cada mudança no projeto não fechar o emulador, só executar novamente o projeto.
Para modificar a resolução do emulador, caso a tela ficou grande, volte ao AVD Manager e edite a resolução.

Pronto. Espero que tenha gostado. No próximo post irei explicar o que seria uma classe Activity.

Como Instalar e Configurar o SDK do Android

2012-03-25T04:36:00.000-07:00

Neste Documento

1. Preparando seu computador de desenvolvimento
2. Fazendo o download do SDK do Android
3. Instalar o plugin ADT no Eclipse

Passo 1. Preparando seu computador de desenvolvimento

Antes de começar com o SDK do Android, é necessário possuir uma Maquina Virtual Java instalada, caso você não o tenha feito.

Para instalar o Eclipse, você pode baixar neste local.

http://www.eclipse.org/downloads/

Passo 2. Fazendo o download do SDK do Android

Primeiramente faça o download do SDK do Android no link abaixo.

http://developer.android.com/sdk/index.html

Após o termino do download, crie uma pasta em sua máquina e descompacte o arquivo .zip dentro da pasta que você criou. Neste tutorial utilizei o SDK para o Windows.

Agora iremos adicionar o diretório tools do SDK ao path do seu sistema. Isto possibilita rodar o ADB - (Android Debug Bridge) e outras ferramentas de linha de comando sem precisar especificar o caminho completo para o diretório tools.

No Windows 7:
Clique com o botão direito em Computador e selecione Propriedades. Em Configurações avançadas do sistema na aba Avançado e depois Variáveis de Ambiente em Variáveis do Sistema procure a variável Path e clique duas vezes. Adicione o caminho completo para o diretório tools.

Ex : C:\tools\SDK_ANDROID\android-sdk-windows\tools;

No linux:
Abaixo os comandos para a descompactação do arquivo SDK e execução do Android no console:
$ tar -zxvf android-sdk_r17-linux.tgz
$ cd android-sdk-linux/tools/
$ ./android

Sugiro que adicione o diretório do SDK Android na variável PATH. Segue o comando abaixo:
$ cd /etc
$ vi profile

acrescenta a linha no exemplo abaixo:
PATH=$PATH:/home/juliana/sdk_android/android-sdk-linux/tools
export PATH

Ao executar o comando ./android abrirá um formulário como segue abaixo:

Clique em Accept All e no botão Install.

Passo 3. Instalar o plugin ADT no Eclipse

Para começar a desenvolver aplicações com Android no Eclipse, primeiramente você precisa instalar um plugin chamado Android Development Tools - (ADT), que é projetado para dar-lhe um ambiente poderoso, integrado, para a criação de aplicativos Android. Em geral, o desenvolvimento no Eclipse com ADT é uma abordagem altamente recomendada e é o caminho mais rápido para começar com o Android.

Como estou usando o Eclipse Helios, para instalar o plugin ADT, vá em Help/Install New Software... e clique em Add no canto superior direito. No campo name digite "ADT Plugin" e no campo Location digite a URL como segue abaixo:

https://dl-ssl.google.com/android/eclipse/

Clique em OK.

Se você tiver problemas na aquisição do plugin, tente usar o "http" na URL em Location, em vez de "https" (https é preferido por razões de segurança).

Em Available Software, selecione a caixa de seleção ao lado de Developer Tools e clique em Next.

Na próxima janela, você verá uma lista das ferramentas para ser baixado. Clique em Next.

Leia e aceite os acordos de licença, clique em Finish.

Se você receber uma aviso de segurança dizendo que a autenticidade ou validade do software não pode ser estabelecida, clique em OK.

Quando a instalação estiver concluída, reinicie o Eclipse.

Depois de ter reiniciado, iremos em Window > Preferences, selecione Android no lado esquerdo.
Em SDK Location clique em Browse..., localize o diretório do SDK baixado em sua máquina.
Pressione Apply, e depois OK.