Busca

Mark Vasconcelos Creative Solutions

Teaching & Learning

Categoria

Android

Simpliest way to implement android.os.Parcelable and Parcelable.Creator trought Json converter library / Maneira mais simples de implementar Parcelable no Android

Caros, segue solução mais simples possível que encontrei para implementar Parcelable no Android (Obs.: Post em inglês).

I recently found a simple solution to implement the android.os.Parcelable interface (and Creator) on Android trought the usage of Gson library API.

The solution is to write one string and read one string from the Parcels at writeToParcel/readFromParcel with the results from Gson.toJson and Gson.fromJson

The resulted code doesn’t requires methods reading every item from parcels, and the model class doesnt need constructors too.

A sample is implemented in the following model:

class User {
long id;
String login;
String pass;

/**
* @param dest
* Writes String Gson.toJson(this) into 'dest'
*/
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(new Gson().toJson(this));
}
public transient static final Parcelable.Creator<User> CREATOR = new Creator<User>() {
/**
* @param source
* @return read string from 'source' as Gson
*/
@Override public User createFromParcel(Parcel source) {
return new Gson().fromJson(source.readString(), User.class);
}

@Override public User[] newArray(int size) { return new User[size]; }};

@Override public int describeContents() { return 0; }
}

PS: Sorry the try of making the relevants part of code clearly by this formatation.

 

😉

[]’s

Design Android – Dicas oficiais

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

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

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

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)

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

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

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

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.

Blog no WordPress.com.

Acima ↑