AguasNegras

El siguiente paso en el desarrollo resulta bastante obvio, ligar el CrankPlayer con el MediaService, o lo que es lo mismo, hacer un bind. Para no perderme, he hecho un pequeño diagrama de interacción entre CrankPlayer y MediaService.

En él se aprecia que aparte de los métodos de negocio necesarios (denotados por una línea discontínua), todavía me faltan por implementar dos métodos del ciclo de vida: el bind y el unbind, que son precisamente los que me permiten establecer una comunicación bidireccional con el MediaService para indicar acciones y realizar y obtener resultados.

Bind y Unbind de MediaService

La definición más pura de Service dice que este es un componente aislado que ejecuta una computación. Esto esta muy bien pero en realidad, si no te puedes comunicar con él, su uso es bastante limitado, para eso existen los bound services. Un bound service se puede combinar con un servicio “normal” (y de hecho es lo que hago) y además ofrece dos métodos adicionales, el bind y el unbind. Lo importante es que en el bind devuelve una interfaz que permite interactuar con él.

Primero entonces creo la clase que hará de fachada del servicio que extiende de Binder:

public class MediaServiceBinder extends Binder {
 
  private final MediaService mediaService;
 
  public MediaServiceBinder(MediaService mediaService) {
    this.mediaService = mediaService;
  }
}

A continuación, declaro una variable de esta clase en el servicio:

private final IBinder mediaServiceBinder = new MediaServiceBinder(this);

Y la devuelve en el método onBind:

@Override
public IBinder onBind(Intent bindingIntent) {
  return this.mediaServiceBinder;
}
 
@Override
public boolean onUnbind(Intent intent) {
  // Nothing to do here
  return super.onUnbind(intent);
}

El onUnbind, de momento he considerado que no requiere ninguna acción en especial.

Vale, con esto el servicio ya devuelve su fachada.

Ahora viene la parte de CrankPlayer, siguiendo el diagrama de interacción, voy a hacer el bind en el onStart:

@Override
public void onStart() {
  super.onStart();
  Intent intent = new Intent(this, MediaService.class);
  bindService(intent, mediaServiceConnection, Context.BIND_AUTO_CREATE);
}

Pero bindService no devuelve el MediaServiceBinder inmediatamente, sino que es devuelto asincronamente, para eso se pasa el objeto mediaServiceConnection, que es una implementación de ServiceConnection, además creo una instancia propia de MediaServiceBinder:

private MediaServiceBinder mediaServiceBinder = null;
 
private ServiceConnection mediaServiceConnection = new ServiceConnection() {
  public void onServiceConnected(ComponentName className,
    IBinder service) {
    mediaServiceBinder = (MediaServiceBinder) service;
  }
 
  public void onServiceDisconnected(ComponentName arg0) {
    mediaServiceBinder = null;
  }
};

Para acabar con esta parte, en el onPause de CrankPlayer, hago el unBind:

@Override
public void onPause() {
  unbindService(mediaServiceConnection);
  super.onPause();
}

Con ésto ya estan implementados los servicios del ciclo de vida, y ahora ya solo me queda por implementar la lógica de negocio.

TODO

1. Añadir el MediaPlayer al MediaThread
2. Definir fachada de MediaService (o lógica de negocio) en MediaServiceBinder.
3. Implementar la lógica en MediaService y MediaThread.

Código

En GitHub (para variar):

Repositorio de CrankPlayer en GitHub

Uno de mis requisitos (de hecho, el fundamental), es poder reproducir a partir de archivos sueltos o directorios.

Por tanto, necesitaré un explorador de archivos, aunque sea muy básico, que permita ver los archivos en la memoria del dispositivo y añadirlos a una lista de reproducción. Gráficamente, la interacción entre las actividades sería así. En general la devolución del parámetro no tendrá mayor problema, ya que se puede hacer a través del intent de vuelta.

Para crear el explorador de archivos voy a seguir este tutorial, por supuesto añadiendo cosas de mi cosecha según me vaya pareciendo.

Creación de CrankExplorer

En primer lugar creo la activity tal cual heredando de CrankActivity y le añado la implementación por defecto de todos los métodos del ciclo de vida.

Ahora la declaro en el AndroidManifest:

<activity android:name=".CrankExplorer" android:label="@string/explorer_name"/>

Para arrancarla, creo un botón en CrankActivity:

<Button
android:id="@+id/buttonOpenExplorer"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/open_explorer"
android:onClick="openCrankExplorer" />

Y el listener:

public void openCrankExplorer(View v) {
  Intent openCrankExplorer = new Intent(this, CrankExplorer.class);
  startActivityForResult(openCrankExplorer, REQUEST_CODE);
}

Con esto ya puedo llamar a CrankExplorer desde CrankPlayer.

Ahora toca implementar CrankExplorer, en general la implementación seguirá estas líneas:

1. Se mostrarán todos los archivos y directorios que se puedan leer.
2. Si se hace click en un directorio se abrirá.
3. Si se hace click en un archivo, se abrirá un diálogo de confirmación para añadirlo a la lista de reproducción.
4. Si se deja presionado un directorio se abrirá un menú contextual para añadir todo su contenido a la lista de reproducción.

Al lío, siguiendo lo que comentan, hago un layout para los archivos, le voy a llamar file_row.xml y a continuación creo el layout de CrankExplorer, crankexplorer.xml. No tiene mucha historia ya que es una lista y punto.

En cuanto a la actividad, lo primero que hago es filtrar los archivos mediante un FilenameFilter, para que solo muestre aquellos directorios y archivos que sean legibles y si es un archivo, que además termine en mp3 u ogg.

Añado un onListItemClick y si es un directorio se invocará a getDir sobre él, mientras que si es un archivo, se mostrará un diálogo que permitirá dos acciones:

1. Añadir el archivo a la lista de reproducción.
2. Cancelar

Por último, para devolver la canción a CrankPlayer, creo un método finish().

Para ir acabando, falta el menú contextual que me permita seleccionar un directorio para añadir (junto con todos los archivos contenidos en él y sus subdirectorios).
Primero creo el layout del menu y lo llamo crankexplorer_context.xml a continuación en el onCreate, registro la lista para el menú contextual:

registerForContextMenu(getListView());

Después tengo que crear dos métodos del ciclo de vida, el primero, la creación del menú:

@Override
public void onCreateContextMenu(ContextMenu menu, View v,
  ContextMenuInfo menuInfo) {
  super.onCreateContextMenu(menu, v, menuInfo);
  menu.setHeaderTitle(R.string.directory_contextual_title);
  MenuInflater inflater = getMenuInflater();
  inflater.inflate(R.menu.crankexplorer_context, menu);
}

Y el segundo, la acción a ejecutar cuando se selecciona:

@Override
public boolean onContextItemSelected(MenuItem item) {
  switch (item.getItemId()) {
    case R.id.addDirectoryItem:
      AdapterContextMenuInfo info = (AdapterContextMenuInfo) item
      .getMenuInfo();
      this.selected = new File(this.path.get((int) info.id));
      if (this.selected.isDirectory()) {
        finish();
      }
      return true;
   default:
     return super.onContextItemSelected(item);
  }
}

Para acabar, implemento el método finish() para devolver bien la canción seleccionada, bien todas las canciones:

@Override
public void finish() {
  Intent data = new Intent();
  if (this.selected != null) {
    if (this.selected.isFile()) {
      data.putExtra("selectedFile", this.selected);
    } else if (this.selected.isDirectory()) {
      List<File> filesInDirectory = this.explodeDir(this.selected);
      data.putExtra("selectedFiles",
        (ArrayList<File>) filesInDirectory);
    }
  }
  setResult(RESULT_OK, data);
  super.finish();
}

Y en CrankPlayer creo un onActivityResult que procese la vuelta desde CrankExplorer:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  if (data.hasExtra("selectedFile")) {
    this.playlist.add((File) data.getExtras().get("selectedFile"));
    this.renderPlaylist();
  } else if (data.hasExtra("selectedFiles")) {
    List<File> fileList = (List<File>) data.getExtras().get(
      "selectedFiles");
    this.playlist.addAll(fileList);
    this.renderPlaylist();
  }
}

TODO

Pues ya solo queda:

1. Hacer el bind del service en CrankPlayer
2. Reproducir con un MediaPlayer en el thread.

Código

Sigue en GitHub

Repositorio de CrankPlayer en GitHub

Última parte del tutorial que sigo para el CrankPlay, MusicDroid, ahora voy a añadir los controles básicos de reproducción. Esta parte se me antoja que no me será de mucha utilidad, ya que es bastante dependiente del diseño de la aplicación, pero que demonios…

Controles de Reproducción

El objetivo de esta parte es añadir los controles de reproducción a la aplicación. Estos se mostrarán como una capa semitransparente sobre la lista de canciones.

Me cojo el xml que viene en la página y lo pego. Como ya me ha pasado antes, justo delante del “id” hay que añadir el namespace: “android:”. Además quito unos puntos y comas y listo. Ahora a ver si explico un poco como es el layout.

En primer lugar, si se mira el songlist.xml, lo primero que se aprecia es que usa un LinearLayout. Un LinearLayout posiciona los elementos hijos en forma de columna (o fila). Y punto. En songlist.xml posiciona los elementos en columna porque el atributo “android:orientation” esta establecido al valor “vertical”.

Esto tiene sentido porque se quiere representar una lista de valores en columna, pero sin embargo, los controles de reproducción se quieren situar los unos en función de los otros… Y esto es lo que hace un RelativeLayout, permite posicionar sus hijos relativamente entre ellos.

Lo que se hace en controls.xml es utilizar un RelativeLayout para que ocupe toda la pantalla y en su interior otro en el centro (controlado por “android:layout_centerVertical” y “android:layout_centerHorizontal”) que tendrá un área total de 170dip x 170dip. ¿Qué es un dip? Pues es un “Density Independent Pixel”, para hacer una idea, 1 dip = 1 pixel en una pantalla de 160 dpi. Si la pantalla tiene mayor resolución, se escala automáticamente. Vamos, que es una medida independiente del tamaño de la pantalla.

Por último, para situar los ImageView se utiliza “android:layout_alignParentTop, android:layout_centerHorizontal”, etc…

Añadiendo una Animación

Cosa que yo no sabía, en android se pueden declarar animaciones con xml. El tutorial propone añadir una que haga que un botón pulsado se haga más grande y otra vez más pequeño. La verdad que el xml es bastante entendible, escala por 1.5 la imagen, alcanzando este tamaño en 600 msg.

Para invocar la animación, pues por ejemplo en el OnKeyUp de los controles se invoca al método startAnimation de la vista correspondiente pasándole como parámetro la animación definida… ningún misterio.

Creando un Tema

Además de la animación, en el tutorial la actividad con los controles de reproducción es transparente y se superpone a la actividad con la lista de mp3, haciendo por tanto posible ver la canción que se esta reproducción. Para conseguir este efecto hay que diseñar un tema (una apariencia visual) para esta actividad.

Lo más sencillo, y lo que hacen en el tutorial es crear un tema que herede del tema por defecto de android y decirle que el color de fondo de la actividad sea transparente y que no tenga título. Todo esto en un archivo llamado styles.xml en “res/values”. Para crear el archivo, he tenido que modificar el atributo parent y establecerlo como “parent=”android:Theme”", ya que si no, no lo reconoce.

Una vez hecho esto avisa del epígrafe de “@drawable/transparent_background”. Esto es debido… a que no existe, jeje.  Para crearlo, en “res/values” hay que crear un archivo llamado colors.xml y pegarle la definición de este transparent background.

Por último, se define la actividad en el AndroidManifest.xml aplicándole el tema.

Creando la Actividad

Pues una vez declarada, toca crearla. El código que viene en la página es bastante sencillo, se limita a gestionar la conexión con el servicio y a ejecutar la animación sobre el botón pulsado.

Como en el artículo anterior, tengo que tocar el método bind y eliminar el parámetro null que se le pasa ya que esa signatura esta deprecada y en el OnKeyUp tengo que capturar también una RemoteException. Con ésto ya compila.

Pero antes, hay que cambiar la actividad CrankPlay para que cuando se pulse en un elemento, invoque la nueva actividad y entonces empiece a reproducir. Lo único que el tutorial esta tan pasao de rosca que el método startSubActivity ya no existe, así que haré una llamada a startActivityForResult.

Y con ésto ya lanzo y andando, todo perfecto

Conclusiones

Bueno, en primer lugar, el autor prometía una cuarta parte del tutorial… pero va a ser que nunca se llevó a cabo xD De entrada tal y como esta a día de hoy hay 4 grandes problemas:

1. Los controles no son táctiles!! Eso es, se utiliza OnKeyUp, asi que uno se puede hartar de pulsar encima que nada…
2. Una vez parada una canción… no hay forma de reanudarla!
3. De la misma manera, tampoco hay forma de salir de la actividad de control y volver a la lista de canciones.
4. Por último, falta una barra de indicación de por donde va la canción o un minutero u algo, ah, y leer el id3 tag.

Bueno, pues después de un tiempo dedicado a un proyecto que tengo por ahí y que anda un poco empantanado, voy a empezar a hacer algo que llevo tiempo queriendo hacer. Un reproductor de mp3 para mi móvil.

Voy a empezar haciendo una pequeña elicitación de requisitos “grosso modo” para tenerlo como guía de aquí en adelante.

Requisitos

El reproductor tendrá las siguientes funcionalidades:

1. Contará con una lista de reproducción en la que se almacenarán las canciones a reproducir en orden.
2. Leerá las canciones de directorios en el almacenamiento del móvil, pudiendo en todo caso seleccionar una carpeta con lo cual se incluirían todos los mp3 en ella y sus subcarpetas en la lista de reproducción.
3. Contará con los controles básicos en un reproductor musical: Play, Stop, Pause, Next, Back, Volumen.

Como requisitos no funcionales:

1. Deberá consumir los recursos mínimos posibles.

Enfoque del Desarrollo

Pues para desarrollar, voy a empezar basándome en el tutorial MusicDroid de HelloAndroid. Este tutorial tiene ya bastantes años, así que iré haciendo un repaso de las APIs involucradas, actualizándolas según sea necesario.

Paso 1 – Crear el Proyecto

El primer paso es sencillo, creo el proyecto, inicializo git, creo repositorio en GitHub y lo subo, para más detalles, Tutorial de Git y GitHub.

Resultado, ya esta el proyecto en GitHub:

Repositorio de CrankPlay en GitHub

Ahora toca empezar con el tutorial de MusicDroid.

Paso 2 – Lista de canciones

El primer paso del tutorial es simplemente mostrar una lista de todos los archivos .mp3 que hay en la tarjeta sd.

Lo primero es el layout, el songlist.xml. Lo he modificado un poco de la siguiente manera:

1. He sacado la cadena de texto “No songs found” al strings.xml.
2. He cambiado el layout_weight, lo he quitado porque daba un warning en combinación con el layout_width.

Ahora, se hace el layout correspondiente a cada canción, song_item.xml. Es copiar y pegar y solo modifico el id, lo cambio por @+id/song_title.

Paso 3 – Actividad CrankPlay

Lo primero que hago en la Activity es hacer que extienda de ListActivity para poder gestionar nativamente el layout ListView. A continuación copio y pego las variables locales:

1. MEDIA_PATH: directorio en el que estan los mp3 (la tarjeta SD por defecto).
2. songs: lista de canciones en MEDIA_PATH.
3. mp: instancia de MediaPlayer que reproducirá las canciones.
4. currentPosition: posición de la canción que se esta reproduciendo.

En cuanto al OnCreate, sin misterios, se encarga de arrancar la aplicación y actualizar la lista de canciones.

En cuanto el updateSongList se encarga de cargar el directorio especificado en MEDIA_PATH y buscar en él todos los archivos terminados en .mp3 con la ayuda de la clase Mp3Filter.

Siguiente paso del tutorial, reproducir una canción cuando se hace click en ella. Para ello se usa un OnListItemClick que únicamente se encarga de llamar al método playSong, pasándole el nombre del archivo de la canción.

PlaySong se limita a usar el objeto mp para reproducir la canción. Primero se hace un reset con lo cual se pausa cualquier canción que se este reproduciendo y se carga la canción nueva. Se crea una clase interna anónima para implementar OnCompletionListener, que se limita a invocar al método nextSong para reproducir la siguiente canción (de haberla).

Y por último nextSong, sencillamente comprueba que no sea la última canción y si no lo es, incrementa currentPosition y llama a playSong.

Listo.

Paso 4 – Probar la Aplicación

Si ejecuto la aplicación directamente (Click con el botón derecho en el proyecto Run as > Android Application), se muestra el mensaje definido para el caso de que no haya canciones “No songs found”, y es correcto, hay que subir mp3s a la tarjeta SD.

Este apartado del tutorial ya esta un poco desfasado, los emuladores ya se pueden crear con el AVD Manager de Eclipse con la tarjeta SD ya creada, con lo cual basta con enviar el mp3 al dispositivo usando el adb en la línea de comandos. El primer paso es tener arrancado el emulador.

El segundo enviar el mp3 de prueba:

~/Android/android-sdks/platform-tools$ ./adb push ~/Música/Noel\ Gallagher\'s\ High\ Flying\ Birds\ -\ Noel\ Gallagher\'s\ High\ Flying\ Birds\ \(Deluxe\ Version\)\ \[theLEAK\]/01.\ Everybody\'s\ On\ The\ Run.mp3 /sdcard/Prueba.mp3

Y listo, ya sale andando y tengo Prueba.mp3 en la lista de canciones.

Ahora bien, si le doy a reproducir no se escucha nada, y en el LogCat se puede ver un Warning: “obtainBuffer timed out (is the CPU pegged?)”. Por lo visto este fallo lo produce el tener habilitados los snapshots en el emulador, así que nada, lo deshabilito y reinicio.

Listo, ya reproduce el mp3, así que ahí lo dejo, mañana más y mejor.