Algoritmo de sort com bug, está no Java, Python e Android

  Um algoritmo de sort (TimSort) usado em Java, Python e no Android contém um bug. Foi descoberto por Stijn de Gouw e outros pesquisadores.
  Stijn de Gouw publicou detalhes no link abaixo. Lá contém o erro, as explicações e a correção.
  Eles usaram técnicas avançadas da ciência da computação chamadas como métodos formais.
  Se você já teve um java.lang.ArrayIndexOutOfBoundsException num sort, provavelmente foi esse bug.
  Vale uma leitura detalhada no post.

http://envisage-project.eu/proving-android-java-and-python-sorting-algorithm-is-broken-and-how-to-fix-it/

  Abraços

Cancelando uma AsyncTask

  Logo no início dos meus estudos testei a classe AsyncTask, vejo que é uma classe problemática para os desenvolvedores Android. Problema, no sentido de dificuldade de entendimento do seu funcionamento.
  Inclusive, o pessoal do Android ajudou um pouco nessa confusão. Quando foi disponibilizado, no Android 1.5 - Cupcake (API 3), a tarefa era executada em um única thread em background. Logo em seguida, nas versões 2.x (API 4 a 10) isso foi mudado para um pool de threads, permitindo que várias tarefas rodassem em paralelo. Para, voltar a executar sequencialmente, uma tarefa por vez, no Android 3.0 - Honeycomb (API 11). Isso para evitar erros de aplicativos causados por execução paralela. O problema não estava, evidentemente, na AsyncTask e sim em como as tarefas foram implementadas.
  Mas, isso é história. O objetivo desse post é retornar num exemplo que postei há muito tempo. Link abaixo. O objetivo é incluir uma forma de cancelar uma tarefa quando a activity entrar nos métodos onPause, onStop ou onDestroy. Escolher em qual (ou quais) método colocar o cancelamento vai depender de cada caso, no meu exemplo, coloco em todos.
  Para cancelar basta usar o método da AsyncTask cancel(true), na verdade, não é cancelado automaticamente, é solicitado um cancelamento. A tarefa em execução precisa ser passível de responder ao pedido de cancelamento. Na tarefa, o método isCancelled() é usado para checar se o cancelamento foi solicitado. É recomendado checar sempre antes de executar um processamento demorado.

  Segue o código que usei no post do link abaixo com as alterações:

package br.com.agorandroid.testeasynctask02; import android.app.Activity; import android.app.ProgressDialog; import android.os.AsyncTask; import android.os.Bundle; import android.util.Log; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.Toast; /** * @author A H Gusukuma * agorandroid.blogspot.com */ public class TesteAsyncTask02Activity extends Activity { Button button; ProgressAsyncTask mAsyncTask; ProgressDialog progressDialog; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); button = (Button) findViewById(R.id.iniciarAsyncTask); button.setOnClickListener(new OnClickListener() { public void onClick(View v) { ativaAsyncTask(); } }); } protected void onPause() { if (mAsyncTask != null) { mAsyncTask.cancel(true); mAsyncTask = null; } Log.i("Teste","onPause"); super.onPause(); } protected void onStop() { if (mAsyncTask != null) { mAsyncTask.cancel(true); mAsyncTask = null; } Log.i("Teste","onStop"); super.onStop(); } protected void onDestroy() { if (mAsyncTask != null) { mAsyncTask.cancel(true); mAsyncTask = null; } Log.i("Teste","onDestroy"); super.onDestroy(); } private void ativaAsyncTask() { progressDialog = new ProgressDialog(TesteAsyncTask02Activity.this); progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); progressDialog.setMessage("Running..."); progressDialog.setCancelable(false); progressDialog.show(); mAsyncTask = new ProgressAsyncTask(); mAsyncTask.execute(); } private class ProgressAsyncTask extends AsyncTask<Void, Integer, Integer> { final static int STATE_DONE = 0; final static int STATE_RUNNING = 1; int mState; int total; protected void onPreExecute() { progressDialog.setProgress(0); } protected Integer doInBackground(Void...progress) { mState = STATE_RUNNING; total = 0; while (!isCancelled() && mState == STATE_RUNNING) { total++; publishProgress(total); if (total>=100) { mState = STATE_DONE; } try { Thread.sleep(1000); } catch (InterruptedException e) { } } return total; } protected void onProgressUpdate(Integer... progress) { progressDialog.setProgress(progress[0]); } protected void onPostExecute(Integer result) { progressDialog.dismiss(); Toast.makeText(TesteAsyncTask02Activity.this, "Fim da AsyncTask", Toast.LENGTH_SHORT).show(); } protected void onCancelled(Integer result) { progressDialog.dismiss(); Log.i("Teste","fim"); Toast.makeText(TesteAsyncTask02Activity.this, "AsyncTask cancelada", Toast.LENGTH_SHORT).show(); } } }

  Faltou dizer que ao cancelar a AsyncTask, o método onPostExecute não será chamado, em seu lugar, o método onCancelled deve ser executado.

http://agorandroid.blogspot.com.br/2012/02/asynctask-e-progressdialog-ex04.html

 Abraços

Android básico: Usando o onSaveInstanceState

  Em algumas situações o sistema pode encerrar sua activity, seja por falta de recursos ou por mudança de orientação da tela. Nesses casos, o método onSaveInstanceState é chamado para permitir ao programador salvar algum dado da activity. O método é chamado com uma referencia a um bundle, nele é que se deve salvar o(s) dado(s). Quando a activity for recriada esse bundle é passado para o onCreate e onRestoreInstanceState.

  Segue abaixo um esquema básico:

Salva o(s) dados(s):

@Override public void onSaveInstanceState(Bundle savedInstanceState) { savedInstanceState.putInt("controle", mControle); super.onSaveInstanceState(savedInstanceState); }


Recupera o(s) dado(s), aqui:

@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); if (savedInstanceState != null) { mControle = savedInstanceState.getInt("controle"); } ... }


Ou aqui:

public void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); mControle = savedInstanceState.getInt("controle"); }

  Os dados da tela são salvos e restaurados automaticamente, por isso é fundamental chamar o método no super.
  Lembrar que esse procedimento só deve ser usado para dados temporários (transitórios), pois são salvos em memória, correndo o risco de serem descartados.
  Em caso de dados importantes, ou na dúvida, salve-os de maneira persistente.

Abraços

Curso Android online

Este curso oferecido pelo Coursera é bem interessante:

Programação de aplicativos para dispositivos móveis com sistema Android: Part 1

Programação de aplicativos para dispositivos móveis com sistema Android: Part 2

O inglês do professor Adam Porter é bem fácil, compreensível.

É bom ter um nível intermediário de conhecimentos de programação Java e, apesar de não ser um pré-requisito, é interessante ter um nível introdutório em Android. Vai aproveitar mais.

Assisti todas as aulas da parte 1 e estou acompanhando a parte 2. 

Gostei, recomendo.

Abraços

Android básico: retornando dados de uma activity para outra.

 Um fato que acontece com frequencia é a necessidade de capturar o retorno de uma outra activity. Para isso temos que chamar a activity com um método específico, o startActivityForResult.
 Por exemplo, a ActivityA invoca a ActivityB com startActivityForResult e aguarda o retorno em onActivityResult. Na ActivityB o retorno é passado via uma Intent, posicionado via setResult. 

 Abaixo segue o esquema básico:

 Na activity chamadora, ActivityA:

Intent intent = new Intent(ActivityA.this, ActivityB.class); // se necessário passar algum dado, usar intent.putExtra int requestCode = CONSULTA; // CONSULTA é uma constante int startActivityForResult(intent, requestCode); ... protected void onActivityResult(int requestCode, int resultCode, Intent intentDeRetorno) { if (requestCode == CONSULTA) { if (resultCode == RESULT_OK) { // = intentDeRetorno.getStringExtra("retorno"); // trata os dados retornados

 Na activity chamada, ActivityB:

Intent intentDeRetorno = new Intent(); intentDeRetorno.putExtra("retorno", algumRetorno); int resultCode = RESULT_OK; setResult (resultCode, intentDeRetorno); finish();


 Abraços

Android básico: a classe Bundle

 Classe Bundle:  Um mapa de chave/valor, onde chave é uma String e valor tipos primitivos ou objetos empacotáveis (Parcelable) e/ou serializáveis. Em outras palavras, é uma classe utilitária para armazenar/transportar dados, um container.

 Todo iniciante em programação Android, toma contato com essa classe logo no primeiro app:

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);

 Se você tiver um material mais antigo, pode ser assim:

@Override public void onCreate(Bundle icicle) { super.onCreate(icicle);

Além de estar no onCreate, o Bundle também está em outros métodos da activity, como em onSaveInstanceState, onRestoreInstanceState. Está também na classe Intent, como um atributo usado para passar/receber dados. Os métodos com "Extra" no nome.

 O formato geral para acessar é: getXxx.
 O formato geral para incluir é: putXxx.

Onde Xxx é o tipo do dado, getInt, putInt, getFloat, putFloat, getIntArray, putString, etc.


Abraços

Relembrando: As regras sagradas do Android

Postei essas regras faz um bom tempo, como continuam válidas vamos relembrar:

O Android tem duas regras sagradas:

1. Não bloqueie a UI Thread.

2. Não atualize a tela através de uma outra thread.

Ou seja, não faça nada demorado na UI Thread e só atualize a tela pela UI Thread.

Para isso temos os seguintes recursos para implementar um código que cumpra as regras acima:

1. Thread

2. Runnable

3. Handle

4. AsyncTask

Além dos recursos citados, em outro post fiz uma lista mais completa (link abaixo).

As regras sagradas do Android

Recursos para processamento assíncrono no Android

Abraços

Impressões sobre a leitura do Livro Dominando o Android - Do Básico ao Avançado

Livro: "Dominando o Android - Do Básico ao Avançado"
Autor: Nelson Glauber
ISBN: 978-85-7522-412-0
Páginas: 792
Ano: 2015

Estou lendo o livro "Dominando o Android - Do Básico ao Avançado", devo ter lido mais de 300 páginas, então já dá para dar uma opinião.
O livro é bom, muito bem escrito. Recomendo, com uma ressalva: não é indicado para quem está iniciando o aprendizado no desenvolvimento Android com o livro. Ele tem vários tópicos interessantes, mas pela abordagem, creio que um iniciante vai ter alguma dificuldade de entendimento.
O ideal é que o leitor já tenha algum conhecimento básico e alguns projetos desenvolvidos. Aí, o livro vai ser melhor aproveitado.

Outro senão, faltou incluir o indice remissivo. Acho muito útil.

Mas, estou gostando.

Parabéns ao autor Nelson Glauber e para a editora Novatec pelo livro.

Abraços.