Design Android – Dicas oficiais

13 01 2012

O Ice Cream Sandwich (Android 4.0) fez vários avanços para tornar o visual do Android algo consistente e coerente.

Os apps do Google agora têm design e comportamento semelhante, e os desenvolvedores de apps deveriam fazer o mesmo.

Felizmente, o Google ensina como fazer isto através de dicas de design, veja no site oficial Android Design.

Noticia via Gizmodo





#CaféComJava – Android Presentation

5 09 2011

Finalmente fiz upload dos slides que usei na minha apresentação no Café com Java de agosto na Caelum.

Fiz o upload no SlideShare e pode ser acessado através desse link.

Titulo: Android Overview
Conteudo: Uma visão geral da plataforma Android junto com codigos simples de exemplo.





Android snippet – Usando um Device para desenvolvimento

13 07 2011

Como eu já disse varias vezes, o emulador do Android é MUITO lento, dependendo da aplicação demora segundos coisas que são quase instantaneas em um aparelho de verdade.

Mas assim como é possivel enviar o APK durante desenvolvimento para o AVD (Android Virtual Device), também é possivel envia-lo diretamente para um aparelho conectado no computador.

Para fazer isso, basta ter um aparelho com Android e o ambiente de progamação instalado.

Primeiro:
No seu Device com Android, vá em Configuração > Aplicações > Desenvolvimento, e habilite “Depuração de USB”.
Conecte seu aparelho via USB no computador.

No Eclipse, vá na perspectiva DDMS, e na lista de devices, escolha o seu aparelho que apareceu.

Se invés de um id, tiver aparecido varias interrogações como na foto abaixo, é preciso reiniciar o adb em modo root.

Para isso:
Via terminal, navegue até a pasta de instalação do Android SDK.

Dentro dela, vá em platform-tools e execute os seguintes comandos:

./adb kill-server
sudo ./adb root

PS: Esses são os comandos unix, para Windows deve ser algo bem parecido (provavelmente sem o ‘./’)

Agora volte ao Eclipse e selecione seu device.

Crie uma aplicação de teste para a mesma versão do Android do seu device.

Vá em Run As.. Android Application, e seu aplicativo será aberto no device.

Se o AVD também estiver aberto é possivel que o seu aplicativo rode nele, para mudar isso, entre em Run As.. > Run Configurations.. na aba Target escolha “manual”, quando rodar a aplicação ele vai mostrar a lista de devices para escolher em qual lançar, no modo automatic sem nenhum “preferred Android Virtual Device” selecionado ele também exibe a lista, a diferença é que se tiver apenas um AVD disponivel o seu aplicativo roda-rá nele.





Android – Toast – code snippet

8 06 2011

Toasts são uma maneira simples de exibir uma mensagem curta ao usuario.

Para utilizar é muito simples, basta utilizar o método Toast.makeText para criar um Toast e mandar exibir.

O método makeText recebe três parametros:

  • Context context – O contexto, pode ser uma Activity ou algum Context que voce pegue de algum lugar (getApplicationContext() e etc)
  • CharSequence text – O texto a ser exibido
  • int duration – A duração que o Toast será exibido, por padrão existe os valores Toast.LENGHT_LONG e Toast.LENGHT_SHORT

Um pequeno código de exemplo:

Toast toast = Toast.makeText(context, "Texto para o usuario", Toast.LENGTH_LONG);
toast.show();

E o resultado disso é algo como o seguinte:





Android – Controles do Emulador (AVD)

11 05 2011

Essa lista consta no seguinte link.

Esses são os controles para utilizar o emulador como um device.

Ação emulada Botão no teclado
Home HOME
Menu F2 ou Page-up button
Star Shift-F2 ou Page Down
Back ESC
Call/dial F3
Hangup/end call F4
Search F5
Power (lock device) F7
Audio volume up KEYPAD_PLUS, Ctrl-5
Audio volume down KEYPAD_MINUS, Ctrl-F6
Camera Ctrl-KEYPAD_5, Ctrl-F3
Mudar para orientação anterior KEYPAD_7, Ctrl-F11
Mudar para proxima orientação KEYPAD_9, Ctrl-F12
Toggle cell networking on/off F8
Toggle code profiling F9 (apenas se iniciado com -trace)
Toggle modo fullscreen Alt-Enter
Toggle modo trackball F6
Modo trackball (Enquanto pressionado) Delete
DPad left/up/right/down KEYPAD_4/8/6/2
DPad center click KEYPAD_5
Onion alpha increase/decrease KEYPAD_MULTIPLY(*) / KEYPAD_DIVIDE(/)

PS: Para usar os valores do keypad é preciso desligar o NumLock.

As ações mais utilizadas são (pelo menos por mim):

  • KEYPAD_7 ou KEYPAD_9 para mudar orientação.
  • HOME para voltar para home.
  • ESC que é o botão “return”
  • F2 que é o botão “opções”
  • Direcionais do teclado fisico (presente em alguns devices), KEYPADS 2, 4, 8 e 6
  • Touchs na tela são emulados com o mouse
  • TrackBall segurar DEL e mover o mouse

Só para constar, não é possivel emular multi-touch, para isso é necessario um device de verdade.





Android – Views – pt. 1

9 05 2011

O Android conta com várias Views por padrão, e neste artigo exploraremos algumas delas.

Uma View é similar a um JComponent, é um item que pode ser adicionado a tela onde o usuario poderá ver e interagir com ele.

Este artigo cobre apenas como criar esses elementos via XML, que é de longe a maneira mais fácil para lidar com telas.

Para continuarmos, vamos criar um projeto com os seguintes parametros:

Target: 2.1
Application Name: ViewsExample
Package Name: br.techs
Create Activity: MainActivity
Min SDK Version: 7

Views

Todas as tags de Views no Android tem suporte ao atributo id, é com ele que conseguimos acessar nossa tela após inflá-la.
As declarações de novos ids devem começar com ‘@+id/’ e depois disso demos o valor que vai ser o id.
Ex:

<TagQualquer android:id="@+id/iddesejado" />

TextView

Sempre que escolhemos a opção “Create Activity” quando estamos criando um projeto, o ADT se encarregará de criar uma classe e um main.xml que é simplesmente um TextView com as palavras “Hello World!” escritas.

O TextView é usado para exibir texto para o usuario, assim como o JLabel do Swing. Podemos controlar sua aparência e tamanho pelo XML, basta modificar os atributos na tag TextView, alguns desses atributos são:

  • android:text: valor será o texto do componente;
  • android:textColor: O valor da cor no formato ‘#RRGGBB’ em hexadecimal, é a cor do texto;
  • android:textSize: Tamanho da fonte, deve ser indicado em px, ex: ’12px';
  • android:textStyle: Style do texto (bold, italic);
  • android:background: Uma cor no formato #RRGGBB ou um drawable;

Alguns atributos são valores pré-defenidos como os do android:textStyle, mesmo assim, ainda é possivel usar mais de um valor no atributo, é aqui que entra o operador pipe “|”.
Por exemplo, se quisermos o texto em negrito usamos “bold”, em itálico usamos o valor “italic”, mas se quisermos que o texto seja negrito+itálico, podemos usar o pipe juntando os dois: “bold|italic”.

Modificamos nosso main.xml para testar estes atributos.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="match_parent"
	android:layout_height="match_parent">
	<TextView android:id="@+id/textView"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		android:text="Hello Views!"
		android:textSize="28px"
		android:textColor="#12FF88"
		android:textStyle="italic|bold"
	/>
</LinearLayout>

E agora, rodando nossa atividade já podemos ver o seguinte:

EditText

Enquanto o TextView exibe texto como um JLabel, quem oferece ao usuário um campo para ele colocar texto é o EditText (assim como o JTextField) que é filho de TextView.
Este componente não declara nenhum atributo XML novo, mas usa os do TextView, a diferença é que ele realmente permite edição.

Para tornar ele editável ou não, usamos o atributo android:editable com true ou false (true é o default). O TextView mesmo com true não permite edição.

Button

É um simples botão com algo escrito assim como o JButton. É através deles que o usuario sabe que alguma ação será realizada quando clicar.

Modificando nosso main.xml para testar esses componentes.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="match_parent"
	android:layout_height="match_parent">
	<TextView android:id="@+id/textView"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		android:text="Hello Views!"
		android:textSize="28px"
		android:textColor="#12FF88"
		android:textStyle="italic|bold" />
	<EditText android:id="@+id/editView"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		android:text="..."
		android:textSize="28px"
		android:textColor="#12FF88"
		android:textStyle="italic|bold" />
	<Button android:id="@+id/button"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		android:text="Click!"
		android:textSize="28px"
		android:textColor="#12FF88"
		android:textStyle="italic|bold" />
</LinearLayout>

Notaram alguma semelhança?

Isso por que Button e EditText estendem TextView e compartilham os atributos de texto.

E o resultado da nossa tela até agora é o seguinte:

CheckBox

É um botão que permite ao usuario alternar entre as opções marcado/desmarcado.

Ele também estende TextView, e o valor atribuido em ‘android:text’ é o texto visivel ao lado do CheckBox.

ToggleButton

ToggleButton são botões como o CheckBox, mas indicam marcado/desmarcado com uma ‘luz’ invés do efeito de desenho de um “tick”.
O atributo ‘android:text’ não tem efeito nesse componente, por padrão o texto é alternado entre ON e OFF, sendo possivel usar os atributos como color, style, size e etc.. para modificar a aparencia desse texto.
Esse componente tem dois atributos a mais para sua tag.

  • android:textOn: O texto que será exibido quando estado for ON
  • android:textOff: O texto que será exibido quando estado for OFF

RadioButton

São botões como o CheckBox que permitem marcá-lo, mas não é possivel desmarcá-lo.
Para se obter o efeito de seleção unica, é necessario adicionar eles dentro de um RadioGroup.

E o nosso XML final:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout android:orientation="vertical"
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="match_parent" android:layout_height="match_parent">
	<TextView android:id="@+id/listView" android:layout_width="match_parent"
		android:layout_height="wrap_content" android:text="Hello Views!"
		android:textSize="28px" android:textColor="#12FF88" android:textStyle="italic|bold" />
	<EditText android:id="@+id/textView" android:layout_width="match_parent"
		android:layout_height="wrap_content" android:text="..."
		android:textSize="28px" android:textColor="#12FF88" android:textStyle="italic|bold" />
	<Button android:id="@+id/button" android:layout_width="match_parent"
		android:layout_height="wrap_content" android:text="Click!"
		android:textSize="28px" android:textColor="#12FF88" android:textStyle="italic|bold" />
	<CheckBox android:id="@+id/check" android:layout_width="match_parent"
		android:layout_height="wrap_content" android:text="Check it!"
		android:textSize="28px" android:textColor="#12FF88" android:textStyle="italic|bold" />
	<ToggleButton android:id="@+id/tbutton"
		android:layout_width="match_parent" android:layout_height="wrap_content"
		android:textOn="Ligado" android:textOff="Desligado" android:textSize="28px"
		android:textColor="#12FF88" android:textStyle="italic|bold" />
	<RadioGroup android:layout_width="match_parent"
		android:layout_height="wrap_content">
		<RadioButton android:id="@+id/r1button"
			android:layout_width="match_parent" android:layout_height="wrap_content"
			android:text="Opção 1" android:textSize="28px" android:textColor="#12FF88"
			android:textStyle="italic|bold" />
		<RadioButton android:id="@+id/r2button"
			android:layout_width="match_parent" android:layout_height="wrap_content"
			android:text="Opção 2" android:textSize="28px" android:textColor="#12FF88"
			android:textStyle="italic|bold" />
	</RadioGroup>
</LinearLayout>

Note que todos eles tem os atributos do TextView, tornando fácil personalizá-los.

E o resultado final da nossa aplicação é como a seguinte:

PS:
Para facilitar, indiquei aqui para criar um novo projeto para esse artigo. Mas o código original está no projeto AndroidTechs, e a nossa MainActivity lá é a ViewActivity e o main.xml é a views.xml.

Esse é o primeiro artigo sobre Views, aqui apresentei apenas as mais comuns para um programa Android, guardarei umas Views mais interessantes para depois. ;)





Desenvolvimento de Games com Android

29 03 2011

Saiu o artigo de desenvolvimento de jogos com Android que escrevi para o Ponto V!

Veja lá no .V

No artigo explico a lógica de um jogo de Pong e também como implementa-la no Android, não deixem de ler.

Abraços





Android – Fullscreen snippet

1 03 2011

Para fazer uma atividade ser exibida em FullScreen no Android é bastante simples.

Basta adicionar as seguintes linhas no método onCreate da sua atividade, antes de definir o conteudo (setContentView).

	public void onCreate(Bundle savedInstance) {
		super.onCreate(savedInstance);
		
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
		
		setContentView(R.layout.main);
	}

É possivel ainda alternar de modo fullscreen para normal através do método clearFlags, mas é impossivel ter a barra de titulo de volta programaticamente.

Ou então para ser mais pratico, é possivel aplicar um Theme na sua Activity pelo AndroidManifest, basta declarar o atributo android:theme com um Style sem Title e Fullscreen.

Uma tag Activity ficaria como a seguinte:

		<activity android:name="LibraryActivity"
			android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
			<intent-filter>
				<action android:name="android.intent.action.MAIN" />
				<category android:name="android.intent.category.LAUNCHER" />
			</intent-filter>
		</activity>

Em ambos os casos sua atividade sera exibida em fullscreen.





Android – Gallery snippet

22 02 2011

Começando a serie de code snippets, os outros artigos são feitos para quem quer aprender Android do zero, nao exatamente do zero pois é preciso ter uma boa base de Java para se adaptar.

A serie de snippets são para aqueles que já sabem alguma coisa de Android, e essas são dicas uteis para criarem aplicações cada vez mais legais.

Hoje vim falar do componente Gallery, ele é um componente que permite visualizar uma serie de itens com scroll, e como exemplo desse componente vamos criar uma aplicaçao que permita ver fotos em scroll com suporte a titulos.

Nossa tela é simplesmente um TextView seguido de uma Gallery para escolher a imagem, o XML é o seguinte:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical" android:layout_width="fill_parent"
	android:layout_height="fill_parent">
	<TextView android:id="@+id/title" android:layout_width="wrap_content"
		android:layout_height="wrap_content" android:text="Titulo"
		android:layout_gravity="center" />
	<Gallery android:id="@+id/gallery" android:layout_width="fill_parent"
		android:layout_height="fill_parent" />
</LinearLayout>

Para usa-lo precisamos criar um Adapter que faz o papel do Model e do Renderer para o nosso componente, ele que constroi os itens que vão para a Gallery.

Primeiro uma entidade simples que representa uma imagem na galeria.

	public class Picture {
		private String title;
		private Bitmap image;

		public Picture(String title, Bitmap image) {
			this.title = title;
			this.image = image;
		}
//Getters & Setters
	}

E o Adapter para trazer os dados ao Gallery

	private class ImageAdapter extends BaseAdapter {
		private List<Picture> images;
		private Context context;

		public ImageAdapter(Context context, List<Picture> images) {
			this.images = images;
			this.context = context;
		}

		@Override
		public int getCount() {
			return images.size();
		}

		@Override
		public Object getItem(int position) {
			return images.get(position);
		}

		@Override
		public long getItemId(int position) {
			return position;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			ImageView item = null;

			if (convertView != null)
				item = (ImageView) convertView;
			else
				item = new ImageView(context);

			item.setLayoutParams(new LayoutParams(280, 460));
			item.setImageBitmap(((Picture) getItem(position)).getImage());

			return item;
		}
	}

Com ele pronto basta criar nossa Activity e usa-lo como Adapter ao Gallery que declaramos no layout.

Nesse exemplo eu coloquei uma pasta com 7 imagens nomeadas de book1 à book7 para adicionar na galeria.

public class GallerySnippetActivity extends Activity {
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		setContentView(R.layout.gallery_snippet);

		final TextView title = (TextView) findViewById(R.id.title);
		final Gallery gallery = (Gallery) findViewById(R.id.gallery);

		final List<Picture> pics = new ArrayList<Picture>();
		pics.add(new Picture("Pic 1", load(R.drawable.book1)));
		pics.add(new Picture("Pic 2", load(R.drawable.book2)));
		pics.add(new Picture("Pic 3", load(R.drawable.book3)));
		pics.add(new Picture("Pic 4", load(R.drawable.book4)));
		pics.add(new Picture("Pic 5", load(R.drawable.book5)));
		pics.add(new Picture("Pic 6", load(R.drawable.book6)));
		pics.add(new Picture("Pic 7", load(R.drawable.book7)));

		gallery.setAdapter(new ImageAdapter(this, pics));
	}

	private Bitmap load(int resourceId) {
		return BitmapFactory.decodeResource(getResources(), resourceId);
	}
}

Com isso vemos nossa tela, ela é até bem legal, mas seria mais interessante o TextView title se atualizar de acordo com o scroll do usuario, e é ai que entra a dica desse snippet. O listener que recebe os Callbacks dos eventos de scroll no Gallery é o OnItemSelectedListener, implementamos ele para pegar a Picture na posição dada e atualizar nossa TextView.

		gallery.setOnItemSelectedListener(new OnItemSelectedListener() {
			public void onItemSelected(AdapterView<?> arg0, View arg1,
					int arg2, long arg3) {
				Picture book = pics.get(arg2);
				title.setText(book.title);
			}

			public void onNothingSelected(AdapterView<?> arg0) {
			}
		});

Com isso é possivel fazer o scroll e atualizar os campos necessarios na tela, essa dica é muito util para fazer algo como, selecionar um CD, um Livro ou o que a imaginação deixar.





Android – Activity

3 02 2011

Nota: Programar para Android tem certas semelhanças com o Swing, se você já sabe Swing será mais fácil se adaptar.

Activity

Cada Activity, é uma tela da sua aplicação.

Ele é basicamente um Form onde é possivel adicionar componentes (Views) e programar eventos.

Seu programa iniciará na Activity que for declarada no AndroidManifest.xml como sendo a principal.

Vamos começar a programar algo para entender como funciona.

Abra o Eclipse, crie um novo projeto Android com os seguintes parâmetros

Target: 2.2.
Application name: Todo List
package name: br.teaching.android
Create Activity: TodoListActivity
Min SDK Version: 8

Agora abra o arquivo br/teaching/android/TodoListActivity.java e vamos dar uma olhada no que tem nele.

package br.teaching.android;

import android.app.Activity;
import android.os.Bundle;

public class TodoListActivity extends Activity {
 /** Called when the activity is first created. */
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 }
}

Esse é o código default gerado automaticamente de um programa Hello World para Android.

Como funciona?

public class TodoListActivity extends Activity{

Todas telas da nossa aplicação devem estender Activity para rodar, o Android a usa para o lifecycle.

@Override
public void onCreate(Bundle savedInstanceState)

O método onCreate é invocado quando é solicitado à sua tela, antes que seja exibida. É aqui que registramos os listeners para os eventos, adicionamos componentes, modificamos outros e etc..

super.onCreate(savedInstance);

O Android realiza algumas operações que não nos afetam diretamente na programação a não ser o fato de que se não for invocado um android.app.SuperNotCalledException vai ser lançado.

setContentView(R.layout.main);

Aqui está a magica para colocar os componentes na tela, existe um arquivo chamado main.xml dentro da pasta res/layout, e nós usamos R.layout.main para referir a ele, o setContentView vai ler esse XML, inflá-lo e carregá-lo na tela.

Layout via XML

Vamos agora dar uma olhada no arquivo main.xml abra-o, se for aberto pelo modo ‘Graphical Layout’, clique na aba chamada ‘main.xml’ para mostrar como texto, e ele será o seguinte.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello" />
</LinearLayout>

Nós criamos o layout da tela via XML, colocando as tags em hierarquia. Nesse caso estamos usando o LinearLayout que ocupa a tela inteira (fill_parent, fill_parent) com um TextView que ocupa toda largura dentro do Layout (fill_parent) mas ocupa só o necessario em altura (wrap_content).

Existem três valores possiveis para os atributos android:layout_(width/heigth):

  • match_parent – O componente irá ocupar todo o espaço disponivel;
  • fill_parent – Igual ao match_parent, mas esse valor foi depreciado e pode-se usar match_parent no lugar;
  • wrap_content – O componente ocupara apenas o tamanho necessario que ele precise para exibir seu conteudo corretamente;

Repare também que o atributo android:text tem o valor “@string/hello”, essa String está declarada em res/values/strings, e é possivel usar esses valores pelo nome do tipo (@strings/) e nome do valor “hello”.

Esse XML representa a tela que vimos ao rodar o programa, apenas um TextView dentro de um Layout.

Para obter a referencia dos componentes via programação e também dentro do XML, precisamos declarar um id para eles no atributo android:id, o valor usado é no padrão “@+id/<idcomponente>”, usamos o @+id para adicionar um novo valor, e o id será o descrito em <idcomponente>. Para usarmos dentro do XML como referencia em outro componente usamos “@id/idcomponente”, programaticamente usamos a classe R.

Como exemplo vamos modificar esse XML para transformar nosso programa em uma lista de coisas a fazer (TodoList). Vamos alterar o layout e colocar alguns componentes na tela.
O layout da nossa tela será um EditText seguido de um Button com uma ListView embaixo.

Usarei o RelativeLayout que é um LayoutManager onde é possivel colocar os componentes em posição relativa aos outros, como acima, abaixo, à direita, à esquerda, alinhado e etc.. informamos isso com as tags android:layout_<direção>=”<id-anchor>”.

O exemplo modificado:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical" android:layout_width="fill_parent"
	android:layout_height="fill_parent">
	<EditText android:id="@+id/text" android:layout_width="wrap_content"
		android:layout_height="wrap_content" android:text="@string/hello" />
	<Button android:id="@+id/button" android:layout_width="wrap_content"
		android:layout_height="wrap_content" android:text="Adicionar"
		android:layout_toRightOf="@id/text" />
	<ListView android:id="@+id/listView" android:layout_width="fill_parent"
		android:choiceMode="singleChoice" android:layout_height="fill_parent"
		android:layout_below="@id/text" />
</RelativeLayout>

Rodando novamente o programa veremos o resultado do nosso novo layout.

A nossa tela está pronta, agora falta um pouco de ações para ela.
Voltamos ao arquivo TodoListActivity.java.

Trabalhando com os componentes no código

Após setContentView(R.layout.main) podemos acessar os componentes da nossa tela pelo método findViewById(int id), e o id é o que colocamos nos componentes pelo atributo android:id, que são acessiveis pela classe R.

O seguinte código pega nossas três Views como objetos.

EditText text = (EditText) findViewById(R.id.text);
Button button = (Button) findViewById(R.id.button);
ListView list = (ListView) findViewById(R.id.listView);

Com objetos em mão, podemos começar a trabalhar com eles.

Para os dados aparecerem na lista é necessario um Adapter de uma lista de Strings como modelo de dados.

List data = new ArrayList();
ArrayAdapter adapter = new ArrayAdapter(
 getApplicationContext(), android.R.layout.simple_list_item_1,
 data);
 list.setAdapter(adapter);

No Android temos eventos como OnTouchListener, OnClickListener, OnLongClickListener e alguns outros que serão estudados mais a fundo em outros artigos.
Agora podemos criar um evento que ao clicar no botão o texto seja exibido na ListView.

button.setOnClickListener(new View.OnClickListener() {
 @Override
 public void onClick(View v) {
 // O método getText() da classe EditText retorna um Editable, e
 // não uma String ele também implementa CharSequence e por costume
 // uso toString só pra retornar uma String normal.
 String txt = text.getText().toString();
 data.add(txt);
 adapter.notifyDataSetChanged();
 }
 });

Depois disso o próprio Android ira se encarregar de exibir a aplicação, ele vai exibir seu contentView na tela.

Clicando no botao com algum texto teremos algo parecido com isso.

Layout via código

Existem duas formas para criar o layout e adicionar os componentes em uma tela, via XML ou programaticamente.

O código para a mesma tela, com um LayoutManager diferente escrita no código seria o seguinte.

EditText text = new EditText(this);
 ListView list = new ListView(this);
 Button button = new Button(this);
 // Via codigo também é possivel acessar as Strings que estão em
 // resources, o seguinte é o mesmo que o atributo
 // android:text="@string/hello"
 text.setText(R.string.hello);
 button.setText("Adicionar");

 LinearLayout layout = new LinearLayout(this);
 layout.setOrientation(LinearLayout.HORIZONTAL);

 LinearLayout top = new LinearLayout(this);
 layout.setOrientation(LinearLayout.VERTICAL);

 top.addView(text, new LayoutParams(
 RelativeLayout.LayoutParams.MATCH_PARENT,
 RelativeLayout.LayoutParams.WRAP_CONTENT));
 top.addView(button, new LayoutParams(
 RelativeLayout.LayoutParams.WRAP_CONTENT,
 RelativeLayout.LayoutParams.WRAP_CONTENT));

 layout.addView(top, new LayoutParams(
 RelativeLayout.LayoutParams.WRAP_CONTENT,
 RelativeLayout.LayoutParams.WRAP_CONTENT));
 layout.addView(list, new LayoutParams(
 RelativeLayout.LayoutParams.MATCH_PARENT,
 RelativeLayout.LayoutParams.MATCH_PARENT));

 setContentView(layout);

Como não é muito pratico, vou continuar os proximos exemplos usando XML, que além de ser recomendado é mais fácil de ser escrito e lido.

Código fonte dos exemplos

O código completo da aplicação está no repositorio do GitHub, é possivel ver pelo site ou ainda baixar o código completo, explore.








Seguir

Obtenha todo post novo entregue na sua caixa de entrada.

Junte-se a 154 outros seguidores