Objectes multimèdia

Un dels accessoris o objectes multimèdia més importants als dispositius mòbils és la càmera fotogràfica. Més enllà de fer fotos amb les aplicacions estàndard, pot ser molt interessant que les vostres aplicacions permetin fer fotos directament i fer-les servir, com per exemple per fer fotos alhora que enregistreu una ruta amb GPS, o per fer un receptari de cuina amb la recepta i la foto del plat, o qualsevol altra aplicació que pugueu pensar.

Hi ha dos procediments per utilitzar la càmera a les nostres aplicacions: engegar l’aplicació estàndard de la càmera o accedir directament al dispositiu.

La manera més senzilla de fer una foto des d’una aplicació Android és engegant l’aplicació de càmera de fotos que tingui instal·lada el dispositiu. Lògicament, en contrapartida, la vostra aplicació tindrà menys control sobre el procés i el resultat de l’operació, però en molts casos només us caldrà fer una foto i emmagatzemar-la.

Abans de continuar, tingueu present que en general les fotos i d’altres captures s’emmagatzemen a la memòria externa (generalment, la targeta SD) del dispositiu. De fet, al principi l’aplicació estàndard per fer servir la càmera de fotos no funcionava si no hi havia una targeta SD al dispositiu. Per comprovar que el vostre emulador tingui configurada una targeta SD, heu d’obrir Tools/Android/AVD Manager, clicar a la icona d’edició i comprovar que tingui algun valor al camp SD Card (heu de mostrar les opcions avançades), com per exemple 200 (que són megabytes de capacitat de la targeta virtual), com es veu a la figura.

El layout per a aquesta aplicació és molt senzill: només es necessita un botó per indicar que es vol fer la foto i un ImageView per visualitzar la foto que s’ha fet. Tot seguit podeu veure el contingut del layout, en el qual l’única propietat destacable és la propietat onClick del botó que té de valor fesFoto, que serà el mètode responsable d’engegar l’aplicació de la càmera:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:gravity="bottom"
    android:orientation="vertical" >
 
    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="5"
        android:src="@mipmap/ic_launcher" />
 
    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="fesFoto"
        android:text="Foto" />
 
</LinearLayout>

Per iniciar una altra aplicació a Android cal crear un Intent i començar una nova activitat amb startActivityForResult(), per tal que puguem recollir el resultat de l’activitat mitjançant el mètode onActivityResult(). Per saber quina és l’activitat que ha retornat el resultat cal assignar-li un número qualsevol que la identifiqui, que en el codi següent hem associat a la variable APP_CAMERA, creada amb la finalitat d’emagatzemar-lo:

    // Número que identifica l'activitat de l'aplicació de fotos
    private static final int APP_CAMERA = 0;
 
    // Identificador de la imatge que crearà l'aplicació de fotos
    private Uri identificadorImatge;
 
    public void fesFoto(View view) {
        // Es crea l'intent per l'aplicació de fotos
        Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
        // Es crea un nou fitxer a l'emmagatzematge extern i se li passa a l'intent
        File foto = new File(Environment.getExternalStorageDirectory(), "Foto.jpg");
        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(foto));
        // Es desa l'identificador de la imatge per recuperar-la quan estigui feta
        identificadorImatge = Uri.fromFile(foto);
        // S'engega l'activitat
        startActivityForResult(intent, APP_CAMERA);
    }

Abans d’iniciar l’aplicació estàndard de captura d’imatges es crea un nou fitxer a l’emmagatzemament extern (típicament, la targeta de memòria SD) i se’l passa a l’intent per tal que sàpiga on ha de desar la imatge que prengui. Finalment, s’executa l’activitat, que iniciarà l’aplicació de càmera fotogràfica per defecte (definida per l’usuari de cada dispositiu).

El segon pas, un cop feta la foto, és recollir el resultat de l’activitat que heu iniciat. En aquest cas només es vol mostrar la imatge que s’ha fet, però es podrien dur a terme altres operacions. També es mostrarà un Toast amb el nom amb el qual s’ha desat la imatge, si és el cas.

Totes aquestes operacions es porten a terme dins del mètode onActivityResult(), que s’executa cada cop que finalitza alguna activitat iniciada per la vostra aplicació. Com que una aplicació pot executar moltes activitats, cal fer servir un codi per distingir-les; en aquest cas és el paràmetre requestCode que coincideix amb el valor APP_CAMERA que hem passat a l’activitat en engegar-la. Distingir quina activitat ha finalitzat és l’objectiu del switch que veureu al codi d’exemple.

Tanmateix, l’activitat pot haver funcionat bé o pot haver fallat per diferents causes; per aquest motiu hi ha l’if, que comprova que el resultat (paràmetre resultCode) sigui RESULT_OK. L’altre valor possible per al resultCode d’una activitat és RESULT_CANCELED quan l’aplicació falla però tenim l’opció de definir altres codis personalitzats.

Un cop comprovat això, el codi accedeix a la imatge mitjançant el ContentResolver, que dóna accés als continguts del dispositiu, en aquest cas la foto que ha fet la càmera. Com que la càrrega de la imatge pot fallar, s’ha de fer dins d’un try… catch per tal de tractar les possibles excepcions. A més de la imatge, es mostra un toast amb el nom del fitxer on s’ha guardat la imatge o bé un missatge d’error si la càrrega falla.

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        // Primer cridem al mètode d'Activity perquè faci la seva tasca
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case APP_CAMERA:
                if (resultCode == Activity.RESULT_OK) {
                    /* El ContentResolver dóna accés als continguts
                       (la imatge emmagatzemada en aquest cas)*/
                    ContentResolver contRes = getContentResolver();
                    // Cal indicar que el contingut del fitxer ha canviat
                    contRes.notifyChange(identificadorImatge, null);
                    /* Accedeix a l'ImageView i hi carrega la foto que ha fet la
                       càmera */
                    ImageView imageView = (ImageView) findViewById(R.id.imageView1);
                    Bitmap bitmap;
                    /* Com que la càrrega de la imatge pot fallar, cal tractar
                       les possibles excepcions*/
                    try {
 
                        bitmap = android.provider.MediaStore.Images.Media
                                .getBitmap(contRes, identificadorImatge);
 
                        /* Reduïm la imatge per no tenir problemes de visualització.
                           Calculem l'alçada per mantenir la proporció amb una amplada de 1080 píxels*/
                        int alt = (int) (bitmap.getHeight() * 1080 / bitmap.getWidth());
                        Bitmap reduit = Bitmap.createScaledBitmap(bitmap, 1080, alt, true);
 
                        imageView.setImageBitmap(reduit);
 
                    } catch (Exception e) {
                        Toast.makeText(this, "No es pot carregar la imatge" +
                                        identificadorImatge.toString(),
                                Toast.LENGTH_SHORT).show();
                    }
                }
        }
    }
}

Ara ja podeu executar l’aplicació i veure el seu funcionament: en clicar el botó s’engega l’aplicació per defecte per fer fotos, i aleshores la foto s’emmagatzema al dispositiu. A la figura teniu una captura de l’aplicació quan es mostra la foto realitzada.

De vegades les aplicacions requereixen un control més estret sobre el procés de captura d’imatges fotogràfiques, com per exemple obtenir-ne una previsualització en la mateixa aplicació, emmagatzemar les fotos directament, o fins i tot convertir-les a un determinat format. Per tal de veure com es pot dur a terme tot això, la següent aplicació accedirà directament a la càmera, integrarà la previsualització al seu layout principal i convertirà els píxels capturats al format desitjat per l’usuari, ja sigui JPEG o PNG, abans de desar la imatge.

Com que aquesta aplicació fa servir directament la càmera, que és un dispositiu important pel que fa a la privacitat de l’usuari (ningú no vol que una aplicació faci fotos sense el seu permís), en primer lloc cal donar permís a l’aplicació perquè pugui accedir a la càmera i perquè pugui llegir i escriure a la memòria externa. Creeu un nou projecte d’Android (anomenat Camera, per exemple) i obriu el seu fitxer AndroidManifest.xml per afegir el següent tot just abans de l’etiqueta application:

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

Aquesta aplicació s’ha d’executar a un emulador amb targeta SD instal·lada per poder desar les fotos.

Començareu per fer una aplicació que desi les fotos en format JPEG, i més endavant afegirem un botó per desar-les en format PNG. El layout és molt senzill, amb una àrea gran de previsualització i, a sota, un botó per fer la foto i un ImageView petit per veure la foto que s’ha fet.

La previsualització es fa mitjançant un control nou anomenat SurfaceView, dissenyat per a aquesta mena de tasques, i que podeu veure al codi del layout. Pel que fa a les seves propietats, és molt semblant a un ImageView. El botó té associa el mètode onClickFoto() a la seva propietat onClick.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
 
    <SurfaceView
        android:id="@+id/surfaceview"
        android:layout_width="fill_parent"
        android:layout_height="396dp"
        android:layout_weight="0.88" />
 
    <LinearLayout
        android:id="@+id/linearLayout1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="0.88" >
 
        <Button
            android:id="@+id/button1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:onClick="onClickFoto"
            android:text="FOTO" />
 
        <ImageView
            android:id="@+id/miniatura"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:scaleType="fitCenter"
            android:src="@mipmap/ic_launcher" />
 
    </LinearLayout>
 
</LinearLayout>

Fet això, ja es pot començar a editar el codi de l’activitat de l’aplicació. En primer lloc, perquè l’aplicació sigui capaç de mostrar la previsualització de la càmera pel SurfaceView, la seva activitat principal ha d’implementar la interfície SurfaceHolder.Callback. Per fer-ho, heu de canviar la declaració de la vostra activitat tal com segueix:

public class MainActivity extends ActionBarActivity  implements SurfaceHolder.Callback {

Afegiu els imports que siguin necessaris. Veureu que l’Android Studio assenyala l’error CameraActivity degut a que, per tal que l’activitat implementi SurfaceHolder.Callback, ha d’incloure els mètodes surfaceChanged(), surfaceCreated() i surfaceDestroyed(). Feu clic sobre la línia que conté l’error i us apareixerà a l’esquerra un requadre amb diverses opcions disponibles, i seleccioneu l’opció Implement methods, amb la qual cosa s’afegiran els mètodes que faltaven:

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
 
    }
 
    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
 
    }
 
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
 
    }

La funció d’aquests mètodes i els seus paràmetres és donar suport a la previsualització de la càmera de fotos. Són cridats automàticament quan s’executa l’aplicació. Més concretament:

• surfaceCreated() és cridat quan es crea la superfície de previsualització (és a dir, quan es crea l’activitat de l’aplicació) i rep l’activitat a la qual pertany (que és un SurfaceHolder, és a dir, que conté una superfície de previsualització). El que ha de fer és activar la càmera perquè comenci a rebre imatges.
• surfaceChanged() és cridat quan la superfície de previsualització canvia de mida o format, per adaptar la previsualització a la seva mida real. A més del SurfaceHolder, rep el format de píxel i l’amplada i alçada de la superfície de previsualització en píxels. En aquest mètode s’ha de dir a la càmera la mida de previsualització que es necessita. Aquest mètode és cridat quan s’inicia l’aplicació, tot seguit de surfaceCreated().
• surfaceDestroyed()és cridat quan la superfície de previsualització s’ha de destruir, i el que ha de fer en aquest cas és desconnectar la càmera.

Abans d’omplir aquests mètodes, s’ha de començar pel principi i afegir un atribut de tipus Camera per accedir a la càmera de fotos i inicialitzar el SurfaceView i les crides d’actualització de la vista prèvia. Editeu el començament de l’activitat del vostre projecte per afegir l’atribut i dur a terme la inicialització:

    // Aquest atribut permet accedir a la càmera de fotos
    Camera camera;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        // Accedeix al SurfaceView i d'aquest al SurfaceHolder per activar les
        // actualitzacions de la vista prèvia (addCallback)
        SurfaceView surfaceView = (SurfaceView) findViewById(R.id.surfaceview);
        SurfaceHolder surfaceHolder = surfaceView.getHolder();
        surfaceHolder.addCallback(this);
    }

No us oblideu d’afegir els imports necessaris si no ho ha fet automàticament l’Android Studio. Fet això, quan s’engegui l’aplicació es cridaran els tres mètodes de SurfaceHolder.Callback que heu creat abans. En primer lloc cal que editeu el surfaceCreated() per fer que quan es creï la superfície de previsualització s’activi la càmera:

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        camera = Camera.open();
    }

Per tal que la superfície de previsualització i la càmera es posin d’acord pel que fa a la mida de les imatges de la vista prèvia, s’ha d’editar el surfaceChanged() per ajustar l’orientació del SurfaceView i la càmera; fixeu-vos que hem reanomenat els paràmetres perquè siguin més entenedors; vosaltres també haureu de reanomenar-los. Un cop fet això, s’activa la vista prèvia. Com que aquesta operació pot fallar, s’ha d’executar dins d’un try … catch per capturar les possibles excepcions.

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int ample, int alt) {
        try {
            ficarOrientacioCamera(this, Camera.CameraInfo.CAMERA_FACING_BACK, camera);
 
            camera.setPreviewDisplay(holder);
        } catch (Exception e) {
            Toast.makeText(this, "Error accedint a la càmera, causa:" + e.toString(),
                    Toast.LENGTH_LONG).show();
            e.printStackTrace();
        }
        camera.startPreview();
    }

El mètode ficarOrientacioCamera ens permetrà calcular i aplicar l’orientació que tindrà la previsualització. Així, si tenim el mòbil en disposició vertical (mode portrait), la previsualització s’haurà de voltejar 90° ja que inicialment estarà preparada per rebre la informació en disposició horitzontal (mode landscape, 0°). Calculem els graus de diferència i els apliquem amb el mètode setDisplayOrientation. Tot seguit podeu veure el codi del mètode:

public static void ficarOrientacioCamera(Activity activity, int cameraId, android.hardware.Camera camera) {
        Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
        Camera.getCameraInfo(cameraId, info);
        int rotacio = activity.getWindowManager().getDefaultDisplay().getRotation();
        int graus = 0;
 
        switch (rotacio) {
            case Surface.ROTATION_0:
                graus = 0;
                break;
            case Surface.ROTATION_90:
                graus = 90;
                break;
            case Surface.ROTATION_180:
                graus = 180;
                break;
            case Surface.ROTATION_270:
                graus = 270;
                break;
        }
 
        int result;
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            result = (info.orientation + graus) % 360;
            result = (360 - result) % 360;  // compensar l'efecte mirall
        } else {  // camera posterior
            result = (info.orientation - graus + 360) % 360;
        }
        camera.setDisplayOrientation(result);
    }

L’últim punt important és aturar la vista prèvia i alliberar la càmera quan es tanqui l’aplicació. Això s’ha de fer al mètode surfaceDestroyed():

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        camera.stopPreview();
        camera.release();
    }

Ja podeu provar d’executar l’aplicació, però encara no cliqueu el botó de Foto ja que encara no hem escrit el mètode onClickFoto() al qual està associat, i l’aplicació fallaria. El que ha de fer aquest mètode és molt senzill: només ha de dir-li a la càmera que faci la foto i desar-la on calgui. Però això, que és fàcil de dir, és una mica més complicat de fer en realitat perquè la càmera no fa les fotos immediatament, sinó que es pren el seu temps (ha d’enfocar, disparar i enviar els píxels de la imatge).

Per aquest motiu, l’ordre enviada a la càmera perquè faci la foto, takePicture(), s’executa immediatament i no retorna la foto (la definició del mètode és void), sinó que aquesta es rep més endavant en un objecte de tipus PictureCallback que hem de crear prèviament perquè rebi la foto i, en aquest cas, la desi.

Aquest comportament és el que s’anomena una crida asíncrona, en la qual els resultats es reben més tard, en un altre lloc. Aquestes crides són freqüents quan accedim a dispositius i xarxes.

Més concretament, takePicture() rep tres paràmetres que són tres objectes amb les següents finalitats:

• Camera.ShutterCallback shutter: l’objecte que s’ha de cridar just quan la càmera fa la foto. Per defecte aquest objecte fa el so del “clic”; si li asssigneu null aleshores no farà aquest clic, i si hi afegiu el vostre codi podeu redefinir el seu comportament.
• Camera.PictureCallback raw: rep la foto que ha fet la càmera sense comprimir. Pot ser útil per emmagatzemar la foto en altres formats que no siguin JPEG, com ara en PNG. També pot ser null.
• Camera.PictureCallback jpeg: rep la foto comprimida en format JPEG, per emmagatzemar-la o fer-ne qualsevol altra operació. També pot ser null.

En aquest exemple treballareu amb els paràmetres shutter i jpeg, perquè el paràmetre raw és més complicat de fer servir. Creareu un shutter buit per tal de gestionar el clic i veure quin és el seu format.

Comenceu amb la primera versió de l’ onClickFoto() per anar veient pas per pas com afegir les diferents funcionalitats:

    public void onClickFoto(View v) {
      camera.takePicture(null, null, null);
    }

Si executeu la vostra aplicació amb aquesta versió del mètode, veureu que quan cliqueu el botó Foto l’aplicació queda com aturada. Això és perquè la càmera atura la previsualització quan fa una foto, i aleshores, tot i que fa la foto, ni es sent el clic, ni es recull la foto, ni es continua amb la vista prèvia.

Canvieu el contingut de l‘onClickFoto() per sentir el clic i veure un toast per comprovar el que està passant. Fixeu-vos que a la crida camera.takePicture() canvia el primer argument per tal que es faci servir el ShutterCallback:

    public void onClickFoto(View v) {
        // Amb aquest objecte s'activa el clic en fer la foto i es mostra
        // un toast per comprovar que s'ha activat
        Camera.ShutterCallback shutterCB = new Camera.ShutterCallback() {
            @Override
            public void onShutter() {
                Toast.makeText(getApplicationContext(), "S'ha disparat!",
                        Toast.LENGTH_LONG).show();
            }
        };
 
      camera.takePicture(shutterCB, null, null);
  }

Si proveu d’executar l’aplicació i cliqueu el botó, sentireu el clic i veureu el toast, però res més. Encara queda feina per fer.

La manera més senzilla d’emmagatzemar una foto és amb el PictureCallback jpeg, que dóna els píxels de la imatge i amb unes quantes instruccions es pot desar. A més, amb aquest objecte mostrareu la foto que s’ha pres al petit ImageView que hi ha a la vostra aplicació; i finalment també fareu servir aquest nou objecte per tornar a activar la vista prèvia de la càmera. El següent codi s’ha d’afegir a l‘onClickFoto(), després del ShutterCallback que heu escrit abans:

 Camera.PictureCallback jpegCB = new Camera.PictureCallback() {
            // Aquest mètode és cridat quan la foto està feta
            @Override
            public void onPictureTaken(byte[] data, Camera cam) {
  // A "data" arriben les dades de la foto
                if (data != null) {
                    // Converteix els píxels en bitmap
                    Bitmap bm = BitmapFactory.decodeByteArray(data, 0, data.length);
                    // Mostra la imatge a l'ImageView de l'aplicació
                    ImageView miniatura = (ImageView) findViewById(R.id.miniatura);
                    miniatura.setImageBitmap(bm);
 
                    //Crea el directori fotos en cas de no existir
                    File directori = new File(Environment.getExternalStorageDirectory().toString() + "/fotos/");
                    if (!directori.exists()) {
                        directori.mkdir();
                    }
 
                    /* Desa la imatge en format JPG */
                    try {
                        // Genera un nom únic per la imatge
                        String nomFitx = directori.getAbsolutePath() + "/" + UUID.randomUUID().toString() + "-foto.jpg";
 
                        // Generem la sortida a partir del nom del fitxer
                        FileOutputStream fos = new FileOutputStream(nomFitx);
                        // Comprimeix la imatge com a JPG
                        bm.compress(Bitmap.CompressFormat.JPEG, 85, fos);
                        // Mostra el nom del fitxer on s'ha desat
                        Toast.makeText(getApplicationContext(), nomFitx, Toast.LENGTH_SHORT).show();
                        // Alliberem l'OutputStream
                        fos.flush();
                        fos.close();
 
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                // Torna a activar la vista prèvia de la càmera
                camera.startPreview();
            }
        };

Si ens fixem amb el codi del mètode onPictureTaken podem diferenciar els següents blocs de codi:

 // Converteix els píxels en bitmap
                    Bitmap bm = BitmapFactory.decodeByteArray(data, 0, data.length);
                    // Mostra la imatge a l'ImageView de l'aplicació
                    ImageView miniatura = (ImageView) findViewById(R.id.miniatura);
                    miniatura.setImageBitmap(bm);

Amb aquest codi obtenim el Bitmap a partir de l’argument data del mètode, i posteriorment l’assignem al nostre ImageView. Amb aquestes instruccions ja tindrem la representació en pantalla de la imatge i disposarem del Bitmap per després guardar-lo a l’emmagatzemament extern.

//Crea el directori fotos en cas de no existir
                    File directori = new File(Environment.getExternalStorageDirectory().toString() + "/fotos/");
                    if (!directori.exists()) {
                        directori.mkdir();
                    }
 

Hem d’escollir a quin directori guardarem la imatge, amb les línies anteriors estem seleccionant el directori “fotos” que es trobarà a l’emmagatzemament extern per defecte (habitualment /storage/sdcard/).

El condicional comprovarà si no existeix aquest directori i, en cas així sigui, el crearà amb la comanda mkdir.

 /* Desa la imatge en format JPG */
                    try {
                        // Genera un nom únic per la imatge
                        String nomFitx = directori.getAbsolutePath() + "/" + UUID.randomUUID().toString() + "-foto.jpg";
 
                        // Generem la sortida a partir del nom del fitxer
                        FileOutputStream fos = new FileOutputStream(nomFitx);
                        // Comprimeix la imatge com a JPG
                        bm.compress(Bitmap.CompressFormat.JPEG, 85, fos);
                        // Mostra el nom del fitxer on s'ha desat
                        Toast.makeText(getApplicationContext(), nomFitx, Toast.LENGTH_SHORT).show();
                        // Alliberem l'OutputStream
                        fos.flush();
                        fos.close();
 
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

Amb aquestes instruccions, el que esteu fent en primer lloc és obtenir un nom de fitxer únic (gràcies al mètode randomUUID()) que estigui ubicat al directori “fotos” que hem seleccionat al codi anterior. Tot seguit, es crea un fitxer de sortida (FileOutputStream fos) per poder desar la imatge. Amb Bitmap.compress() es comprimeix i es desa la imatge al fitxer, i finalment es mostra un toast per veure el nom del fitxer.

Finalment, fem un flush() i un close() de l‘OutputStream, és a dir, forcem l’escriptura de dades que puguin quedar al buffer, i tanquem i alliberem el recurs.

Ara que ja ho teniu tot preparat, heu de canviar la crida a camera.takePicture() perquè faci servir aquest nou objecte:

        camera.takePicture(shutterCB, null, jpegCB);

Si proveu d’executar l’aplicació i fer una foto, sentireu el clic i veureu els dos toast, amb la qual cosa s’haurà desat la vostra imatge. Podeu veure una captura de la pantalla a la figura.

Per tal d’accedir a la imatge podeu obrir el monitor de l’emulador Android anant a Tools/Android/Android Device Monitor, on heu d’accedir a la pestanya File Explorer per tal de veure els fitxers del dispositiu virtual Android.

Aneu a la carpeta /storage/sdcard/fotos, tal com es veu a la figura. En aquesta carpeta hi trobareu les imatges que ha capturat la càmera. A la part superior de la finestra hi ha un botó amb un disquet i una fletxa al damunt que serveix per transferir un fitxer de l’emulador al vostre ordinador. Proveu de copiar alguna de les imatges per comprovar que la foto correspon a la que heu pres amb la càmera.

Per guardar la foto en format PNG només haurem de canviar el nom del fitxer i el Bitmap.CompressFormat; així, el codi del PictureCallback quedaria de la següent manera:

Camera.PictureCallback jpegCB = new Camera.PictureCallback() {
            // Aquest mètode és cridat quan la foto està feta
            @Override
            public void onPictureTaken(byte[] data, Camera cam) {
                // A "data" arriben les dades de la foto
                if (data != null) {
                    // Converteix els píxels en bitmap
                    Bitmap bm = BitmapFactory.decodeByteArray(data, 0, data.length);
                    // Mostra la imatge a l'ImageView de l'aplicació
                    ImageView miniatura = (ImageView) findViewById(R.id.miniatura);
                    miniatura.setImageBitmap(bm);
 
                    //Crea el directori fotos en cas de no existir
                    File directori = new File(Environment.getExternalStorageDirectory().toString() + "/fotos/");
                    if (!directori.exists()) {
                        directori.mkdir();
                    }
 
                    /* Desa la imatge en format PNG */
                    try {
                        // Genera un nom únic per la imatge
                        String nomFitx = directori.getAbsolutePath() + "/" + UUID.randomUUID().toString() + "-foto.png";
 
                        // Generem la sortida a partir del nom del fitxer
                        FileOutputStream sort = new FileOutputStream(nomFitx);
                        // Comprimeix la imatge com a JPG
                        bm.compress(Bitmap.CompressFormat.PNG, 100, sort);
                        // Mostra el nom del fitxer on s'ha desat
                        Toast.makeText(getApplicationContext(), nomFitx, Toast.LENGTH_SHORT).show();
                        // Allibera l'OutputStream
                        sort.flush();
                        sort.close();
 
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
 
                // Torna a activar la vista prèvia de la càmera
                camera.startPreview();
            }
        };

Amb unes senzilles operacions heu vist com convertir dades multimèdia d’un format a un altre.

A banda de mostrar imatges que s’hagin afegit com a recursos de l’aplicació, Android permet visualitzar les imatges que hi ha emmagatzemades a la memòria del dispositiu, com per exemple a la targeta de memòria, que és on s’acostumen a emmagatzemar les imatges capturades amb la càmera de fotos o descarregades d’Internet.

Així doncs, en aquest exemple veureu com es pot triar una imatge emmagatzemada a la targeta SD del dispositiu, que és on es guarden les fotografies fetes amb la càmera, per exemple. Comenceu un nou projecte Android. En primer lloc afegiu el permís <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> abans de l’etiqueta application del fitxer AndroidManifest.xml i prepareu la interfície de l’aplicació perquè inclogui un ImageView que us mostrarà la imatge.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
 
    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@mipmap/ic_launcher" />
 
</LinearLayout>

Al mètode onCreate() de l’activitat s’hi han d’afegir les següents instruccions, que el que fan és engegar una nova activitat que permet triar una imatge. A més, es pot recollir el resultat d’aquesta activitat:

Intent i = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivityForResult(i, ACTIVITAT_SELECCIONAR_IMATGE);

Com veieu, es fa servir una constant per identificar l’activitat; cal declarar-la com a constant de la classe (és a dir, abans de l’onCreate()):

private static final int ACTIVITAT_SELECCIONAR_IMATGE = 1;

El valor concret que li doneu a la constant no és important, mentre no assigneu el mateix valor a més d’una constant que es faci servir per engegar activitats noves.

Amb tot això, quan s’obre la vostra aplicació immediatament s’inicia una activitat que us deixa triar alguna foto de la targeta SD, tal com es veu a la figura.

Un cop trieu una de les imatges, aquesta activitat es tancarà i retornarà la imatge seleccionada a la vostra activitat, però si ho proveu ara mateix veureu que en comptes de mostrar la imatge seleccionada segurament apareixerà la icona d’Android (imatge per defecte de l’ImageView). Per què? Doncs perquè no hem recollit el resultat de l’activitat. Per fer-ho, cal afegir-hi el següent mètode:

    protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
        super.onActivityResult(requestCode, resultCode, intent);
 
        switch (requestCode) {
            case ACTIVITAT_SELECCIONAR_IMATGE:
                if (resultCode == RESULT_OK) {
                    Uri seleccio = intent.getData();
                    String[] columna = {MediaStore.Images.Media.DATA};
 
                    Cursor cursor = getContentResolver().query(seleccio, columna, null, null, null);
                    cursor.moveToFirst();
 
                    int indexColumna = cursor.getColumnIndex(columna[0]);
                    String rutaFitxer = cursor.getString(indexColumna);
                    cursor.close();
 
                    Bitmap imatge = BitmapFactory.decodeFile(rutaFitxer);
                    /* Reduïm la imatge per no tenir problemes de visualització.
                       Calculem l'alçada per mantenir la proporció amb una amplada de 1080 píxels
                    */
                    int alt = (int) (imatge.getHeight() * 1080 / imatge.getWidth());
                    Bitmap reduit = Bitmap.createScaledBitmap(imatge, 1080, alt, true);
 
                    // Afegim la imatge reduïda a l'Imageview
                    ImageView imageView = (ImageView) findViewById(R.id.imageView1);
                    imageView.setImageBitmap(reduit);
                }
        }
    }

Vegem pas a pas què fa aquest mètode per mostrar la imatge seleccionada. En primer lloc, és important el nom del mètode, onActivityResult(), perquè serà cridat quan alguna activitat engegada amb startActivityForResult() acabi. El mètode rep tres paràmetres: requestCode, que és el codi amb què heu iniciat l’activitat (la constant definida prèviament); resultCode, que és el codi d’èxit o error de l’activitat; i finalment, intent, que dóna accés a les dades de l’activitat.

En primer lloc es crida el mètode corresponent de la superclasse perquè faci les operacions bàsiques. Tot seguit, s’ha de mirar quin és el codi de l’activitat (perquè poden haver-se’n llançat vàries) amb el switch, i comprovar que l’activitat ha tornat amb èxit (que resultCode sigui RESULT_OK). Si no, us podria aparèixer algun missatge d’error.

Un cop comprovat això ja es pot començar a extreure la imatge. Penseu que l’activitat pren una estructura de dades complexa, una taula (seleccio) amb moltes columnes d’informació; n’extraiem la columna DATA, que és la que ens interessa. Tot seguit fem servir un cursor (una mena d’índex a la taula) per accedir a la posició que ens interessa (el primer element), i finalment llegim el seu contingut per obtenir el nom del fitxer d’imatge (rutaFitxer).

Només queda llegir i carregar la imatge a l’aplicació (variable imatge) i accedir a l’ImageView per tal que la mostri; abans, però, la reduirem per no tenir problemes de memòria que impedeixin la seva representació. Ara ja podreu veure la imatge quan la seleccioneu.

Els dispositius mòbils poden ser eines útils com a enregistradores de so, perquè estan equipats amb un micròfon i disposen d’espai per emmagatzemar so. Per tal de fer servir aquesta prestació, crearem una aplicació que, quan es premi un botó, començarà a enregistrar so pel micròfon del dispositiu; un cop fet això, permetrà reproduir el so per tal de comprovar que s’ha enregistrat el que es desitjava.

L’emulador d’Android no accedeix al micròfon, per la qual cosa si executeu aquesta aplicació a l’emulador es crearà un fitxer d’àudio vàlid però en silenci; cal executar-la, doncs, en un dispositiu per provar-la.

L’enregistrament de so a Android s’aconsegueix mitjançant un objecte MediaRecorder, que serveix per enregistrar àudio i vídeo d’una manera relativament senzilla. Un cop s’hagi desat el fitxer d’àudio, es reproduirà fent servir un objecte de tipus MediaPlayer, que és el complementari del MediaRecorder: permet reproduir àudio i vídeo a les aplicacions Android.

El fitxer d’àudio es desarà a la carpeta compartida per música i so, de manera que qualsevol altra aplicació hi tingui accés. Així doncs, els permisos que requereix l’aplicació seran dos: accedir al micròfon i escriure fitxers a l’emmagatzemament extern. Creeu un nou projecte d’Android i afegiu els permisos següents al fitxer AndroidManifest.xml:

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

D’altra banda, la interfície d’aquesta aplicació és molt senzilla: només cal crear dos botons, un per iniciar o aturar la gravació i un altre per reproduir l’arxiu de so. El layout.xml ha de ser el següent:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
    android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity">
 
    <ToggleButton
        android:id="@+id/botoGravar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:textOff="Gravar"
        android:textOn="Aturar"
        android:text="ToggleButton"
        android:onClick="onClickBotoGravar"/>
 
    <Button
        android:id="@+id/botoReproduir"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_marginLeft="15dp"
        android:layout_toRightOf="@+id/botoGravar"
        android:text="Reproduir"
        android:onClick="onClickBotoReproduir"/>
 
</RelativeLayout>

Per gravar fareu servir un ToggleButton, que té una llumeneta que s’encén quan el botó està “activat”. En aquest cas el fareu servir per indicar que s’està gravant. Com podeu veure, cada botó té associat un mètode diferent que s’executarà quan el cliqueu (propietat onClick).

El funcionament general de l’aplicació serà el següent: amb dues variables booleanes es controlarà si l’aplicació està gravant o no i si està reproduint o no l’arxiu d’àudio. També es necessiten atributs de l’activitat per recordar el nom del fitxer d’àudio i els objectes MediaRecorder i MediaPlayer que es faran servir. Al mètode onCreate() de l’activitat es definirà el nom del fitxer d’àudio. Per tant, el començament del codi de l’aplicació serà:

    private static String mNomFitxer = null;
 
    private MediaRecorder mRecorder = null;
    private MediaPlayer mPlayer = null;
    private boolean mGravant = false;
    private boolean mReproduint = false;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // Generar el nom del fitxer
        mNomFitxer = Environment.getExternalStorageDirectory() + "/gravacio.3gp";
 
    }

Com podeu veure, l’extensió de l’arxiu d’àudio és 3gp, que és un format d’àudio i vídeo molt habitual per a dispositius mòbils. Quan es creï el MediaRecorder s’haurà d’especificar que el format sigui aquest.

La primera funcionalitat que afegirem és la gravació amb el micròfon. Quan l’usuari de l’aplicació clica el botó Gravar, es crida el mètode onClickBotoGravar() tal com heu vist al layout de l’aplicació. D’altra banda, aquest mètode comprova l’estat actual (gravant o no, amb l’atribut mGravant) i segons el seu valor atura la gravació (cridant el mètode aturaGravacio()) o l’engega amb el mètode comencaGravacio(). Finalment, canvia a l’altre estat (si estava gravant deixa de gravar i viceversa).

    public void onClickBotoGravar(View view) {
        if (mGravant) {
            aturaGravacio();
        } else {
            comencaGravacio();
        }
        // Canvia a l'altre estat
        mGravant = !mGravant;
    }

El mètode comencaGravacio() té com a tasques principals crear el MediaRecorder, configurar-lo perquè gravi el so del micròfon al fitxer i format desitjat, i finalment posar en marxa la gravació. Els paràmetres més importants que cal indicar al MediaRecorder són:

• Font d’àudio amb el mètode setAudioSource(), en aquest cas el micròfon. Hi ha altres valors possibles, els més interessants dels quals són MediaRecorder.AudioSource.VOICE_UPLINK (gravació del so que envia l’usuari en una conversa telefònica) i MediaRecorder.AudioSource.VOICE_DOWNLINK (gravació del so que rep l’usuari en una conversa telefònica, és a dir, el que diu l’altre interlocutor).
• Format del fitxer d’àudio que es gravarà amb el mètode setOutputFormat(), en aquest cas 3GP (MediaRecorder.OutputFormat.THREE_GPP). Altres valors interessants són MediaRecorder.OutputFormat.AAC_ADTS, un format d’alta qualitat sovint utilitzat per a l’àudio de pel·lícules, o MediaRecorder.OutputFormat.MPEG_4, per guardar l’àudio en format MP4, que és un format suportat per molts dispositius i programes.
• Nom del fitxer d’àudio que es gravarà, mitjançant setOutputFile().
• Codificació d’àudio, mitjançant setAudioEncoder(). En aquest cas es fa servir MediaRecorder.AudioEncoder.AMR_NB, però hi ha d’altres codificacions amb més qualitat, com ara MediaRecorder.AudioEncoder.AMR_WB, o bé MediaRecorder.AudioEncoder.AAC.

    private void comencaGravacio() {
        // Crea el MediaRecorder i especifica la font d'audio, el format
        // de sortida i el fitxer, i el codificador d'audio
        mRecorder = new MediaRecorder();
        mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
        mRecorder.setOutputFile(mNomFitxer);
        mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
 
        // En enllestir la gravació poden sorgir problemes, per tant cal
        // preveure excepcions
        try {
            mRecorder.prepare();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        // Si s'ha pogut disposar tot correctament, es comença a gravar
        mRecorder.start();
    }

D’altra banda, per aturar la gravació s’ha d’aturar el MediaRecorder i alliberar-lo perquè alliberi el micròfon i el deixi a l’abast d’altres aplicacions:

    private void aturaGravacio() {
        mRecorder.stop();
        mRecorder.release();
        mRecorder = null;
    }

Pel que fa a la reproducció del fitxer d’àudio que s’ha gravat, el mètode onClickBotoReproduir() és molt semblant a onClickBotoGravar(), ja que mira si ja s’està reproduint el fitxer o no, i segons sigui aquest valor atura o engega la reproducció.

    public void onClickBotoReproduir(View v) {
        if (mReproduint) {
            aturaReproduccio();
        } else {
            comencaReproduccio();
        }
        // Canvia a l'altre estat
        mReproduint = !mReproduint;
    }

Els següents dos mètodes fan la feina d’iniciar i aturar la reproducció del so. El primer, comencaReproduccio(), crea un MediaPlayer, especifica el fitxer multimèdia que farà servir amb setDataSource(), prepara el reproductor i el posa en marxa. Com que aquest procés pot fallar (per exemple, si el fitxer no està disponible), s’han d’encerclar les operacions amb un try… catch.

D’altra banda, per aturar la reproducció només cal alliberar el MediaPlayer, que és el que fa el mètode aturaReproduccio().

    private void comencaReproduccio() {
        mPlayer = new MediaPlayer();
        try {
            mPlayer.setDataSource(mNomFitxer);
            mPlayer.prepare();
            mPlayer.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    private void aturaReproduccio() {
        mPlayer.release();
        mPlayer = null;
    }

Ja podeu executar l’aplicació i veure com grava el fitxer gravacio.3gp a la carpeta /storage/sdcard/. A la figura podeu veure una captura de pantalla de l’aplicació.

Un cop feta l’aplicació per gravar àudio, és molt senzill modificar-la perquè els fitxers de sortida estiguin en altres formats i amb altres codificacions. Per exemple, imagineu que necessiteu fer una gravació amb més qualitat i format MP4. Només heu de fer tres canvis a l’aplicació de gravació d’àudio.

En primer lloc, el fitxer on es gravarà hauria de tenir l’extensió mp4. Editeu les línies corresponents a l‘onCreate() i feu el següent:

mNomFitxer= Environment.getExternalStorageDirectory() + "/gravacio.mp4";

A banda d’això, s’ha de canviar el format del fitxer i la codificació que s’utilitza (per fer-ne servir una amb més qualitat de so). Aneu al mètode comencaGravacio() i editeu-hi les línies següents per especificar el format MP4 i la codificació AAC:

mRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
....
mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);

Fet! Amb només tres línies podeu especificar fàcilment el format del fitxer d’àudio que es gravarà.

Com que els dispositius mòbils disposen de càmera i micròfon, també ofereixen la possibilitat de gravar vídeos. Com en el cas de la fotografia, és possible gravar vídeos fent servir l’aplicació de gravació que hi hagi instal·lada o bé programar directament tots els detalls per tal de previsualitzar el vídeo i indicar a la càmera que comenci a gravar. En aquest cas, farem servir l’aplicació de gravació de vídeo perquè acostuma a incloure moltes funcionalitats i els usuaris ja estan acostumats a fer-la servir.

El procediment per activar l’aplicació de gravació des de les vostres aplicacions és l’habitual: executar un intent amb el tipus de tasca que es necessita i recollir el seu resultat per veure si tot ha funcionat correctament; i, en aquest cas, s’ha gravat el vídeo o, altrament, si s’ha cancel·lat la gravació.

En el cas que s’hagi gravat el vídeo correctament, l’aplicació oferirà la possibilitat de reproduir-lo per tal que l’usuari pugui comprovar el seu contingut. Com és habitual, les vostres aplicacions podrien fer qualsevol altra operació amb el vídeo gravat.

Creeu un nou projecte Android anomenat GravaVideo amb les opcions per defecte i editeu el seu layout perquè quedi així:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
 
    <Button
        android:id="@+id/botoGravar"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Gravar vídeo"
        android:onClick="onClickBotoGravar" />
 
    <Button
        android:id="@+id/botoReproduir"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Reproduir"
        android:enabled="false"
        android:onClick="onClickBotoReproduir" />
 
    <VideoView
        android:id="@+id/visorVideo"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" />
</LinearLayout>

Aquest projecte conté dos botons, un per indicar que s’iniciï l’aplicació de gravació de vídeo, i un altre per reproduir el vídeo quan es rebi. Aquest segon botó restarà desactivat (enabled=”FALSE”) fins que hi hagi un vídeo disponible, com es mostra a la figura (és allò que veuríeu si provéssiu d’executar l’aplicació en aquest moment).

Haurem d’afegir el següent permís al fitxer AndroidManifest.xml per tal que l’aplicació tingui permís per llegir a l’emmagatzemament extern:

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

El que ha de fer el botó de gravar és crear i executar un Intent que demani l’aplicació de gravació de vídeo que l’usuari tingui instal·lada per defecte.

Aleshores, el començament de l’aplicació haurà de ser com mostra el codi a continuació: es defineix una constant (INTENT_GRAVAR_VIDEO) per identificar l’intent que engegarà el gravador de vídeo (li podeu assignar un número qualsevol), i un Uri per rebre l’adreça del vídeo.

Un Uri és un Universal Resource Identifier, un nom que identifica un recurs, en aquest cas el vídeo gravat.

El mètode onCreate() és força estàndard: simplement activa el layout que heu creat abans. D’altra banda, el mètode onClickBotoGravar() només ha de crear l’intent que demana una captura de vídeo i llançar una activitat amb aquest intent. Com que se li passa la constant INTENT_GRAVAR_VIDEO, quan torni l’aplicació sabrà a què correspon el resultat rebut.

public class MainActivity extends ActionBarActivity {
 
    // Una constant per identificar l'intent de gravar vídeo
    final static int INTENT_GRAVAR_VIDEO = 1;
    // Aquí tornarà l'adreça del vídeo gravat
    Uri uriVideo = null;
 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
 
    public void onClickBotoGravar(View view) {
        // Es crea l'intent i es llança
        Intent intent = new Intent(android.provider.MediaStore.ACTION_VIDEO_CAPTURE);
        startActivityForResult(intent, INTENT_GRAVAR_VIDEO);
    }
  }

Quan l’intent que acabeu de llançar torna, es crida el mètode onActivityResult(), que rep tres paràmetres: requestCode, que és el codi amb el qual l’heu creat (INTENT_GRAVAR_VIDEO); resultCode, que indica si l’intent ha acabat bé (RESULT_OK) o ha estat cancel·lat per l’usuari (RESULT_CANCELED), i data, que torna les dades de l’intent, en aquest cas l’URI del vídeo gravat.

Amb aquesta informació, el mètode comprova que l’intent hagi acabat bé, que sigui l’intent de gravació de vídeo que s’ha engegat abans, i en cas afirmatiu mostra amb un toast l’URI del vídeo i activa el botó de reproducció (que estava desactivat per defecte); si no, mostra un missatge per indicar a l’usuari que la gravació s’ha cancel·lat.

    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode == RESULT_OK) {
            if (requestCode == INTENT_GRAVAR_VIDEO) {
 
                uriVideo = data.getData();
                Toast.makeText(this,
                        uriVideo.getPath(),
                        Toast.LENGTH_LONG).show();
                // Activar el botó de reproduir vídeo perquè ja hi ha un vídeo
                Button botoReproduir = (Button) findViewById(R.id.botoReproduir);
                botoReproduir.setEnabled(true);
            }
        } else if (resultCode == RESULT_CANCELED) {
            uriVideo = null;
            Toast.makeText(this,
                    "Gravació cancel·lada!",
                    Toast.LENGTH_LONG).show();
        }
    }

La segona funcionalitat de l’aplicació és mostrar el vídeo que s’ha gravat quan l’usuari premi el botó Reproduir, que s’ha activat quan l’aplicació ha gravat un vídeo amb èxit (perquè si aquest botó hagués estat disponible i l’usuari l’hagués clicat, s’hauria produït un error).

La funcionalitat del mètode que s’executa en clicar el botó de reproduir és molt senzilla: simplement mostra un toast amb l’URI del vídeo i tot seguit accedeix al VideoView, carrega el vídeo i comença la reproducció.

    public void onClickBotoReproduir(View view) {
        // Primer mostra un toast amb l'URI del vídeo
        Toast.makeText(this,
                "Reproduint: " + uriVideo.getPath(),
                Toast.LENGTH_LONG).show();
 
        // Després accedeix al visor, carrega el vídeo i el reprodueix
        VideoView visorVideo = (VideoView) findViewById(R.id.visorVideo);
        visorVideo.setVideoURI(uriVideo);
        visorVideo.start();
    }

Un cop completada l’aplicació, podeu provar d’executar-la i comprovar el seu comportament. A la figura es pot veure la gravació de vídeo engegada (amb l’aplicació estàndard instal·lada per l’usuari del dispositiu).

Un cop el vídeo s’ha gravat, la vostra aplicació us mostra l’URI del vídeo, que és un identificador simbòlic que permet accedir-hi, com es veu a la figura. No es tracta pas de l’adreça del fitxer de vídeo, que per defecte es gravarà a la carpeta /storage/sdcard/DCIM/Camera/ del dispositiu amb un nom com ara VID_20150101_121310.mp4, generat automàticament amb la data i l’hora.

Comproveu-ho fent servir el monitor de l’emulador: Tools/Android/Android Device Monitor.

Com podeu comprovar també, l’aplicació permet gravar més d’un vídeo; com que feu ús de l’aplicació estàndard de gravació, cada nou vídeo que graveu rep un nom diferent (amb la data i l’hora) i, com podeu veure a les toast que van sortint, una URI diferent per tal que l’aplicació els pugui distingir.

Tot i que feu servir l’aplicació estàndard amb la seva configuració per defecte, també és possible passar-li alguns paràmetres per controlar determinats aspectes del vídeo generat, com ara la qualitat, la seva durada màxima i la mida màxima del vídeo gravat. Aquestes opcions s’han d’especificar un cop creat l’intent, però abans d’executar-lo:

    public void onClickBotoGravar(View view) {
        // Es crea l'intent i es llança
        Intent intent = new Intent(android.provider.MediaStore.ACTION_VIDEO_CAPTURE);
        // Qualitat del vídeo: 1 és alta, 0 baixa
        intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
        // Durada màxima del vídeo en segons
        intent.putExtra(MediaStore.EXTRA_DURATION_LIMIT, 10);
        // Tamany màxim del vídeo en bytes
        intent.putExtra(MediaStore.EXTRA_SIZE_LIMIT, 100000);
        // Començar la gravació
        startActivityForResult(intent, INTENT_GRAVAR_VIDEO);
    }