Galeria de mídia do Android

Olá povo,

Neste post vou mostrar como tirar uma foto com a aplicação de câmera, salvar a imagem em um diretório temporário e em seguida adiciona-la à galeria de mídia do aparelho. E por último, vou mostrar como carregar uma imagem da galeria.
Vamos iniciar mostrando como chamar a aplicação de câmera.

public void tirarFotoClick(View v) {
  String nomeFoto = DateFormat.format(
    "yyyy-MM-dd_hhmmss", new Date()).toString();

  caminhoFoto = new File(
    Environment.getExternalStoragePublicDirectory(
      Environment.DIRECTORY_PICTURES),
    nomeFoto);

  Intent it = new Intent(
    MediaStore.ACTION_IMAGE_CAPTURE);  
  it.putExtra(MediaStore.EXTRA_OUTPUT, 
    Uri.fromFile(caminhoFoto));
  startActivityForResult(it, 0);
}

A aplicação de câmera é chamada através da ação ACTION_IMAGE_CAPTURE passado no construtor da Intent. Um detalhe interessante aqui é o parâmetro EXTRA_OUTPUT, ele serve para indicar um caminho para a foto ser salva. Sem ele, a imagem será salva com tamanho e qualidade inferior a que a câmera realmente tirou.

caminhoFoto é um atributo do tipo File.
A chamada do método startActivityForResult indica que queremos tratar o resultado da activity que estamos chamando. Esse tratamento é feito no método onActivityResult.

protected void onActivityResult(
  int requestCode, int resultCode, Intent data) {
  super.onActivityResult(
    requestCode, resultCode, data);

  if (resultCode == RESULT_OK && requestCode == 0) {
    ImageView img = (ImageView)
      findViewById(R.id.imageView1);
   
    // Obtém o tamanho da ImageView
    int targetW = img.getWidth();
    int targetH = img.getHeight();
    
    // Obtém a largura e altura da foto
    BitmapFactory.Options bmOptions =
      new BitmapFactory.Options();
    bmOptions.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(
      caminhoFoto.getAbsolutePath(), bmOptions);

    int photoW = bmOptions.outWidth;
    int photoH = bmOptions.outHeight;
    
    // Determina o fator de redimensionamento
    int scaleFactor = Math.min(
      photoW/targetW, photoH/targetH);
    
    // Decodifica o arquivo de imagem em 
    // um Bitmap que preencherá a ImageView
    bmOptions.inJustDecodeBounds = false;
    bmOptions.inSampleSize = scaleFactor;
    bmOptions.inPurgeable = true;
    
    Bitmap bitmap = BitmapFactory.decodeFile(
      caminhoFoto.getAbsolutePath(), bmOptions);
    img.setImageBitmap(bitmap);
  }
}

Quando chamamos a câmera, no startActivityForResult, passamos o valor 1 como segundo parâmetro, esse valor representa o código da requisição (requestCode). Esse valor é retornado no método onActivityResult para saber se o resultado que estamos tratando é daquela requisição. No if que fizemos, além do requestCode, checamos o resultCode. O resultCode descreve o resultado da operação, que neste caso é tirar a foto. Se o resultado for RESULT_OK, é porque uma foto foi tirada.
[EDITADO em 12/05/2013] 
A foto que é tirada com as câmeras atuais requer muita memória para ser alocada. Sendo assim, verificamos o tamanho da ImageView para carregar a imagem deste tamanho.
O atributo caminhoFoto que foi atribuído no método tirarFotoClick é utilizado para carregar a imagem e atribuir em um ImageView. Agora vamos ver como salvar essa imagem na galeria de mídia.

public void salvarFotoClick(View v) {
  if (caminhoFoto != null && caminhoFoto.exists()) {
    MediaStore.Images.Media.insertImage(
      getContentResolver(), 
      caminhoFoto.getAbsolutePath(), 
      caminhoFoto.getName(), "");

    Toast.makeText(this, 
      "Imagem adicionada a galeria.",
      Toast.LENGTH_SHORT).show();
  }
}

A classe MediaStore.Images.Media tem um "método mágico" que permite que possamos inserir um Bitmap na galeria. Essa operação é feita graças a um ContentProvider disponibilizado pela aplicação de galeria. O próximo passo será como abrir a galeria de mídia para selecionarmos uma imagem.

public void galleryButtonClick(View v) {

  Intent intent = new Intent(
    Intent.ACTION_GET_CONTENT);
  intent.setType("image/*");
  startActivityForResult(intent, 2);
}

O código acima abrirá a aplicação de galeria. Notem que agora passamos o valor 2 para o startActivityForResult. Da mesma forma que fizemos para tirar foto, usaremos o método onActivityResult para tratar a imagem selecionada.

// adicione esse código no onActivityResult
if (resultCode == RESULT_OK && requestCode == 2) {
  Uri selectedImage = data.getData();
  String[] filePathColumn = { 
    MediaStore.Images.Media.DATA };

  Cursor cursor = getContentResolver().query(
    selectedImage, filePathColumn, null, null, null);
  cursor.moveToFirst();

  int columnIndex = cursor.getColumnIndex(
    filePathColumn[0]);
  String filePath = cursor.getString(columnIndex); 
  cursor.close();

  Bitmap yourSelectedImage = 
    BitmapFactory.decodeFile(filePath);

  imageView1.setImageBitmap(yourSelectedImage);
}

A galeria retorna o endereço da imagem selecionada através de um objeto Uri que é obtido em data.getData(). Com essa informação podemos acessar o ContentProvider da galeria para obter o caminho da imagem. Com esse caminho passamos para a classe BitmapFactory que retornará um objeto Bitmap para preencher a imageView.

Qualquer dúvida, deixem seus comentários.

4br4ç05,
nglauber

Capturando Eventos do Sistema com Android

Olá pessoal,

A facilidade da plataforma Android me encanta muito, nunca programei com nada tão bacana. Por isso, vou falar um pouquinho sobre como capturar eventos do sistema utilizando BroadcastReceivers. A classe android.content.BroadcastReceiver é utilizada para receber eventos de sistema (ou nossos próprios) e tratá-los em background. Ela não possui interface gráfica associada e possui um tempo de vida muito curto (cerca de 10 segundo), então se quisermos mostrar algum feedback pro usuário devemos delegar isso pra uma Activity.

Para implementarmos um BroadcastReceiver basta criar uma classe que a estenda, implementar o método onReceive(Context, Intent) e registrá-la com a tag <receiver> AndroidManifest.xml ou no código através do método context.registerReceiver(receiver, filtro). Para desativar podemos utilizar uma chamada para context.unregisterReceiver(receiver). Se quisermos enviar nossa própria mensagem de broadcast, podemos chamar o método sendBroadcast(Intent).

No nosso exemplo, capturaremos as mudanças de estado do telefone. Ou seja, quando for feita, recebida ou terminada uma ligação, nosso BroadcastReceiver entrará em ação.

Primeiro, crie a classe conforme abaixo:

public class InterceptCall extends BroadcastReceiver {

 public void onReceive(Context ctx, Intent it) {
   String estado = it.getStringExtra("state");
   String num = it.getStringExtra("incoming_number");
   String msg = null;
     
   if (estado.equals("RINGING")){
     msg = "O número "+ num +" está chamando.";
         
   } else if (estado.equals("OFFHOOK")){
     msg = "Em ligação.";
       
   } else if (estado.equals("IDLE")){
     if (num != null){
       msg = "Chamada não atendida de "+ num;
     } else {
       msg = "Chamada atendida, foi terminada.";
     }
   }
     
   Toast.makeText(ctx, msg, Toast.LENGTH_LONG).show();
 }
}

Com esse receiver, capturamos a mudança de estado do telefone em ligações. A Intent que o dispara tem dois extras: state e incoming_number. O primeiro indica o estado do telefone e o segundo o número do telefone de quem está ligando. O telefone vai para o estado RINGING (tocando) quando o telefone está recebendo a ligação. Ao atender ou fazer uma chamada o telefone vai para o estado OFFHOOK (fora do gancho). E por último, ao terminar uma ligação o telefone volta para o seu estado padrão, IDLE (parado).

Notem que nem OFFHOOK e nem IDLE quando não se atende a ligação, contam com o número do telefone que o chamou.

Para finalizar, basta registrarmos o nosso BroadcastReceiver no AndroidManifest.xml, dentro da tag <application>, conforme abaixo:

<receiver android:name="InterceptCall">
<intent-filter>
  <action
  android:name="android.intent.action.PHONE_STATE"/>
  <category
  android:name="android.intent.category.DEFAULT"/>
</intent-filter>
</receiver>

Também adicione a permissão para ler o estado da ligação no AndroidManifest.xml FORA DA TAG .

<uses-permission 
  android:name="android.permission.READ_PHONE_STATE"/>

Pronto! Agora é só brincar com os demais eventos do sistema.

4br4ç05,
nglauber