Debug de Códigos

5 de dezembro de 2013

Services vs IntentServices - Android

A arquitetura Android possui várias "maravilhas" e facilidades que auxiliam os desenvolvedores na hora de criar aplicativos robustos e versáteis. Duas dessas "maravilhas" são as classes Service e IntentService, onde cada uma possui sua particulariedade, vantagens e metodologias de implementação.

Para tanto, é necessário saber quando devemos utilizar uma classe ou outra a fim de não fazer uma escolha errônea, afinal, quanto menos manutenção em nosso código fizermos, MENOS DOR DE CABEÇA! :-)

Para exemplificarmos melhor, trago abaixo uma pequena tabela compartiva para que vocês analisem e escolham qual classe implementar em seu projeto.

	Service.class	IntentService.class
Quando usar?	Tarefas sem conteúdos visuais (UI), mas sem excesso de tempo de execução. Caso for utilizar em longos processos, utilize em conjunto com Threads.	Geralmente, efetua longos processos sem comunicação com a UIThread. Caso seja necessário, recomendo utilizar Handlers ou Broadcast Intents.
Como usar?	Utilizando a chamada para startService(...), bindService(...) através do método onStartCommand(...).	Utilizando Intent apenas.
Executada a partir de qual Thread?	Qualquer Thread - com Context.	Apenas na UIThread uma vez que Intent's são utilizadas na UIThread, mas geram outras WorkerThreads.
Funciona em qual Thread?	UIThread ou Remote (Implementando o AIDL).	Em uma WorkerThread separada.
Desvantagens	Pode travar a UIThread, se mal implementada.	Não executa tarefas paralelas e caso seja necessário rodar múltiplas instâncias do IntentService, será gerado uma Fila - Queue - na mesma WorkerThread.

Service.class

IntentService.class

Activity

public class MainActivity extends Activity {

...

private ConnectionService mConn;

...

public void startService() {
      // Executando um Service...
      Intent intent = new Intent(this, MyService.class);
      startService(intent);
    }

public void bindService() {
     if (mConn == null) {
      mConn = new ServiceConnection() {

@Override
       public void onServiceConnected(ComponentName name, IBinder service) {
        MyService myService = ((MyService) service).getService();
        // Você pode chamar o método manualmente!
        myService.onStartCommand(...);
       }

@Override
       public void onServiceDisconnected (ComponentName name) {
        // unbind(...) foi chamado! :-)
       }

};
     }

Intent intent = new Intent(this, MyService.class);
     bindService(intent, mConn, Context.BIND_AUTO_CREATE);
    }

public void startIntentService() {
     Intent intent = new Intent(this, MyIntentService.class);
     intent.putExtra("pergunta", "IntentService foi executado?");
     startService(intent);
    }

@Override
    public void onDestroy() {
     super.onDestroy();

// Não esqueça!
     if (mConn != null) {
      unbindService(mConn);
     }
    }

}

Pense direito antes de implementar o tipo de Service que você deseja, ambos possuem suas vantagens e desvantagens!

Espero que ajude, abraço.

29 de novembro de 2013

Desenhando na Tela através do Touch (DrawingBoard) - Android

Ao desenvolver uma aplicativo na empresa em que trabalho, uma de minhas necessidades foi a criação de um componente visual (i.e. View) responsável por tratar eventos de touch screen e que o mesmo desenha-se o pontos em que o dedo passava.

Para isso, criei uma classe chamada DrawingBoard que possui algumas peculiaridades como limpeza do que foi desenhado e pré-desenho de um texto para que o usuário saiba que ele pode desenhar na respectiva área.

Antes de mais nada, vou falar uma pouco sobre a classe View. Ela é responsável por todos os componentes visuais do Android, afinal, como o Java utiliza os conceitos de henrança dizemos que a classe View é pai (i.e. Super Class) de todos os componentes visuais no Android.

Com isso, nossa DrawingBoard também herdará de View para que a mesma possua suas propriedades. Em especial, utilizaremos os métodos onDraw() - responsável por renderizar na tela os traços baseado em coordenadas passadas pelo touch do usuário - e onTouchEvent - responsável por analisar as ações de movimentos do dedo do usuário.

DrawingBoard:

package br.com.infocusweb.flexpag.models.views;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Calendar;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.EmbossMaskFilter;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.os.Environment;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import br.com.infocusweb.flexpag.R;

/**
 * View responsável por desenhar na tela atravás do touch.
 * 
 * @author Felipe Bonezi -> felipebonezi@gmail.com
 * @version 1.0.0
 * @category View
 * 
 */
public class DrawingBoard extends View {

private static final float  TOUCH_TOLERANCE = 4;
 private static final String DIR_ROOT_NAME = "FlexPag";
 private static final String DIR_SIGNATURE_NAME = "Signatures";
 public static final String EXTRA_SIGNATURE = "SIGNATURE_EXTRA";
 
 private int   mWidth;
 private int   mHeight;
 private int   mPaintColor;
 private int   mBoardColor;
 private float mStrokeSize;
 private float mX, mY;
 private boolean mIsEnable = true;
 private boolean mIsSigned = false;
 
 private Bitmap mBitmap;
 private Canvas mCanvas;
 private Path   mPath;
 private Paint  mPaint;
 private final Paint  mBitmapPaint;
 private final EmbossMaskFilter mEmboss;
 private String mFullName = null;
 private Paint mPaint2;
 private Rect mBoundsName;
 private Paint mTextPaint;

public DrawingBoard(final Context context) {
  super(context);
  mPath = new Path();
  mBitmapPaint = new Paint(Paint.DITHER_FLAG);
  mEmboss = new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
  mPaintColor = Color.BLACK;
  mBoardColor = Color.TRANSPARENT;
 }

public DrawingBoard(final Context context, final AttributeSet attrs, final int defStyle) {
  super(context, attrs, defStyle);
  mPath = new Path();
  mBitmapPaint = new Paint(Paint.DITHER_FLAG);
  mEmboss = new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
  mPaintColor = Color.BLACK;
  mBoardColor = Color.TRANSPARENT;
 }

public DrawingBoard(final Context context, final AttributeSet attrs) {
  super(context, attrs);
  mPath = new Path();
  mBitmapPaint = new Paint(Paint.DITHER_FLAG);
  mEmboss = new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
  mPaintColor = Color.BLACK;
  mBoardColor = Color.TRANSPARENT;
 }
 
 @Override
 protected void onSizeChanged(final int width, final int height, final int oldWidth, final int oldHeight) {
  super.onSizeChanged(width, height, oldWidth, oldHeight);
  mWidth = width;
  mHeight = height;
  mBitmap = Bitmap.createBitmap(mWidth, mHeight, Bitmap.Config.ARGB_8888);
  mCanvas = new Canvas(mBitmap);
 }

@Override
 protected void onDraw(final Canvas canvas) {
  canvas.drawColor(mBoardColor);
  canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
  if (mPaint == null) {
   final float dimen = Float.parseFloat(getContext().getString(R.dimen.text_stroke_signature).substring(0, 1));
   mStrokeSize = dimen;
   mPaint = createNewPaint(mPaintColor, mStrokeSize);
  }
  canvas.drawPath(mPath, mPaint);
  
  if(!mIsSigned && mIsEnable) {
   mPaint2 = new Paint();
            mPaint2.setColor(Color.BLACK);
            mPaint2.setTextSize(30f);
            final Rect bounds = new Rect();
   mPaint2.getTextBounds("Assine aqui...", 0, "Assine aqui...".length(), bounds);
   canvas.drawText("Assine aqui...", (mWidth / 2) - bounds.centerX(), (mHeight - 100), mPaint2);
  }
  
  canvas.drawLine(25, (mHeight - 50), (mWidth - 25), (mHeight - 50), mPaint2);
  if (mBoundsName == null) {
   mBoundsName = new Rect();
   mTextPaint = new Paint();
   final float dimen = Float.parseFloat(getContext().getString(R.dimen.text_signature).substring(0, 2));
   if (isInEditMode()) {
    mTextPaint.setTextSize(18);
   } else {
    mTextPaint.setTextSize(dimen);
   }
  }
  if(mFullName != null) {
   mTextPaint.getTextBounds(mFullName, 0, mFullName.length(), mBoundsName);
   canvas.drawText(mFullName, (mWidth/2 - mBoundsName.centerX()), (mHeight - 25), mTextPaint);
  }
 }

@Override
 public boolean onTouchEvent(final MotionEvent event) {
  if (mIsEnable) {
   draw(new Canvas());
   
   final float x = event.getX();
   final float y = event.getY();
 
   switch (event.getAction()) {
   case MotionEvent.ACTION_DOWN:
    touchStart(x, y);
    invalidate();
    break;
   case MotionEvent.ACTION_MOVE:
    touchMove(x, y);
    invalidate();
    break;
   case MotionEvent.ACTION_UP:
    touchUp();
    invalidate();
    mIsSigned = true;
    break;
   default:
    break;
   }
   return true;
  } else {
   return false;
  }
 }

private Paint createNewPaint(final int color, final float strokeSize) {
  final Paint paint = new Paint();
  paint.setAntiAlias(true);
  paint.setDither(true);
  paint.setColor(color);
  paint.setStyle(Paint.Style.STROKE);
  paint.setStrokeJoin(Paint.Join.ROUND);
  paint.setStrokeCap(Paint.Cap.ROUND);
  paint.setStrokeWidth(strokeSize);
  return paint;
 }

private void touchStart(final float x, final float y) {
  mPath.reset();
  mPath.moveTo(x, y);
  mX = x;
  mY = y;
 }

private void touchMove(final float x, final float y) {
  final float dx = Math.abs(x - mX);
  final float dy = Math.abs(y - mY);
  if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {
   mPath.quadTo(mX, mY, (x + mX) / 2, (y + mY) / 2);
   mX = x;
   mY = y;
  }
 }

private void touchUp() {
  mPath.lineTo(mX, mY);
  if (mPaint == null) {
   mPaint = createNewPaint(mPaintColor, mStrokeSize);
  }
  mCanvas.drawPath(mPath, mPaint);
  mPath.reset();
 }

public void setPaint(final Paint paint) {
  mPaint = paint;
 }

public void clearBoard() {
  mPath = new Path();
  mBitmap = Bitmap.createBitmap(mWidth, mHeight, Bitmap.Config.ARGB_8888);
  mCanvas = new Canvas(mBitmap);
  mIsSigned = false;
  invalidate();
 }

private void createDir() {
  final File file = new File(Environment.getExternalStorageDirectory()
    .getAbsolutePath().concat(File.separator).concat(DIR_ROOT_NAME)
    .concat(File.separator).concat(DIR_SIGNATURE_NAME));
  file.mkdirs();
 }

public boolean persistsSignatureAtCache() {
  final boolean canWrite = getContext().getCacheDir().canWrite();
  if (canWrite) {
   ByteArrayOutputStream byteArrayOutputStream = null;
   FileOutputStream fileOutputStream = null;
   File file = null;
   String outputDir = null;
   try {
    byteArrayOutputStream = new ByteArrayOutputStream();
    mBitmap.compress(Bitmap.CompressFormat.PNG, 60, byteArrayOutputStream);

outputDir = getContext().getCacheDir().getAbsolutePath();
    file = new File(outputDir
      .concat(File.separator)
      .concat("signature").concat(".png"));
    file.createNewFile();

fileOutputStream = new FileOutputStream(file);
    fileOutputStream.write(byteArrayOutputStream.toByteArray());
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
  return canWrite;
 }
 
 public boolean deleteTemporarySignature() {
  return false;
 }
 
 @Deprecated
 public boolean persistSignatureAtSDCard() {
  final boolean canWrite = Environment.getExternalStorageDirectory().canWrite();
  if (canWrite) {
   createDir();

Calendar date = null;
   ByteArrayOutputStream byteArrayOutputStream = null;
   FileOutputStream fileOutputStream = null;
   File file = null;
   try {
    byteArrayOutputStream = new ByteArrayOutputStream();
    mBitmap.compress(Bitmap.CompressFormat.PNG, 40, byteArrayOutputStream);

date = Calendar.getInstance();
    file = new File(Environment
      .getExternalStorageDirectory()
      .getAbsolutePath()
      .concat(File.separator)
      .concat(DIR_ROOT_NAME)
      .concat(File.separator)
      .concat(DIR_SIGNATURE_NAME)
      .concat(File.separator)
      .concat(date.get(Calendar.DAY_OF_MONTH) + "-"
        + date.get(Calendar.MONTH) + "-"
        + date.get(Calendar.YEAR) + "-"
        + date.get(Calendar.HOUR_OF_DAY) + "-"
        + date.get(Calendar.MINUTE) + "-"
        + date.get(Calendar.MILLISECOND))
      .concat(".png"));
    file.createNewFile();

fileOutputStream = new FileOutputStream(file);
    fileOutputStream.write(byteArrayOutputStream.toByteArray());
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
  return canWrite;
 }
 
 public boolean temporarySignature() {
  return Environment.getExternalStorageDirectory().canWrite();
 }
 
 public void setColor(final int mColor) {
  if (mPaint == null) {
   mPaint = createNewPaint(mPaintColor, mStrokeSize);
  }
  
  this.mPaintColor = mColor;
  mPaint.setColor(mColor);
 }
 
 public void setBoardColor(final int mColor) {
  if (mPaint == null) {
   mPaint = createNewPaint(mPaintColor, mStrokeSize);
  }
  
  this.mBoardColor = mColor;
  clearBoard();
 }
 
 public void setStrokeSize(final float strokeSize) {
  if (mPaint == null) {
   mPaint = createNewPaint(mPaintColor, mStrokeSize);
  }
  
  this.mStrokeSize = strokeSize;
  mPaint.setStrokeWidth(strokeSize);
 }
 
 public void setEraseMode(boolean eraseMode) {
  if (mPaint == null) {
   mPaint = createNewPaint(mPaintColor, mStrokeSize);
  }
  
  if(eraseMode) {
   mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
  } else {
   mPaint.setXfermode(null);
   mPaint.setColor(mPaintColor);
  }
 }
 
 public void setEmbossMode(final boolean embossMode) {
  if (mPaint == null) {
   mPaint = createNewPaint(mPaintColor, mStrokeSize);
  }
  
  if(embossMode) {
   if(mPaint.getMaskFilter() != mEmboss) {
    mPaint.setMaskFilter(mEmboss);
   }
  } else {
   mPaint.setMaskFilter(null);
  }
 }
 
 public Bitmap getSignature() {
  return mBitmap;
 }
 
 public void setFullName(final String name) {
  this.mFullName = name;
 }
 
 public boolean isSigned() {
  return mIsSigned;
 }
 
 public void disable() {
  mIsEnable = false;
  clearBoard();
 }
 
 public void enable() {
  mIsEnable = true;
  clearBoard();
 }
 
}

Note que o nosso DrawingBoard também nos dá a possibilidade de persistir a imagem de "assinatura" do usuário em seu cartão de memória SD ou na pasta cache do aplicativo. Para tanto, é necessário utilizar os métodos persistSignatureAtCache() ou persistSignatureAtSDCard() - lembre de colocar a permissão no AndroidManifest.xml para que o aplicativo possa escrever no SDCard.

Espero que ajude, abraço.

10 de abril de 2013

Para nunca mais esquecer [5] - Android

Mais uma leva de dicas legais para desenvolvedores Android. :) Modelo do aparelho: Versão do Android no aparelho: Nome do produtor do aparelho: Envio de SMS por Intent: Qual o versionName/versionCode descrito no AndroidManifest.xml: Espero que ajude! Att,

20 de março de 2013

[Fuctura] I Minicurso de Android

Bem, na última segunda-feira tive o prazer de ministrar um mini-curso na Fuctura Escola de Software Livre onde 'tentamos' desenvolver um simples app em 3 horas.
Claro que não conseguimos 'termina-lo', mas deu para todos verem como desenvolver para a plataforma Android é simples, basta você entender toda a complexidade da arquitetura.

Como muitos pediram, estou disponibilizando o projeto que fizemos na aula que está na url abaixo:
Espero que tenham gostado e amanhã tem mais um mini-curso lá na Fuctura, espero todos lá!
Att,

6 de março de 2013

Para nunca mais esquecer [4] - Android

1. Obter o atual código de área do aparelho:
OBS: Não esqueça da respectiva permissão em seu AndroidManifest.xml ou uma exceção SecurityException será lançada.

2. Como obter o IMEI do aparelho:
OBS: Não esqueça da respectiva permissão em seu AndroidManifest.xml ou uma exceção SecurityException será lançada.

3. Efetuar uma requisição HTTPS POST:
OBS: Não esqueça da respectiva permissão em seu AndroidManifest.xml ou uma exceção SecurityException será lançada. Perceba também que para que a UI do app não seja comprometida, você deve fazer essa requisição em uma AsyncTask ou Thread diferente da UI Thread.

4. Salvar conteúdo no SharedPreference:

5. Recuperar conteúdo no SharedPreference:

Esses são alguns trechos que acho importante não esquecer! :) Att,

5 de março de 2013

Signin with Google+ API - Android

Uma das apostas do Google neste semestre será a utilização da API do Google+ disponibilizada na API do Google Services. Antes de tudo, para utilizarmos a API do Google+, precisamos baixar em nosso SDK Manager o Google Play Services que nada mais é do que uma library contendo diversas API criadas pelo pessoal do Google. Depois de baixar, tudo que precisamos fazer é importa-lo para o nosso workspace do Eclipse (O projeto do Google Play Services estará na pasta do SDK do Android).

O que precisamos fazer agora? Cada usuário desenvolvedor Google possui um painel onde são listados os serviços disponíveis para aquela respectiva conta chamado de Google APIs Console. Ao entrar, tenha certeza de ativar a opção do Google+ API.
Depois disso, precisamos criar a sua autenticação OAuth 2.0 Client e selecionar que iremos utiliza-lo através da plataforma Android. Também necessitamos de um SHA-1 Fingerprint que é gerado através do command line:
Pronto, agora podemos partir para a doideira, haha! :)
Para o nosso layout, precisamos apenas de um botão que será o responsável por executar o signin no Google+. Não é segredo que através do nosso Button iremos captar o evento de click realizado pelo usuário.
Agora que temos nosso layout criado, precisamos inicializar em nossa Activity a classe PlusClient, disponibilizada na library do Google Play Services.
Basicamente utilizaremos a classe PlusClient para efetuar a comunicação entre nosso app com o Google+ API através de uma conexão que será estabelecida de modo assíncrono.

Também podemos efetuar essa inicialização utilizando o conceito de Ciclo de Vida de uma Activity.

onCreate: Inicializamos o objeto PlusClient através do padrão Builder;
onResume: Executamos a conexão através do método connect() contido no PlusClient;
onPause: Desconectamos através do método disconnect() contido no PlusClient.

Mas como dito anteriormente, neste exemplo iremos utilizar o evento de click para efetuar a conexão!

public class MainActivity extends Activity implements ConnectionCallbacks, OnConnectionFailedListener, OnClickListener {

// Intent Error Code
 private static final int INTENT_ERROR = 9000;

private PlusClient mPlusClient;
 private ConnectionResult mConnectionResult;

@Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

// Verificação de disponibilidade do Google+ no aparelho
  int errorCode = GooglePlusUtil.checkGooglePlusApp(this);
  if (errorCode != GooglePlusUtil.SUCCESS) {
   // O aparelho não possui o app do Google+
   GooglePlusUtil.getErrorDialog(errorCode, this, 0).show();
  }

// Todos os observers estão implementados pela Activity
  PlusClient.Builder builder = new PlusClient.Builder(this, this, this);

// O Scope LOGIN nos dá capacidade de obter informações da conta
  builder.setScopes(Scopes.PLUS_LOGIN);
  mPlusClient = builder.build();

findViewById(R.id.sign_in_button).setOnClickListener(this);
 }

@Override
 public void onClick(View view) {
  if (view.getId() == R.id.sign_in_button) {
   if (!mPlusClient.isConnected()) {
    if (mConnectionResult == null) {
     // Chamada para efetuar conexão
     mPlusClient.connect();
    } else {
     if (mConnectionResult.hasResolution()) {
      try {
       // Recupera as informações da conexão
       mConnectionResult.startResolutionForResult(this, INTENT_ERROR);
      } catch (SendIntentException e) {
       // Nova tentativa de conexão
       mConnectionResult = null;
       mPlusClient.connect();
      }
     }
    }
   } else {
    Toast.makeText(this, "Você já está connectado!",
      Toast.LENGTH_SHORT).show();
   }
  }
 }

@Override
 protected void onDestroy() {
  super.onDestroy();
  // Chamada para desconectar o PlusClient.
  mPlusClient.disconnect();
 }

@Override
 public void onConnected() {
  final String accountName = mPlusClient.getAccountName();
  Person me = mPlusClient.getCurrentPerson();
  String aboutMe = me != null ? me.getAboutMe() : "null";
  mPlusClient.loadMoments(new OnMomentsLoadedListener() {

@Override
   public void onMomentsLoaded(ConnectionResult status,
     MomentBuffer momentBuffer, String nextPageToken,
     String updated) {
    if (status.isSuccess()) {
     for (int i = 0;i < momentBuffer.getCount();i++) {
      Moment moment = momentBuffer.get(i);
      ItemScope item = moment.getResult();
      String description = item.getDescription();
      Log.d("Google+", "Descrição: " + description);
     }
    }
   }
  });
  Toast.makeText(this, accountName + ", sobre você: "
      + aboutMe, Toast.LENGTH_LONG).show();
 }

@Override
 public void onDisconnected() {
  Toast.makeText(this, "Desconectou do Google+!",
      Toast.LENGTH_LONG).show();
 }

@Override
 public void onConnectionFailed(ConnectionResult result) {
  if (result.hasResolution()) {
   try {
    // Recupera as informações da falha na conexão
    result.startResolutionForResult(this, INTENT_ERROR);
   } catch (SendIntentException e) {
    // Nova tentativa de conexão
    mPlusClient.connect();
   }
  }
 }

protected void onActivityResult(int requestCode, int responseCode,
   Intent intent) {
  if (requestCode == INTENT_ERROR
     && responseCode == RESULT_OK) {
   // Nova tentativa de conexão
   mConnectionResult = null;
   mPlusClient.connect();
  }
 }

Lembrando que devemos apenas utilizar o Google+ API a partir do Android 2.x, ou seja, precisamos verificar qual é a versão do S.O. em que o app está sendo rodado. Como podemos fazer isso? SIMPLES!
Espero que ajudem todos! Dúvidas é só entrar em contato, Abraço.

4 de fevereiro de 2013

Ferramentas ESSENCIAIS para desenvolvedores Android

Um dos maiores aprendizados que tive neste ano que passou foi conhecer algumas ferramentas úteis para desenvolvedores de aplicativos para a plataforma Google Android.

As vezes, a modelagem/teste de um aplicativo fica muito mais fácil depois de se utilizar essas ferramentas.

Abaixo irei falar sobre as seguintes ferramentas que venho utilizando em minha jornada como desenvolvedor Google Android e também recomendo para os designer's no qual trabalho em conjunto.

Ferramentas:

ZipAlign (Android Developer)
Monkey (Android Developer)

Cada ferramenta tem sua respectiva funcionalidade e importancia no processo de desenvolvimento do conceito do app.

Para exemplificar melhor, irei falar um pouco sobre cada ferramenta e como utiliza-la.

ZipAlign:

Segundo o Android Developers, o Zip Align é uma poderosa ferramenta responsável por otimizar os resources do apk da sua aplicação. Ele tem o preceito que todos os arquivos não comprimidos começam com um certo valor para alinhamento. Utilizando esta ferramenta teremos o benefício de ter uma redução considerável do processamento do nosso aplicativo com a RAM durante sua execução.

Perceba que devemos apenas utilizar essa ferramenta depois que você exportar seu .apk assinado (i.e. pronto para ser publicado), caso contrário, não terá efeito algum pois todo o processo de alinhamento dos arquivos será desfeito.

Como utilizar

Abra o seu prompt e navegue até a pasta do SDK do Android e dentro da pasta "tools" utilize o segundo comando:

Note que temos uma área para as FLAGS que são -f, -v e -c onde -f é reponsável por sobreescrever em um arquivo .zip do apk, -v é responsável por dar um verbose log do processo de alinhamento e o -c é para confirmar o alinhamento no respectivo arquivo (e.g. recomendo utilizar o [-f] [-v] liberando outro apk alinhado).

Monkey:

Essa é uma ferramenta utilizada tanto nos dispositivos móveis quanto no emulador para simular uma lista de pseudo-eventos randômicos a procura de bug's em seu aplicativo. Ele é utilizado para ambiente de "stress-test" com eventos randômicos, podendo configurar para que não sejam repetidos em testes distintos.

O site do Android Developers diz que podemos classificar o monkey com as respectivas categorias primárias:

Manipulação de configuração para opcões básicas, como descricão de números e textos;
Exceções de operações, como a restrição para pacotes únicos de aplicações;
Frequencias e eventos;
Opções de debug;

O mais legal dessa ferramenta é que se algum problema é encontrado, como o travamento da aplicação, o monkey avisa ao desenvolvedor para o teste com seu respectivo erro em log.

Como utilizar

Tudo que precisamos fazer é navegar até a pasta do SDK do ANDROID, e entrar na pasta "plataform-tools", nele está contido o programa do adb.

Feito isso, apenas necessitamos utilizar a seguinte linha de comando:

Como qualquer ferramenta, ele utiliza de opções que são -p e -v, onde -p refere-se ao nome do pacote da sua aplicação que está rodando, e -v é o valor do nível máximo de eventos que ele irá executar de forma randômica iniciando no nível default 0.

Acho as duas ferramentas de extrema usabilidade para os desenvolvedores Android, uma vez que por falta de descuido perdemos a atenção para pequenos problemas, na qual essas ferramentas podem nos auxiliar e MUITO!

Espero que utilizem algum dia,

Abraço.