Ús de la càmera amb Android

En aquest article veurem com fer ús del hardware de la càmera per a capturar imatges i vídeos. També tractarem sobre l'emmagatzematge dels arxius multimèdia.

Referències:

• Articles en aquesta wiki:
  • Android
  • Android threads
  • Android persistència
• Apunts de MP08 UF2 de DAM a l'IOC.
• Article "photo basics" oficial d'Android. Cal llegir-lo en anglès perquè la versió en castellà conté errors.
• Device File Explorer de l'Android Studio.

Estratègies per a captura d'imatges

Tenim 2 estratègies bàsiques en el què pertoca a l'adquisició d'imatges amb la càmera:

1. Cridar la app Camera externa del propi sistema operatiu. És la forma més senzilla de treballar. Podria arribar a passar que el SO no tingui cap app Camera instal·lada, però sol ser poc habitual. Emprarem un Intent per cridar a l'altra app, la qual ens retornarà la foto com a dades (thumbnail) en el retorn del Intent, o en un arxiu que cal habilitar prèviament abans de cridar-la.
   1. Versió amb thumbnail (miniatura): si no adjuntem cap File al Intent, la App Camera ens retornarà un thumbnail que podem assignar a una ImageView.
   2. Versió full-size: per poder disposar de la foto a tamany complert cal donar permís a la App Camera amb un FileProvider.
      
2. Implementar a la nostra pròpia app la visualització de la càmera i la presa de dades. A nivell de llibreries i codi és més complicat de gestionar. Per la previsualització necessitarem disposar d'una SurfaceView o una PreviewView que podrà monitoritzar el què està captant la càmera i habilitar un botó per a realitzar la captura des del nostre codi. Per aquest mecanisme disposem de diverses llibreries:

Utilitzant la App Camera externa

Podem emprar el tutorial Photo Basics oficial d'Android. A l'inici diu que està deprecated però en realitat encara serveix. Indica que a l'article és obsolet perquè s'utilitza la class Camera (obsoleta) però no s'utilitza pas en tot el tutorial. Utilitzem la app Camera externa del sistema operatiu, que no té res a veure amb la class Camera.

El què sí que està obsolet del tutorial és com llençar una altra app externa per rebre dades. Inicialment es feia amb el mètode Activity.startActivityForResult (complementant-se amb la callback onActivityResult). Ara s'ha de fer amb Activity Results API.

Aquest tutorial per a crida d'una app externa ens clarifica com utilitzar adequadament la Activity Results API amb un Intent que crida, en aquest cas, la galeria d'imatges, i rep una foto.

De fet, l'exemple del tutorial s'assembla més al darrer exemple de l'Activity Results API, el subtítol diu «Create a custom contract» però acte seguit parla del genèric StartActivityForResult contract que és el que serveix per al cas genèric i que s'empra en el tutorial. Li falten alguns avantatges dels nous contractes que milloren algunes situacions, però és més fàcil de treballar.

Comencem accedint a la Galeria d'imatges

public class MainActivity extends AppCompatActivity {
    public static int RC_PHOTO_PICKER = 0;
    ActivityResultLauncher<Intent> someActivityResultLauncher;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...mes codi de inicialització...
 
        someActivityResultLauncher = registerForActivityResult(
            // ...tota la carretada per crear la callback
            // i pintar la foto a l'ImageView...
        });
 
        Button button = findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            // ...creem i cridem l'Intent per engegar l'app Camera externa...
        });
 
    } // onCreate
}

Accedim a la càmera i rebem una miniatura o thumbnail

Foto full-size i FileProvider : donant accés a l'espai privat

Demanar que una altra app faci la foto que nosaltres després utilitzarem té una dificultat: la seguretat d'Android priva que una app pugui veure en els arxius d'una altra. Per tant, la App Camera no podria escriure en el nostre espai intern.

Per solucionar aquest problema, existeix FileProvider. Aquest objecte publicarà temporalment un recurs en un objecte tipus Uri perquè la App Camera hi pugui escriure.

Així, els passos que cal fer son:

1. Crear un FileProvider al AndroidManifest.xml
2. Definir els directoris a un arxiu de Recursos (res) file_paths.xml
3. Crear un arxiu temporal amb l'objecte File.createTempFile.
   1. Utilitza també les funcions d'emmagatzematge intern o extern (getFilesDir o getExternalFilesDir).
4. Transforma el File en Uri amb FileProvider.getUriForFile
5. Llançar el Intent per a la App Camera amb l'afegit perquè ens retorni la foto full-size. Hauriem de tenir una cosa similar a això al Button.onClickListener:

       // creem arxiu on volem guardar la imatge
       String filePath = getExternalFilesDir(Environment.DIRECTORY_PICTURES
                         ).toString() + "/tmpImg.jpg";
       File photoFile = new File( filePath );
       // li donem permisos amb FileProvider pq hi pugui escriure l'app camera
       // ULL: la authority ha de ser la del vostre package "com....fileprovider"
       //      igual que la que heu d'haver configurat al AndroidManifest.xml
       photoURI = FileProvider.getUriForFile(MainActivity.this,
               "com.enricmieza.gallery25.fileprovider",
               photoFile);
    
       // Create Intent
       Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
       // Afegir arxiu amb permisos del FileProvider al Intent
       intent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI);
       cameraResultLauncher.launch(intent);

6. Quan rebem el resultat a la callback cameraResultLauncher, podem utilitzar la mateixa Uri que ja hem fet servir per al FileProvider:

       @Override
       public void onActivityResult(ActivityResult result) {
           if (result.getResultCode() == AppCompatActivity.RESULT_OK) {
               // display foto
               ImageView imageView = findViewById(R.id.imageView);
               Intent data = result.getData();
               Bundle extras = data.getExtras();
               // si ve un bitmap, pinto el bitmap
               if( extras!=null ) {
                   Bitmap imageBitmap = (Bitmap) extras.get("data");
                   imageView.setImageBitmap(imageBitmap);
                   return;
               } else {
                   // si no em retorna res, agafo la photoURI
                   // que hem configurat pel FileProvider
                   if( photoURI!=null ) {
                       imageView.setImageURI(photoURI);
                       return;
                   }
                   Log.e("ERROR","No hi ha cap photoURI");
               }
           }
       }

Imatge de la càmera dins la nostra App

Tutorial Java (medium.com)

Els objectes SurfaceView i PreviewView (widgets que podem incorporar al nostre layout de l'Activity) ens permeten veure el què captura la càmera directament sobre la nostra App. Sembla ser, però, que la gestió d'una SurfaceView és força complicada. Si emprem CameraX, serà més fàcil la gestió amb PreviewView.

Llibreries Android disponibles:

1. Camera: obsoleta des de la API 21. Cal emprar Camera2. Ull amb els tutorials obsolets.
2. Camera2: la llibreria oficial actual.
3. CameraX: una sèria d'utilitats que ens facilita (relativament) el codi. Per sota utilitza Camera2.
   • Descripció general de CameraX.
   • Doc oficial de CameraX.

Tutorial Kotlin

Podem seguir les indicacions del tutorial oficial d'Android per a CameraX.

Aquest tutorial empra View Binding per accedir d'una forma més moderna a les views. Llegeix l'article abans.

I com no, no es pot seguir al peu de la lletra, cal adaptar algunes coses. En concret al pas 2 «Crear el projecte». Resulta que l'arxiu build.gradle ara ha passat a ser build.gradle.kt especificat en format Kotlin també, pel què hi haurà algunes modificacions que indiquem tot seguit:

1. Punt 1: les biblioteques de codi

   dependencies {
       // ...
    
       val camerax_version = "1.4.1"
       implementation("androidx.camera:camera-core:${camerax_version}")
       implementation("androidx.camera:camera-camera2:${camerax_version}")
       implementation("androidx.camera:camera-lifecycle:${camerax_version}")
       implementation("androidx.camera:camera-video:${camerax_version}")
       implementation("androidx.camera:camera-view:${camerax_version}")
       implementation("androidx.camera:camera-extensions:${camerax_version}")
   }

2. El punt 2 de les compileOptions no cal, podem deixar el que ve per defecte amb VERSION_11:

   compileOptions {
           sourceCompatibility = JavaVersion.VERSION_11
           targetCompatibility = JavaVersion.VERSION_11
       }

3. El punt 3 queda així

   buildFeatures {
       viewBinding = true
   }

La resta queda igual. Cal anar amb compte de llegir bé els passos i entendre'ls.

Codis QR

Una aplicació interessant de la càmera pot ser amb generació i escaneig de codis QR.

Aquestes llibreries funcionen (a Febrer de 2023):

• Generació de codis QR.
  • Si us surt el QR borrós (blurred) caldrà escalar el Bitmap amb Bitmap.createScaledBitmap.
• Escaneig de codis QR.