Nota:questa pagina fa riferimento alla classe Camera, che è stata ritirata. Ti consigliamo di utilizzare CameraX o, per casi d'uso specifici, Camera2. Sia CameraX sia Camera2 supportano Android 5.0 (livello API 21) e versioni successive.
Questa lezione insegna come scattare una foto delegando il compito a un'altra app fotocamera sul dispositivo. Se preferisci creare la tua funzionalità della videocamera, consulta Controllare la videocamera.
Supponiamo che tu stia implementando un servizio meteo in crowdsourcing che crea una mappa del meteo globale fondendo insieme le foto del cielo scattate dai dispositivi su cui è in esecuzione la tua app client. L'integrazione delle foto è solo una piccola parte della tua applicazione. Vuoi scattare foto senza problemi, non reinventare la fotocamera. Fortunatamente, la maggior parte dei dispositivi Android ha già installato almeno un'applicazione per la fotocamera. In questa lezione imparerai a scattare una foto.
Richiedere la funzionalità della fotocamera
Se una funzione essenziale della tua applicazione è scattare foto, limita la sua visibilità su Google Play ai dispositivi con fotocamera. Per pubblicizzare il fatto che la tua applicazione richiede una
videocamera, inserisci un
tag <uses-feature>
nel
file manifest:
<manifest ... > <uses-feature android:name="android.hardware.camera" android:required="true" /> ... </manifest>
Se la tua applicazione utilizza, ma non richiede una videocamera per funzionare, imposta android:required
su false
. In questo modo, Google Play consentirà ai dispositivi senza fotocamera di scaricare la tua applicazione. È quindi tua responsabilità verificare la disponibilità della videocamera in fase di esecuzione chiamando hasSystemFeature(PackageManager.FEATURE_CAMERA_ANY)
.
Se non è disponibile una videocamera, devi disattivare le funzionalità della videocamera.
Ottenere la miniatura
Se la semplice azione di scattare una foto non è il traguardo della tua app, probabilmente vorrai recuperare l'immagine dall'applicazione della fotocamera e utilizzarla.
L'applicazione Fotocamera di Android codifica la foto nel messaggio di risposta
Intent
inviato a
onActivityResult()
come piccolo Bitmap
negli extra,
sotto la chiave "data"
. Il seguente codice recupera questa immagine e la mostra in un
ImageView
.
Kotlin
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) { val imageBitmap = data.extras.get("data") as Bitmap imageView.setImageBitmap(imageBitmap) } }
Java
@Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) { Bundle extras = data.getExtras(); Bitmap imageBitmap = (Bitmap) extras.get("data"); imageView.setImageBitmap(imageBitmap); } }
Nota: questa miniatura di "data"
potrebbe andare bene per un'icona, ma non per molto altro. Gestire un'immagine a dimensione intera richiede un po' più di lavoro.
Salvare la foto a grandezza originale
L'applicazione Fotocamera di Android salva una foto a grandezza originale se specifichi un file in cui salvarla. Devi fornire un nome file completo in cui l'app della fotocamera deve salvare la foto.
In genere, tutte le foto scattate dall'utente con la fotocamera del dispositivo devono essere salvate sul dispositivo
nello spazio di archiviazione esterno pubblico in modo che siano accessibili a tutte le app. La directory corretta per le foto condivise è fornita da getExternalStoragePublicDirectory()
con l'argomento DIRECTORY_PICTURES
. La directory fornita da questo metodo è condivisa tra tutte le app. Su Android 9 (livello API 28) e versioni precedenti, la lettura e la scrittura in questa directory richiedono rispettivamente le autorizzazioni READ_EXTERNAL_STORAGE
e WRITE_EXTERNAL_STORAGE
:
<manifest ...> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> ... </manifest>
Su Android 10 (livello API 29) e versioni successive, la directory corretta per la condivisione delle foto è la tabella MediaStore.Images
.
Non è necessario dichiarare autorizzazioni di archiviazione, a condizione che la tua app debba accedere solo alle foto scattate dall'utente utilizzando la tua app.
Tuttavia, se vuoi che le foto rimangano private solo per la tua app, puoi utilizzare la directory fornita da Context.getExternalFilesDir()
.
Su Android 4.3 e versioni precedenti, la scrittura in questa directory richiede anche l'autorizzazione WRITE_EXTERNAL_STORAGE
. A partire da Android 4.4, l'autorizzazione non è più richiesta perché la directory
non è accessibile da altre app, quindi puoi dichiarare che l'autorizzazione deve essere richiesta solo sulle
versioni precedenti di Android aggiungendo l'attributo
maxSdkVersion
:
<manifest ...> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28" /> ... </manifest>
Nota:i file salvati nelle directory fornite da
getExternalFilesDir()
o
getFilesDir()
vengono
eliminati quando l'utente disinstalla la tua app.
Una volta scelta la directory per il file, devi creare un nome file che non generi conflitti.
Ti consigliamo inoltre di salvare il percorso in una variabile membro per utilizzarlo in un secondo momento. Ecco un esempio di soluzione
in un metodo che restituisce un nome file univoco per una nuova foto utilizzando un timestamp.
Questo esempio presuppone che tu stia chiamando il metodo dall'interno di un Context
.
Kotlin
lateinit var currentPhotoPath: String @Throws(IOException::class) private fun createImageFile(): File { // Create an image file name val timeStamp: String = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date()) val storageDir: File = getExternalFilesDir(Environment.DIRECTORY_PICTURES) return File.createTempFile( "JPEG_${timeStamp}_", /* prefix */ ".jpg", /* suffix */ storageDir /* directory */ ).apply { // Save a file: path for use with ACTION_VIEW intents currentPhotoPath = absolutePath } }
Java
String currentPhotoPath; private File createImageFile() throws IOException { // Create an image file name String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); String imageFileName = "JPEG_" + timeStamp + "_"; File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES); File image = File.createTempFile( imageFileName, /* prefix */ ".jpg", /* suffix */ storageDir /* directory */ ); // Save a file: path for use with ACTION_VIEW intents currentPhotoPath = image.getAbsolutePath(); return image; }
Con questo metodo a disposizione per creare un file per la foto, ora puoi creare e richiamare Intent
come segue:
Kotlin
private fun dispatchTakePictureIntent() { Intent(MediaStore.ACTION_IMAGE_CAPTURE).also { takePictureIntent -> // Ensure that there's a camera activity to handle the intent takePictureIntent.resolveActivity(packageManager)?.also { // Create the File where the photo should go val photoFile: File? = try { createImageFile() } catch (ex: IOException) { // Error occurred while creating the File ... null } // Continue only if the File was successfully created photoFile?.also { val photoURI: Uri = FileProvider.getUriForFile( this, "com.example.android.fileprovider", it ) takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI) startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE) } } } }
Java
private void dispatchTakePictureIntent() { Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); // Ensure that there's a camera activity to handle the intent if (takePictureIntent.resolveActivity(getPackageManager()) != null) { // Create the File where the photo should go File photoFile = null; try { photoFile = createImageFile(); } catch (IOException ex) { // Error occurred while creating the File ... } // Continue only if the File was successfully created if (photoFile != null) { Uri photoURI = FileProvider.getUriForFile(this, "com.example.android.fileprovider", photoFile); takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI); startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE); } } }
Nota: utilizziamo
getUriForFile(Context, String, File)
che restituisce un URI content://
. Per le app più recenti che hanno come target Android 7.0 (livello API 24) e versioni successive, il passaggio di un URI file://
oltre un confine del pacchetto causa un FileUriExposedException
.
Pertanto, ora presentiamo un modo più generico per archiviare le immagini utilizzando un
FileProvider
.
Ora devi configurare FileProvider
. Nel file manifest della tua app, aggiungi un provider all'applicazione:
<application> ... <provider android:name="androidx.core.content.FileProvider" android:authorities="com.example.android.fileprovider" android:exported="false" android:grantUriPermissions="true"> <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/file_paths"></meta-data> </provider> ... </application>
Assicurati che la stringa delle autorità corrisponda al secondo argomento di
getUriForFile(Context, String, File)
.
Nella sezione dei metadati della definizione del provider, puoi vedere che il provider si aspetta che i percorsi idonei vengano configurati in un file di risorse dedicato,
<?xml version="1.0" encoding="utf-8"?> <paths xmlns:android="http://schemas.android.com/apk/res/android"> <external-files-path name="my_images" path="Pictures" /> </paths>
Il componente percorso corrisponde al percorso restituito da
getExternalFilesDir()
quando viene chiamato con
Environment.DIRECTORY_PICTURES
.
Assicurati di sostituire com.example.package.name
con il nome del pacchetto effettivo della tua app. Inoltre, consulta la documentazione di FileProvider
per una descrizione dettagliata degli specificatori di percorso che puoi utilizzare oltre a external-path
.
Aggiungere la foto a una galleria
Quando crei una foto tramite un'intenzione, dovresti sapere dove si trova l'immagine, perché hai indicato dove salvarla. Per tutti gli altri, il modo più semplice per rendere accessibile la foto è farlo dal provider multimediale del sistema.
Nota: se hai salvato la foto nella directory fornita da
getExternalFilesDir()
,
lo scanner multimediale non può accedere ai file perché sono privati per la tua app.
Il seguente metodo di esempio mostra come richiamare lo scanner multimediale di sistema per aggiungere la foto al database del fornitore di contenuti multimediali, rendendola disponibile nell'applicazione Galleria di Android e in altre app.
Kotlin
private fun galleryAddPic() { Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE).also { mediaScanIntent -> val f = File(currentPhotoPath) mediaScanIntent.data = Uri.fromFile(f) sendBroadcast(mediaScanIntent) } }
Java
private void galleryAddPic() { Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE); File f = new File(currentPhotoPath); Uri contentUri = Uri.fromFile(f); mediaScanIntent.setData(contentUri); this.sendBroadcast(mediaScanIntent); }
Decodificare un'immagine scalata
La gestione di più immagini a dimensione intera può essere complicata con una memoria limitata. Se la tua applicazione esaurisce la memoria dopo aver visualizzato solo alcune immagini, puoi ridurre notevolmente la quantità di heap dinamico utilizzato espandendo il file JPEG in un array di memoria già scalato per adattarsi alle dimensioni della visualizzazione di destinazione. Il seguente metodo di esempio dimostra questa tecnica.
Kotlin
private fun setPic() { // Get the dimensions of the View val targetW: Int = imageView.width val targetH: Int = imageView.height val bmOptions = BitmapFactory.Options().apply { // Get the dimensions of the bitmap inJustDecodeBounds = true BitmapFactory.decodeFile(currentPhotoPath, bmOptions) val photoW: Int = outWidth val photoH: Int = outHeight // Determine how much to scale down the image val scaleFactor: Int = Math.max(1, Math.min(photoW / targetW, photoH / targetH)) // Decode the image file into a Bitmap sized to fill the View inJustDecodeBounds = false inSampleSize = scaleFactor inPurgeable = true } BitmapFactory.decodeFile(currentPhotoPath, bmOptions)?.also { bitmap -> imageView.setImageBitmap(bitmap) } }
Java
private void setPic() { // Get the dimensions of the View int targetW = imageView.getWidth(); int targetH = imageView.getHeight(); // Get the dimensions of the bitmap BitmapFactory.Options bmOptions = new BitmapFactory.Options(); bmOptions.inJustDecodeBounds = true; BitmapFactory.decodeFile(currentPhotoPath, bmOptions); int photoW = bmOptions.outWidth; int photoH = bmOptions.outHeight; // Determine how much to scale down the image int scaleFactor = Math.max(1, Math.min(photoW/targetW, photoH/targetH)); // Decode the image file into a Bitmap sized to fill the View bmOptions.inJustDecodeBounds = false; bmOptions.inSampleSize = scaleFactor; bmOptions.inPurgeable = true; Bitmap bitmap = BitmapFactory.decodeFile(currentPhotoPath, bmOptions); imageView.setImageBitmap(bitmap); }