Programação de Aplicativos Android (Parte 6) - Ricardo Quintão - UVA

Prévia do material em texto

Prof: Ricardo Quintão
email: ricardo.quintao@uva.br
Site: www.rgquintao.com.br
Criando um Projeto Android
Como criar uma nova Activity?
Até agora, todos os nossos projetos utilizavam apenas uma Activity.
Podemos fazer o projeto inteiro usando apenas uma Activity, e apresentando diversas telas, porém, isso
dificulta a gerência de recursos do Android, já que os recursos utilizados pela Activity devem estar
ativos.
É muito mais eficiente, dividir o programa em diversas Activitys, pois desta forma o Android pode
liberar os recursos das Activitys que não estão em execução, como vimos no seu ciclo de vida.
Primeiramente, veremos um projeto contendo mais de uma tela, porém, com uma única Activity.
Depois, faremos um projeto com mais de uma Activity, cada uma com a sua tela.
tela1.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.multiplastelas.Activity_telas" >
9:
10: <TextView
11: android:layout_width="wrap_content"
12: android:layout_height="wrap_content"
13: android:text="Tela1 – Activity_telas" />
14:
15: <Buttom
16: android:id="@+id/bt_tela2"
17: android:layout_width="match_parent"
18: android:layout_height="wrap_content"
19: android:text="Ir para Tela2" />
20:
21: </LinearLayout>
Vamos realizar um projeto
contendo duas telas e apenas
uma Activity.
Cada tela terá um texto
identificando a própria tela e um
botão possibilitando ir para a
outra tela.
Ao lado temos o arquivo
tela1.xml representando a tela1.
Criando um Projeto Android com uma Activity e duas Telas
Para criar a tela2.xml seguiremos os seguintes
passos:
1- Vá no menu: File  New Other...
Aparecerá a tela ao lado.
2- Escolha a opção: Android XML Layout File.
3- Click em Next.
Criando um Projeto Android com uma Activity e duas Telas
4- Coloque o nome tela2 em File.
5- Marque a opção LinearLayout.
A tela deve ficar semelhante à tela ao lado.
6- Click em Finish.
Criando um Projeto Android com uma Activity e duas Telas
tela2.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: android:orientation="vertical"
4: android:layout_width="match_parent"
5: android:layout_height="match_parent"
6: android:padding="10dp"
7:
8: <TextView
9: android:layout_width="wrap_content"
10: android:layout_height="wrap_content"
11: android:text="Tela2 – Activity_telas" />
12:
13: <Buttom
14: android:id="@+id/bt_tela1"
15: android:layout_width="match_parent"
16: android:layout_height="wrap_content"
17: android:text="Voltar para Tela1" />
18:
19: </LinearLayout>
O arquivo tela2.xml será criado
e deveremos editá-lo para ficar
igual ao apresentado ao lado.
Ele é quase idêntico ao utilizado
em tela1.xml.
Criando um Projeto Android com uma Activity e duas Telas
Abaixo temos as duas telas criadas.
Tela1 Tela2
Criando um Projeto Android com uma Activity e duas Telas
Ao lado temos o arquivo
Activity_telas.java responsável pela
execução do nosso projeto.
Repare que não é inicializada a
apresentação da tela diretamente
dentro do método onCreate().
Foram implementados dois métodos
responsáveis por criar e processar
suas próprias telas.
Estes métodos são: tela1() e tela2().
Activity_telas.java
1: package com.example.multiplastelas;
2: 
3: import android.app.Activity;
4: import android.os.Bundle;
5: import android.view.View;
6: import android.widget.*;
7: 
8: public class Activity_telas extends Activity
9: {
10: @Override
11: protected void onCreate(Bundle savedInstanceState)
12: {
13: super.onCreate(savedInstanceState);
14:
15: tela1();
16: }
17:
Criando um Projeto Android com uma Activity e duas Telas
Ao lado temos o método
tela1().
Nele, na linha 22, é
apresentada a tela1.
Na linha 31, após o click no
botão, é chamado o método
tela2().
Activity_tela1.java (continuação)
18: void tela1()
19: {
20: Button bt_tela2;
21:
22: setContentView(R.layout.tela1);
23:
24: bt_tela2 = (Button) findViewById(R.id.bt_tela2);
25:
26: bt_tela2.setOnClickListener(new View.OnClickListener()
27: {
28: @Override
29: public void onClick(View v)
30: {
31: tela2();
32: }
33: });
34: }
35:
Criando um Projeto Android com uma Activity e duas Telas
Activity_tela1.java (continuação)
36: void tela2()
37: {
38: Button bt_tela1;
39:
40: setContentView(R.layout.tela2);
41:
42: bt_tela1 = (Button) findViewById(R.id.bt_tela1);
43:
44: bt_tela1.setOnClickListener(new View.OnClickListener()
45: {
46: @Override
47: public void onClick(View v)
48: {
49: tela1();
50: }
51: });
52: }
53: }
Ao lado temos o método
tela2().
Nele, na linha 40, é
apresentada a tela2.
Na linha 49, após o click no
botão, é chamado o método
tela1().
Desta forma, é possível ficar
trocando de tela através dos
botões.
Lembrando que apesar de
termos duas telas, temos
apenas uma Activity.
Criando um Projeto Android com uma Activity e duas Telas
tela1.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivity.Activity_tela1" >
9:
10: <TextView
11: android:layout_width="match_parent"
12: android:layout_height="wrap_content"
13: android:background="#FF0000"
14: android:text="Tela1 – Activity_tela1" />
15:
16: <Buttom
17: android:id="@+id/bt_tela2"
18: android:layout_width="match_parent"
19: android:layout_height="wrap_content"
20: android:text="Ir para Tela2" />
21:
22: </LinearLayout>
Vamos realizar um projeto contendo três
telas e três Activitys (Activity_tela1,
Activity_tela2, Activity_tela3).
Cada tela terá um texto identificando a
própria tela e a sua Activity.
A tela1 e a tela2 terão um botão
possibilitando ir para a tela seguinte em
outra Activity.
Para retornar, basta clicar no botão voltar
do dispositivo que ele finaliza a Activity
corrente.
Ao lado temos o arquivo tela1.xml
representando a tela1.
Na linha 13, estabelecemos a cor
vermelha como cor de fundo desta view
para ajudar na sua identificação.
Criando um Projeto Android com três Activity e três Telas
Para criar a Activity_tela2 seguiremos os
seguintes passos:
1- Vá no menu: File  New Other...
Aparecerá a tela ao lado.
2- Escolha a opção: Android Activity.
3- Click em Next.
Criando um Projeto Android com três Activity e três Telas
4- Tal como foi feito ao criar o projeto, marque
a opção Blank Activity.
5- Click em Next.
Criando um Projeto Android com três Activity e três Telas
6- Coloque como nome da Activity:
Activity_tela2.
7- Coloque como nome do Layout:tela2
8- Click em Finish.
Será então criada a Activity no arquivo
Activity_tela2.java e o layout de tela
no arquivo tela2.xml.
Repita todo o procedimento para criar a
Activity_tela3 e o layout de tela
tela3.xml
Criando um Projeto Android com três Activity e três Telas
tela2.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivity.Activity_tela2" >
9:
10: <TextView
11: android:layout_width="match_parent"
12: android:layout_height="wrap_content"
13: android:background="#00FF00"
14: android:text="Tela2 – Activity_tela2" />
15:
16: <Buttom
17: android:id="@+id/bt_tela3"
18: android:layout_width="match_parent"
19: android:layout_height="wrap_content"
20: android:text="Ir para Tela3" />
21:
22: </LinearLayout>
Ao lado temos o arquivo
tela2.xml.
Cada tela terá um texto
identificando a própria tela, a
sua Activity e um botão que
possibilita ir para a tela
seguinte.
Na linha 13, foi estabelecida a
cor verde como cor de fundo
desta view para ajudar na sua
identificação.
Criando um Projeto Android com três Activity e três Telas
tela3.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivity.Activity_tela3" >
9:
10: <TextView
11: android:layout_width="match_parent"
12: android:layout_height="wrap_content"
13: android:background="#0000FF"
14: android:text="Tela3 – Activity_tela3" />
15:
16: </LinearLayout>
Ao lado temos o arquivo
tela3.xml.
Ela é semelhante ao tela2.xml
com a diferença que, como ela
se encontra na última Activity,
não possui um botão para
disparar a Activity seguinte.
Na linha 13, foi estabelecida a
cor azul como cor de fundo
desta view para ajudar na sua
identificação.
Criando um Projeto Android com três Activity e três Telas
Para disparar uma nova Activity, é
preciso utilizar a classe Intent.
Esta classe indica a intenção de
utilizar algum recurso.
Como a Activity solicitará recursos
ao sistema, como por exemplo,
memória, não existe a garantia de que
ela poderá ser disparada. Por isso a
necessidade de usar a classe Intent.
Vamos agora ao arquivo
Activity_tela1.java.
Activity_tela1.java
1: package com.example.novaactivity;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: import android.view.View;
7: import android.widget.*;
8: 
9: public class Activity_tela1 extends Activity
10: {
11: Button bt_tela2;
12:
13: @Override
14: protected void onCreate(Bundle savedInstanceState)
15: {
16: super.onCreate(savedInstanceState);
17: setContentView(R.layout.tela1);
18:
19: bt_tela2 = (Button) findViewById(R.id.bt_tela2);
20: 
Criando um Projeto Android com três Activity e três Telas
Activity_tela1.java (continuação)
21: bt_tela2.setOnClickListener(new View.OnClickListener()
22: {
23: @Override
24: public void onClick(View v)
25: {
26: Intent tela2 = new Intent(Activity_tela1.this, Activity_tela2.class);
27: startActivity(tela2);
28: }
29: });
30: }
31: }
Na linha 26 é criado um objeto tela2 do tipo Intent.
Este objeto recebe como parâmetro a Activity chamadora, no caso Activity_tela1, e a Activity a ser
disparada, que é a Activity_tela2.
Na linha 27 é solicitada a inicialização da Activity definida no objeto Intent tela2.
Se não houver qualquer tipo de problema, a Activity será disparada.
Criando um Projeto Android com três Activity e três Telas
A Activity_tela2.java é quase idêntica
a Activity_tela1.java, mudando
apenas o nome de alguns parâmetros
e variáveis.
Ao lado temos a listagem deste
arquivo.
Activity_tela2.java
1: package com.example.novaactivity;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: import android.view.View;
7: import android.widget.*;
8: 
9: public class Activity_tela2 extends Activity
10: {
11: Button bt_tela3;
12:
13: @Override
14: protected void onCreate(Bundle savedInstanceState)
15: {
16: super.onCreate(savedInstanceState);
17: setContentView(R.layout.tela2);
18:
19: bt_tela3 = (Button) findViewById(R.id.bt_tela3);
20: 
Criando um Projeto Android com três Activity e três Telas
Activity_tela2.java (continuação)
21: bt_tela3.setOnClickListener(new View.OnClickListener()
22: {
23: @Override
24: public void onClick(View v)
25: {
26: Intent tela3 = new Intent(Activity_tela2.this, Activity_tela3.class);
27: startActivity(tela3);
28: }
29: });
30: }
31: }
Tal como na Activity_tela1.java, na linha 26 é criado um objeto tela3 do tipo Intent.
Este objeto recebe como parâmetro a Activity chamadora, sendo agora a Activity_tela2, e a Activity a ser
disparada, que agora é a Activity_tela3.
Na linha 27 é solicitada a inicialização da Activity definida no objeto Intent tela3.
Se não houver qualquer tipo de problema, a Activity será disparada.
Criando um Projeto Android com três Activity e três Telas
Por fim, ao lado temos a
Activity_tela3.java.
A única finalidade desta Activity é a
apresentação da tela3.xml.
Como já foi dito anteriormente, para
finalizar a Activity atual e retornar
para a anterior basta utilizar o botão
“voltar” do próprio dispositivo.
Activity_tela3.java
1: package com.example.novaactivity;
2: 
3: import android.app.Activity;
4: import android.os.Bundle;
5: 
6: public class Activity_tela3 extends Activity
7: {
8: @Override
9: protected void onCreate(Bundle savedInstanceState)
10: {
11: super.onCreate(savedInstanceState);
12: setContentView(R.layout.tela3);
13: }
14: } 
Criando um Projeto Android com três Activity e três Telas
Ao ser executado este projeto teremos as seguintes telas:
Tela1
Criando um Projeto Android com três Activity e três Telas
Tela2
Criando um Projeto Android com três Activity e três Telas
Tela3
Criando um Projeto Android com três Activity e três Telas
Muitas vezes, quando estamos criando uma nova Activity, precisamos passar algumas informações da
Activity atual para a próxima Activity.
Para fazermos isto, vamos apresentar agora o recurso de passagem de parâmetros para uma outra
Activity.
Este projeto terá duas telas e duas Activities (uma para cada tela).
A primeira Activity fará a entrada de dois dados, enquanto a segunda fará a apresentação destes dados.
Como já aprendemos, vamos criar um projeto de nome Nova Activity (envio).
A Activity principal, aquela criada durante a criação do projeto, se chamará Activity_tela1 e sua tela
estará no arquivo tela1.xml,
A segunda Activity se chamará Activity_tela2 e sua tela estará no arquivo tela2.xml.A seguir apresentaremos o código das Activities e das telas, acompanhados de alguns comentários,
quando necessários.
Criando um Projeto Android com Passagem de Parâmetros
tela1.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivityenvio.Activity_tela1" >
9:
10: <TextView
11: android:layout_width="match_parent"
12: android:layout_height="wrap_content"
13: android:background="#0000FF"
14: android:text="Tela1 – Activity_tela1" />
15:
16: <TextView
17: android:layout_width="wrap_content"
18: android:layout_height="wrap_content"
19: android:text="Teste de passagem de parâmetros" />
20:
Abaixo temos o arquivo de layout tela1.xml.
Criando um Projeto Android com Passagem de Parâmetros
tela1.xml (continuação)
21: <TextView
22: android:layout_width="wrap_content"
23: android:layout_height="wrap_content"
24: android:text="Entre com um texto:" />
25:
26: <EditText
27: android:id="@+id/et_texto"
28: android:layout_width="wrap_content"
29: android:layout_height="wrap_content"
30: android:inputType="text"
31: android:maxLines="1"
32: android:text="" />
33:
tela1.xml (continuação)
34: <TextView
35: android:layout_width="wrap_content"
36: android:layout_height="wrap_content"
37: android:text="Entre com um valor:" />
38:
39: <EditText
40: android:id="@+id/et_valor"
41: android:layout_width="wrap_content"
42: android:layout_height="wrap_content"
43: android:text="" />
44:
45: <Buttom
46: android:id="@+id/bt_tela2"
47: android:layout_width="match_parent"
48: android:layout_height="wrap_content"
49: android:text="Ir para Tela2" />
50:
51: </LinearLayout>
Na linha 30, configuramos o atributo android:inputType
com o valor “text” e na linha 31 o atributo
android:maxLines com o valor inteiro “1”.
A combinação destes dois valores obriga o texto a ser
exibido em apenas uma linha com o recurso de scroll
horizontal, caso ele ultrapasse a capacidade da View.
Estes dois atributos substituem o já obsoleto e
descontinuado atributo android:singleLine=“true”.
Apesar deste último funcionar, se conflitar com outros
parâmetros ele será desabilitado.
Criando um Projeto Android com Passagem de Parâmetros
tela2.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivityenvio.Activity_tela2" >
9:
10: <TextView
11: android:layout_width="match_parent"
12: android:layout_height="wrap_content"
13: android:background="#00FF00"
14: android:text="Tela2 – Activity_tela2" />
15:
16: <TextView
17: android:layout_width="wrap_content"
18: android:layout_height="wrap_content"
19: android:text="Teste de recebimento de parâmetros" />
20:
Abaixo temos o arquivo de layout tela2.xml.
Criando um Projeto Android com Passagem de Parâmetros
tela2.xml (continuação)
21: <TextView
22: android:id="@+id/tv_texto2"
23: android:layout_width="wrap_content"
24: android:layout_height="wrap_content"
25: android:layout_marginTop="10dp"
26: android:textColor="#0000FF"
27: android:text="" />
28:
29: <TextView
30: android:id="@+id/tv_valor2"
31: android:layout_width="wrap_content"
32: android:layout_height="wrap_content"
33: android:layout_marginTop="10dp"
34: android:textColor="#FF0000"
35: android:text="" />
36:
37: </LinearLayout>
Criando um Projeto Android com Passagem de Parâmetros
Ao lado temos o arquivo
Activity_tela1.java responsável
pela execução do nosso projeto.
Activity_tela1.java
1: package com.example.novaactivityenvio;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: import android.view.View;
7: import android.widget.*;
8: 
9: public class Activity_tela1 extends Activity
10: {
11: EditText et_texto, et_valor;
12: Button bt_tela2;
13:
14: @Override
15: protected void onCreate(Bundle savedInstanceState)
16: {
17: super.onCreate(savedInstanceState);
18: setContentView(R.layout.tela1);
19:
20: et_texto = (EditText) findViewById(R.id.et_texto);
21: et_valor = (EditText) findViewById(R.id.et_valor);
22: bt_tela2 = (Button) findViewById(R.id.bt_tela2);
23:
Criando um Projeto Android com Passagem de Parâmetros
Diferente do exemplo anterior, na linha 34 e 35 temos o uso do método putExtra() do objeto Intent.
Este método permite a inserção de dados na Intent. Assim podemos recupera-los na Activity disparada.
Este método recebe um rótulo para identificar o dado e o dado propriamente dito.
Activity_tela1.java (continuação)
24: bt_tela2.setOnClickListener(new View.OnClickListener()
25: {
26: @Override
27: public void onClick(View v)
28: {
29: String texto = et_texto.getText().toString();
30: int valor = Integer.parseInt(et_valor.getText().toString());
31:
32: Intent tela2 = new Intent(Activity_tela1.this, Activity_tela2.class);
33:
34: tela2.putExtra("Valor_enviado", valor);
35: tela2.putExtra("Texto_enviado", texto);
36:
37: startActivity(tela2);
38: }
39: });
40: }
41: }
Criando um Projeto Android com Passagem de Parâmetros
Activity_tela2.java
1: package com.example.novaactivityenvio;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: import android.widget.*;
7: 
8: public class Activity_tela2 extends Activity
9: {
10: String texto;
11: int valor;
12:
13: TextView tv_texto2, tv_valor2;
14:
15: @Override
16: protected void onCreate(Bundle savedInstanceState)
17: {
18: super.onCreate(savedInstanceState);
19: setContentView(R.layout.tela2);
20:
21: tv_texto2 = (TextView) findViewById(R.id.tv_texto);
22: tv_valor2 = (TextView) findViewById(R.id.tv_valor);
23:
Ao lado temos o arquivo
Activity_tela2.java responsável
pela execução do nosso projeto.
Criando um Projeto Android com Passagem de Parâmetros
Para receber os parâmetros, devemos capturar o endereço da Intent enviada pela Activity_tela1.
Na linha 24 é declarada a variável tela1 do tipo Intent.
Na linha 25 usa-se o método getIntent() para recuperar o endereço da Intent recebida da Activity_tela1.
Na linha 27 utiliza-se o método getStringExtra() com o rótulo usado para identificar o valor enviado,
para recuperar este valor, no caso uma string.
Na linha 28 utiliza-se o método getIntExtra() com o rótulo usado para identificar o valor enviado, para
recuperar este valor, no caso um inteiro.
Activity_tela2.java (continuação)
24: Intent tela1;
25:tela1 = getIntent();
26:
27: texto = tela1.getStringExtra("Texto_enviado");
28: valor = tela1.getIntExtra("Valor_enviado", 0);
29:
30: tv_texto2.setText("Texto_recebido:" + texto);
31: tv_valor2.setText("Valor_recebido:" + valor);
32: }
33: }
Criando um Projeto Android com Passagem de Parâmetros
Uma outra forma de passagem de parâmetros entre Activities é no retorno. É muito comum criarmos uma
Activity para realizar entrada de dados. Neste caso, teremos que repassar estes dados à Activity anterior.
Para fazermos isto, vamos apresentar agora o recurso de retorno de parâmetros para a Activity chamadora.
Este projeto terá duas telas e duas Activities (uma para cada tela).
A primeira Activity fará a apresentação dos dados retornados, enquanto a segunda fará a entrada destes
dados.
Como já aprendemos, vamos criar um projeto de nome Nova Activity (Retorno).
A Activity principal, aquela criada durante a criação do projeto, se chamará Activity_tela1 e sua tela estará
no arquivo tela1.xml,
A segunda Activity se chamará Activity_tela2 e sua tela estará no arquivo tela2.xml.
A seguir apresentaremos o código das Activities e das telas, acompanhados de alguns comentários, quando
necessários.
Criando um Projeto Android com Retorno de Parâmetros
tela1.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivityretorno.Activity_tela1" >
9:
10: <TextView
11: android:layout_width="match_parent"
12: android:layout_height="wrap_content"
13: android:background="#0000FF"
14: android:text="Tela1 – Activity_tela1" />
15:
16: <TextView
17: android:layout_width="wrap_content"
18: android:layout_height="wrap_content"
19: android:text="Teste de recebimento de parâmetros" />
20:
Abaixo temos o arquivo de layout tela1.xml.
Criando um Projeto Android com Retorno de Parâmetros
tela1.xml (continuação)
21: <Buttom
22: android:id="@+id/bt_tela2"
23: android:layout_width="match_parent"
24: android:layout_height="wrap_content"
25: android:text="Ir para Tela2" />
26:
27: <TextView
28: android:id="@+id/tv_texto"
29: android:layout_width="wrap_content"
30: android:layout_height="wrap_content"
31: android:layout_marginTop="10dp"
32: android:textColor="#0000FF"
33: android:text="" />
34:
35: <TextView
36: android:id="@+id/tv_valor"
37: android:layout_width="wrap_content"
38: android:layout_height="wrap_content"
39: android:layout_marginTop="10dp"
40: android:textColor="#FF0000"
41: android:text="" />
42:
43: </LinearLayout>
Criando um Projeto Android com Retorno de Parâmetros
tela2.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivityretorno.Activity_tela2" >
9:
10: <TextView
11: android:layout_width="match_parent"
12: android:layout_height="wrap_content"
13: android:background="#00FF00"
14: android:text="Tela2 – Activity_tela2" />
15:
16: <TextView
17: android:layout_width="wrap_content"
18: android:layout_height="wrap_content"
19: android:text="Teste de retorno de parâmetros" />
20:
Abaixo temos o arquivo de layout tela2.xml.
Criando um Projeto Android com Retorno de Parâmetros
tela2.xml (continuação)
21: <TextView
22: android:layout_width="wrap_content"
23: android:layout_height="wrap_content"
24: android:text="Entre com um texto:" />
25:
26: <EditText
27: android:id="@+id/et_texto"
28: android:layout_width="wrap_content"
29: android:layout_height="wrap_content"
30: android:text="" />
31:
32: <TextView
33: android:layout_width="wrap_content"
34: android:layout_height="wrap_content"
35: android:text="Entre com um valor:" />
36:
37: <EditText
38: android:id="@+id/et_valor"
39: android:layout_width="wrap_content"
40: android:layout_height="wrap_content"
41: android:text="" />
42:
43: <Buttom
44: android:id="@+id/bt_tela2"
45: android:layout_width="match_parent"
46: android:layout_height="wrap_content"
47: android:text="Voltar para Tela1, devolvendo os parâmetros" />
48:
49: </LinearLayout>
Ao lado temos o arquivo
Activity_tela1.java responsável
pela execução do nosso projeto.
Activity_tela1.java
1: package com.example.novaactivityretorno;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: import android.view.View;
7: import android.widget.*;
8: 
9: public class Activity_tela1 extends Activity
10: {
11: TextView tv_texto, tv_valor;
12: Button bt_tela2;
13:
14: @Override
15: protected void onCreate(Bundle savedInstanceState)
16: {
17: super.onCreate(savedInstanceState);
18: setContentView(R.layout.tela1);
19:
20: tv_texto = (TextView) findViewById(R.id.tv_texto);
21: tv_valor = (TextView) findViewById(R.id.tv_valor);
22: bt_tela2 = (Button) findViewById(R.id.bt_tela2);
23:
Criando um Projeto Android com Retorno de Parâmetros
Na linha 29 é feita a definição da Intent tela2 da mesma forma que foi feita nos exemplos anteriores.
Na linha 30 temos uma diferença. Ao invés de se utilizar o método startActivity(), como deseja-se
receber valores da Activity a ser criada, será utilizado o método startActivityForResult() passando por
parâmetro a Intent tela2 e um código inteiro que identificará esta Activity para que seus dados possam
ser recuperados. Neste exemplo foi estabelecido o código “1”.
Activity_tela1.java (continuação)
24: bt_tela2.setOnClickListener(new View.OnClickListener()
25: {
26: @Override
27: public void onClick(View v)
28: {
29: Intent tela2 = new Intent(Activity_tela1.this, Activity_tela2.class);
30: startActivityForResult(tela2, 1);
31: }
32: });
33: }
34:
Criando um Projeto Android com Retorno de Parâmetros
O resultado é recebido no método OnActivityResult() da classe Activity.
Sendo assim, deve-se sobrescrever este método para fazer a recuperação e o devido processamento.
Três parâmetros são passados para este método: requestCode, resultCode e a Intent que contém os dados.
O requestCode é o mesmo código que foi passado na criação da Activity, no nosso caso, o valor “1”.
O resultCode contém o código enviado por setResult().
Activity_tela1.java (continuação)
35: @Override
36: protected void OnActivityResult(int requestCode, int resultCode, Intent retorno)
37: {
38: if (retorno != null)
39: {
40: if (requestCode == 1)
41: {
42: String texto = retorno.getStringExtra("Texto_retorno");
43: int valor = retorno.getIntExtra("Valor_retorno", 0);
44:
45:tv_texto.setText("Texto_retornado:" + texto);
46: tv_valor.setText("Valor_retornado:" + valor);
47: }
48: }
49: }
50: }
Criando um Projeto Android com Retorno de Parâmetros
Activity_tela2.java
1: package com.example.novaactivityenvio;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: import android.view.View;
7: import android.widget.*;
8: 
9: public class Activity_tela2 extends Activity
10: {
11: EditText et_texto2, et_valor2;
12: Button bt_tela1;
13:
14: @Override
15: protected void onCreate(Bundle savedInstanceState)
16: {
17: super.onCreate(savedInstanceState);
18: setContentView(R.layout.tela2);
19:
20: et_texto2 = (EditText) findViewById(R.id.et_texto2);
21: et_valor2 = (EditText) findViewById(R.id.et_valor2);
22: bt_tela1 = (Button) findViewById(R.id.bt_tela1);
23:
Ao lado temos o arquivo
Activity_tela2.java responsável
pela execução do nosso projeto.
Criando um Projeto Android com Retorno de Parâmetros
Para devolver
valores, deve-se
primeiramente
recuperar a Intent
originalmente
enviada. Isto é
feito na linha 32.
Em seguida, nas
linhas 34 e 35,
colocam-se os
valores utilizando o
método putExtra().
Activity_tela2.java (continuação)
24: bt_tela1.setOnClickListener(new View.OnClickListener()
25: {
26: @Override
27: public void onClick(View v)
28: {
29: String texto = et_texto2.getText().toString();
30: int valor = Integer.parseInt(et_valor2.getText().toString());
31:
32: Intent retorno = getIntent();
33: retorno.putExtra("Valor_retorno", valor);
34: retorno.putExtra("Texto_retorno", texto);
35:
36: setResult(1, retorno);
37: finish();
38: }
39: });
40: }
41: }
Na linha 37 é feito o envio dos dados através do método setResult(). Ele passa um código que será recebido
na Activity chamadora que é corriqueiramente utilizado para informar se a operação foi ou não bem sucedida.
O segundo parâmetro é a Intent. Para finalizar a Activity atual, utiliza-se o método finish().
Criando um Projeto Android com Retorno de Parâmetros
Dependendo da complexidade de um determinado processamento e da quantidade de memória envolvida,
pode ser conveniente transferir todo esse processamento para uma Activity.
Como esta Activity será responsável apenas pelo processamento, ela não possuirá uma tela para ser
apresentada.
No exemplo a seguir, será mostrada esta situação.
Na Activity inicial, denominada Activity_tela1, faremos a entrada de 10 valores inteiros em um vetor.
Será iniciada uma segunda Activity, denominada Activity_calculo, que receberá o vetor como parâmetro,
realizará a sua ordenação, e ao final, retornará este vetor ordenado.
A Activity_tela1 irá receber este vetor ordenado e então mostrará o seu conteúdo.
A seguir temos os códigos das Activities e o arquivo tela1.xml.
Criando um Projeto Android com uma Activity sem Tela
tela1.xml
1: <LinearLayout
2: xmlns:android="http://schemas.android.com/apk/res/android"
3: xmlns:tools="http://schemas.android.com/tools"
4: android:orientation="vertical"
5: android:layout_width="match_parent"
6: android:layout_height="match_parent"
7: android:padding="10dp"
8: tools:context="com.example.novaactivitysemtela.Activity_tela1" >
9:
10: <TextView
11: android:layout_width="wrap_content"
12: android:layout_height="wrap_content"
13: android:text="Entre com os 10 valores inteiros do vetor" />
14:
15: <LinearLayout
16: android:layout_width="match_parent"
17: android:layout_height="wrap_content"
18: android:orientation="horizontal" >
19:
Abaixo temos o arquivo de layout tela1.xml.
Criando um Projeto Android com uma Activity sem Tela
tela1.xml (continuação)
20: <TextView
21: android:id="@+id/tv_posicao"
22: android:layout_width="wrap_content"
23: android:layout_height="wrap_content"
24: android:text="Valor[0] = " />
25:
26: <EditText
27: android:id="@+id/et_valor"
28: android:layout_width="wrap_content"
29: android:layout_height="wrap_content"
30: android:inputType="number"
31: android:text="" />
32:
33: </LinearLayout
34:
35: <Buttom
36: android:id="@+id/bt_registrar"
37: android:layout_width="match_parent"
38: android:layout_height="wrap_content"
39: android:text="Registrar Valor" />
40:
Criando um Projeto Android com uma Activity sem Tela
tela1.xml (continuação)
41: <Buttom
42: android:id="@+id/bt_ordenar"
43: android:layout_width="match_parent"
44: android:layout_height="wrap_content"
45: android:text="Ordenar Vetor" />
46:
47: <TextView
48: android:layout_width="wrap_content"
49: android:layout_height="wrap_content"
50: android:layout_marginTop="20dp"
51: android:text="Aqui apresentamos o vetor ordenado." />
52:
43: <TextView
54: android:id="@+id/tv_ordenado"
55: android:layout_width="wrap_content"
56: android:layout_height="wrap_content"
57: android:text="" />
58:
59: </LinearLayout>
Criando um Projeto Android com uma Activity sem Tela
Ao lado temos o arquivo
Activity_tela1.java responsável
pela execução do nosso
projeto.
Este arquivo será responsável
pela entrada dos dados, chamar
uma nova Activity, que
realizará os cálculos, e de
apresentar os resultados.
Activity_tela1.java
1: package com.example.novaactivitysemtela;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: import android.view.View;
7: import android.widget.*;
8: 
9: public class Activity_tela1 extends Activity
10: {
11: int[] valore = new int[10];
12: int pos = 0;
13:
14: TextView tv_posicao, tv_ordenado;
15: EditText et_valor;
16: Button bt_registrar, bt_ordenar;
17:
18: @Override
19: protected void onCreate(Bundle savedInstanceState)
20: {
21: super.onCreate(savedInstanceState);
22: setContentView(R.layout.tela1);
23:
24: tv_posicao = (TextView) findViewById(R.id.tv_posicao);
25: tv_ordenado = (TextView) findViewById(R.id.tv_ordenado);
26: et_valor = (Button) findViewById(R.id.et_valor);
27: bt_registrar = (TextView) findViewById(R.id.bt_registrar);
28: bt_ordenar = (Button) findViewById(R.id.bt_ordenar);
29:
Criando um Projeto 
Android com uma 
Activity sem Tela
Activity_tela1.java (continuação)
30: bt_registrar.setOnClickListener(new View.OnClickListener()
31: {
32: @Override
33: public void onClick(View v)
34: {
35: valores[pos] = Integer.parseInt(et_valor.getText().toString());
36: pos++;
37: if (pos == 10)
38: {
39: bt_registrar.setEnabled(false);
40: et_valor.setEnabled(false);
41: }
42: else
43: {
44: tv_posicao.setText("Valor[" + pos + "] = ");
45: et_valor.setText("");46: }
47: }
48: });
49: 
Criando um Projeto Android com uma Activity sem Tela
Activity_tela1.java (continuação)
50: bt_ordenar.setOnClickListener(new View.OnClickListener()
51: {
52: @Override
53: public void onClick(View v)
54: {
55: Intent envio = new Intent(Activity_tela1.this, Activity_calculo.class);
56: envio.putExtra("Valores", valores);
57: startActivityForResult(envio, 1);
58: }
59: });
60: }
61:
Criando um Projeto Android com uma Activity sem Tela
O método listagem() é o responsável por apresentar o resultado, isto é, listar o vetor recebido de
Activity_calculo.
Activity_tela1.java (continuação)
62: @Override
63: protected void OnActivityResult(int requestCode, int resultCode, Intent recebido)
64: {
65: if (recebido != null)
66: {
67: if (requestCode == 1)
68: {
69: valores = recebido.getIntArrayExtra("Valores");
70: listagem();
71: }
72: }
73: }
74:
75: void listagem()
76: {
77: for(int pos = 0; pos < 10; pos++)
78: {
79: tv_ordenado.setText(tv_ordenado.getText().toString()+"\nValor[" + pos + "] = " + valores[pos]);
80: }
81: }
82: }
Criando um Projeto Android com uma Activity sem Tela
Abaixo temos o arquivo Activity_calculo.java responsável pela ordenação do vetor recebido.
Activity_calculo.java
1: package com.example.novaactivitysemtela;
2: 
3: import android.app.Activity;
4: import android.content.Intent;
5: import android.os.Bundle;
6: 
7: public class Activity_calculo extends Activity
8: {
9: int[] valore = new int[10];
10:
11: @Override
12: protected void onCreate(Bundle savedInstanceState)
13: {
14: super.onCreate(savedInstanceState);
15:
16: Intent recebido = getIntent();
17: valores = recebido.getIntArrayExtra("Valores");
18:
Activity_calculo.java (continuação)
19: boolean trocou;
20: do
21: {
22: trocou = false;
23: for (int i=1; i<10; i++)
24: if (valores[i-1] > valores[i])
25: {
26: int temp = valores[i-1];
27: valores[i-1] = valores[i];
28: valores[i] = temp;
29: trocou = true;
30: }
31: }while (trocou);
32:
33: recebido.putExtra("Valores", valores);
34: setResult(1, recebido);
35: finish();
36: }
37: }
Criando um Projeto Android com uma Activity sem Tela
O método finish(), usado na linha 36, serve para finalizar a Activity. A Activity anterior entra em execução.
Prof: Ricardo Quintão
email: ricardo.quintao@uva.br
Site: www.rgquintao.com.br