DSL no DemoDroid

Eu curto muito estas linguagens novas, como Groovy e Ruby. A sintaxe delas permite fazer códigos lindos. A melhor parte, para mim, é poder criar uma DSL de forma fácil e bem intuitiva. No Java, também é possível, mas não fica tão bonito como ficaria em um Groovy, por exemplo. Ah! Você está por fora do que é uma DSL? Tradução: Domain Specific Language. Eu gosto de dizer que uma DSL pode ser vista como um subconjunto de uma linguagem, ou até mesmo uma linguagem própria, para resolver problemas específicos.

Você vai por aí muitas DSLs. Já encontrei o Mirror, que é uma DSL para usar Reflexão em Java. Parece-me que é um projeto de brasileiros. Então, fica aqui meus parabéns! E você pode criar DSLs para diversos tipos de situações específicas. Olha como é o código do Mirror para definir o valor de um atributo de um objeto:

new Mirror().on(target).set().field(fieldName).withValue(value)

Percebe como a leitura deste código parece mais natural do que aquele monte de linhas da API de Reflection do Java? Você pode até ler naturalmente como: Mirror (new Mirror()), no (on) objeto tal (target) defina (set) o atributo tal (fieldName) com o valor tal (withValue). Bacana, né não? E que diabos eu quero com esse blá blá blá? Vamos lá! Nessa ideia de DSL, é que eu resolvi criar uma para incorporar no DemoDroid. Uma coisa recorrente no desenvolvimento em Android é precisar disparar uma tarefa que leva um tempo razoável de processamento e você quer exibir uma mensagem de progresso.

Para quem já programa em Android, sabe que é necessário usar a class android.os.AsyncTask. Veja abaixo um exemplo de utilização dela, retirado do BrasileirãoZ:

new AsyncTask<Void, Void, List<Jogo>>() {

	private ProgressDialog dialog;
			
	protected List<Jogo> doInBackground(Void... params) {
		try {
			return campeonato.getRodada(final_rodada).getJogos();
		} catch (Exception e) {
			messageContext.add("Erro");
		}
		return new ArrayList<Jogo>();
	}

	protected void onPreExecute() {
		if (dialog == null) {
			dialog = ProgressDialog.show(getView(), "Consultando...", "Obtendo Jogos.", true);
		}
	}

	protected void onPostExecute(java.util.List<Jogo> result) {
		JogosPresenter.this.getView().setJogos(result);
		JogosPresenter.this.getView().setRodada(final_rodada);
		dialog.dismiss();
	}
}.execute();

Nada mal, não é? Um monte de linha de código para fazer muito pouca coisa. E também pouco intuitivo para quem está lendo. Uma pessoa que pega este código para ler, precisa ter um conhecimento bem legal da classe AsyncTask para poder usá-la. E olhe que esta classe do Android até que é bem simples. Existem outras muito mais difíceis. E por que não trocar este monte de linha de código, por isso aí embaixo? Não acha mais intuitivo? Claro, ainda posso melhorar e fica aí para você me sugerir melhorias. Esse código faz um processamento muito semelhante ao daí de cima:

new Async()
	.using(getView())
	.call("getJogos").on(event.getClube()).noArgs()
	.during().show("Consultando...", "Obtendo Jogos do Clube.")
	.after().call("setJogos").on(getView()).withResultAsArg()
	.occurring().crash().alert("Tente novamente mais tarde",1)
	.occurring().success().alert("Jogos atualizados!", 1)
	.execute();