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

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 – 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.

Android – Gallery snippet

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.