Android ACTION_IMAGE_CAPTURE Intento

Stiamo provando a utilizzare l'app della fotocamera nativa per consentire all'utente di scattare una nuova foto. Funziona bene se tralasciamo EXTRA_OUTPUT extrae restituisce la piccola immagine Bitmap. Tuttavia, se abbiamo putExtra(EXTRA_OUTPUT,...)l'intenzione prima di avviarlo, tutto funziona finché non si tenta di premere il pulsante "Ok" nell'app della fotocamera. Il pulsante "Ok" non fa nulla. L'app della fotocamera rimane aperta e nulla si blocca. Possiamo cancellarlo, ma il file non viene mai scritto. Cosa dobbiamo fare esattamente ACTION_IMAGE_CAPTUREper scrivere la foto scattata in un file?

Modifica: questo viene fatto tramite l' MediaStore.ACTION_IMAGE_CAPTUREintento, solo per essere chiari

questo è un bug ben documentato in alcune versioni di Android. vale a dire, sulle esperienze di google build di Android, l'acquisizione di immagini non funziona come documentato. quello che ho generalmente usato è qualcosa di simile in una classe di utilità.

public boolean hasImageCaptureBug() {

    // list of known devices that have the bug
    ArrayList<String> devices = new ArrayList<String>();
    devices.add("android-devphone1/dream_devphone/dream");
    devices.add("generic/sdk/generic");
    devices.add("vodafone/vfpioneer/sapphire");
    devices.add("tmobile/kila/dream");
    devices.add("verizon/voles/sholes");
    devices.add("google_ion/google_ion/sapphire");

    return devices.contains(android.os.Build.BRAND + "/" + android.os.Build.PRODUCT + "/"
            + android.os.Build.DEVICE);

}

quindi quando avvio l'acquisizione di immagini, creo un intento che controlla il bug.

Intent i = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
if (hasImageCaptureBug()) {
    i.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File("/sdcard/tmp")));
} else {
    i.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
}
startActivityForResult(i, mRequestCode);

quindi nell'attività a cui torno, faccio diverse cose in base al dispositivo.

protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
     switch (requestCode) {
         case GlobalConstants.IMAGE_CAPTURE:
             Uri u;
             if (hasImageCaptureBug()) {
                 File fi = new File("/sdcard/tmp");
                 try {
                     u = Uri.parse(android.provider.MediaStore.Images.Media.insertImage(getContentResolver(), fi.getAbsolutePath(), null, null));
                     if (!fi.delete()) {
                         Log.i("logMarker", "Failed to delete " + fi);
                     }
                 } catch (FileNotFoundException e) {
                     e.printStackTrace();
                 }
             } else {
                u = intent.getData();
            }
    }

questo ti evita di dover scrivere una nuova app per la fotocamera, ma neanche questo codice è eccezionale. i grandi problemi sono

1. non ottieni mai immagini a grandezza naturale dai dispositivi con il bug. ottieni immagini larghe 512 pixel che vengono inserite nel provider di contenuti di immagini. sui dispositivi senza bug, tutto funziona come un documento, ottieni un'immagine normale di grandi dimensioni.

2. devi mantenere la lista. come scritto, è possibile eseguire il flashing dei dispositivi con una versione di Android (ad esempio build di cyanogenmod ) che ha corretto il bug. in tal caso, il codice si arresterà in modo anomalo. la soluzione consiste nell'utilizzare l'intera impronta digitale del dispositivo.

So che a questo è già stata data una risposta, ma so che molte persone sono inciampate su questo, quindi aggiungerò un commento.

Ho avuto lo stesso identico problema nel mio Nexus One. Questo proveniva dal file non esistente sul disco prima dell'avvio dell'app della fotocamera. Pertanto, mi sono assicurato che il file esistente prima avviasse l'app della fotocamera. Ecco alcuni esempi di codice che ho usato:

String storageState = Environment.getExternalStorageState();
        if(storageState.equals(Environment.MEDIA_MOUNTED)) {

            String path = Environment.getExternalStorageDirectory().getName() + File.separatorChar + "Android/data/" + MainActivity.this.getPackageName() + "/files/" + md5(upc) + ".jpg";
            _photoFile = new File(path);
            try {
                if(_photoFile.exists() == false) {
                    _photoFile.getParentFile().mkdirs();
                    _photoFile.createNewFile();
                }

            } catch (IOException e) {
                Log.e(TAG, "Could not create file.", e);
            }
            Log.i(TAG, path);

            _fileUri = Uri.fromFile(_photoFile);
            Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE );
            intent.putExtra( MediaStore.EXTRA_OUTPUT, _fileUri);
            startActivityForResult(intent, TAKE_PICTURE);
        }   else {
            new AlertDialog.Builder(MainActivity.this)
            .setMessage("External Storeage (SD Card) is required.\n\nCurrent state: " + storageState)
            .setCancelable(true).create().show();
        }

Per prima cosa creo un nome di file univoco (in qualche modo) usando un hash MD5 e lo metto nella cartella appropriata. Quindi controllo per vedere se esiste (non dovrebbe, ma è buona norma controllare comunque). Se non esiste, ottengo la directory principale (una cartella) e creo la gerarchia delle cartelle (quindi se le cartelle che portano alla posizione del file non esistono, seguiranno questa riga. Quindi Creo il file: una volta creato il file ottengo l'Uri e lo passo all'intento, quindi il pulsante OK funziona come previsto e tutto diventa dorato.

Ora, quando si preme il pulsante Ok sull'app della fotocamera, il file sarà presente nella posizione specificata. In questo esempio sarebbe /sdcard/Android/data/com.example.myapp/files/234asdioue23498ad.jpg

Non è necessario copiare il file in "onActivityResult" come pubblicato sopra.

Ho attraversato una serie di strategie di acquisizione di foto e sembra che ci sia sempre un caso, una piattaforma o determinati dispositivi, in cui alcune o tutte le strategie di cui sopra falliranno in modi inaspettati. Sono stato in grado di trovare una strategia che utilizza il codice di generazione URI di seguito, che sembra funzionare nella maggior parte se non in tutti i casi.

mPhotoUri = getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, 
            new ContentValues());
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
intent.putExtra(MediaStore.EXTRA_OUTPUT, mPhotoUri);
startActivityForResult(intent,CAPTURE_IMAGE_ACTIVITY_REQUEST_CODE_CONTENT_RESOLVER);

Per contribuire ulteriormente alla discussione e aiutare i nuovi arrivati, ho creato un'app di esempio / test che mostra diverse strategie per l'implementazione di foto. I contributi di altre implementazioni sono decisamente incoraggiati ad aggiungere alla discussione.

https://github.com/deepwinter/AndroidCameraTester

Ho avuto lo stesso problema in cui il pulsante OK nell'app della fotocamera non ha fatto nulla, sia sull'emulatore che su Nexus One.

Il problema è scomparso dopo aver specificato un nome file sicuro senza spazi bianchi, senza caratteri speciali, in MediaStore.EXTRA_OUTPUT Inoltre, se si specifica un file che risiede in una directory non ancora creata, è necessario crearlo prima. L'app Camera non fa mkdir per te.

Il flusso di lavoro che descrivi dovrebbe funzionare come l'hai descritto. Potrebbe essere utile se tu potessi mostrarci il codice attorno alla creazione dell'Intento. In generale, il seguente schema dovrebbe consentirti di fare ciò che stai provando.

private void saveFullImage() {
  Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  File file = new File(Environment.getExternalStorageDirectory(), "test.jpg");
  outputFileUri = Uri.fromFile(file);
  intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
  startActivityForResult(intent, TAKE_PICTURE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  if ((requestCode == TAKE_PICTURE) && (resultCode == Activity.RESULT_OK)) {
    // Check if the result includes a thumbnail Bitmap
    if (data == null) {    
      // TODO Do something with the full image stored
      // in outputFileUri. Perhaps copying it to the app folder
    }
  }
}

Nota che è l' attività della fotocamera che creerà e salverà il file e non fa effettivamente parte dell'applicazione, quindi non avrà l'autorizzazione di scrittura nella cartella dell'applicazione. Per salvare un file nella cartella dell'app, creare un file temporaneo sulla scheda SD e spostarlo nella cartella dell'app nel onActivityResultgestore.

Per dare seguito al commento di Yenchi sopra, anche il pulsante OK non farà nulla se l'app della fotocamera non è in grado di scrivere nella directory in questione.

Ciò significa che non è possibile creare il file in un luogo scrivibile solo dalla propria applicazione (ad esempio, qualcosa sotto getCacheDir())Qualcosa sotto getExternalFilesDir()dovrebbe funzionare, tuttavia.

Sarebbe bello se l'app della fotocamera stampasse un messaggio di errore nei registri se non fosse in grado di scrivere nel EXTRA_OUTPUTpercorso specificato , ma non l'ho trovato.

per fare in modo che la fotocamera scriva su sdcard ma la conservi in ​​un nuovo album nell'app della galleria, lo uso come segue:

 File imageDirectory = new File("/sdcard/signifio");
          String path = imageDirectory.toString().toLowerCase();
           String name = imageDirectory.getName().toLowerCase();


            ContentValues values = new ContentValues(); 
            values.put(Media.TITLE, "Image"); 
            values.put(Images.Media.BUCKET_ID, path.hashCode());
            values.put(Images.Media.BUCKET_DISPLAY_NAME,name);

            values.put(Images.Media.MIME_TYPE, "image/jpeg");
            values.put(Media.DESCRIPTION, "Image capture by camera");
           values.put("_data", "/sdcard/signifio/1111.jpg");
         uri = getContentResolver().insert( Media.EXTERNAL_CONTENT_URI , values);
            Intent i = new Intent("android.media.action.IMAGE_CAPTURE"); 

            i.putExtra(MediaStore.EXTRA_OUTPUT, uri);

            startActivityForResult(i, 0); 

Tieni presente che dovrai generare un nome file univoco ogni volta e sostituire 1111.jpg che ho scritto. Questo è stato testato con Nexus One. l'uri viene dichiarato nella classe privata, quindi sul risultato dell'attività sono in grado di caricare l'immagine dall'uri su imageView per l'anteprima, se necessario.

Ho avuto lo stesso problema e l'ho risolto con il seguente:

Il problema è che quando specifichi un file a cui solo la tua app ha accesso (ad es. Chiamando getFileStreamPath("file");)

Questo è il motivo per cui mi sono appena assicurato che il file dato esista davvero e che TUTTI abbiano accesso in scrittura ad esso.

Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
File outFile = getFileStreamPath(Config.IMAGE_FILENAME);
outFile.createNewFile();
outFile.setWritable(true, false);
intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT,Uri.fromFile(outFile));
startActivityForResult(intent, 2);

In questo modo, l'app della fotocamera ha accesso in scrittura all'URI specificato e il pulsante OK funziona bene :)

Ti consiglio di seguire il post di formazione Android per scattare una foto. Mostrano in un esempio come scattare foto piccole e grandi. Puoi anche scaricare il codice sorgente da qui

Ho creato una semplice libreria che gestirà la scelta delle immagini da diverse fonti (Galleria, Fotocamera), forse la salverò in una posizione (SD-Card o memoria interna) e restituirà l'immagine, quindi per favore libera di usarla e migliorarla - Android-ImageChooser .

Il file deve essere scrivibile dalla fotocamera, come ha sottolineato Praveen .

Nel mio utilizzo ho voluto archiviare il file nella memoria interna. Ho fatto questo con:

Intent i = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
if (i.resolveActivity(getPackageManager()!=null)){
    try{
        cacheFile = createTempFile("img",".jpg",getCacheDir());
        cacheFile.setWritavle(true,false);
    }catch(IOException e){}
    if(cacheFile != null){
        i.putExtra(MediaStore.EXTRA_OUTPUT,Uri.fromFile(cacheFile));
        startActivityForResult(i,REQUEST_IMAGE_CAPTURE);
    }
}

Ecco cacheFileun file globale utilizzato per fare riferimento al file che è stato scritto. Quindi nel metodo risultato l'intento restituito è nullo. Quindi il metodo per elaborare l'intento è simile al seguente:

protected void onActivityResult(int requestCode,int resultCode,Intent data){
    if(requestCode != RESULT_OK){
        return;
    }
    if(requestCode == REQUEST_IMAGE_CAPTURE){
        try{
            File output = getImageFile();
            if(output != null && cacheFile != null){
                copyFile(cacheFile,output);

                //Process image file stored at output

                cacheFile.delete();
                cacheFile=null;
            }
        }catch(IOException e){}
    }
}

Ecco getImageFile()un metodo di utilità per denominare e creare il file in cui l'immagine deve essere memorizzata ed copyFile()è un metodo per copiare un file.

Puoi usare questo codice

private Intent getCameraIntent() {

    PackageManager packageManager = mContext.getPackageManager();
    List<ApplicationInfo> list = packageManager.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
    Intent main = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    List<ResolveInfo> launchables = packageManager.queryIntentActivities(main, 0);
    if (launchables.size() == 1)
        return packageManager.getLaunchIntentForPackage(launchables.get(0).activityInfo.packageName);
    else
        for (int n = 0; n < list.size(); n++) {
            if ((list.get(n).flags & ApplicationInfo.FLAG_SYSTEM) == 1) {
                Log.d("TAG", "Installed Applications  : " + list.get(n).loadLabel(packageManager).toString());
                Log.d("TAG", "package name  : " + list.get(n).packageName);
                String defaultCameraPackage = list.get(n).packageName;


                if (launchables.size() > 1)
                    for (int i = 0; i < launchables.size(); i++) {
                        if (defaultCameraPackage.equals(launchables.get(i).activityInfo.packageName)) {
                            return packageManager.getLaunchIntentForPackage(defaultCameraPackage);
                        }
                    }
            }
        }
    return null;
}

Risolvere questo problema con il codice risultato attività è molto semplice. Prova questo metodo

if (reqCode == RECORD_VIDEO) {
   if(resCode == RESULT_OK) {
       if (uri != null) {
           compress();
       }
    } else if(resCode == RESULT_CANCELED && data!=null){
       Toast.makeText(MainActivity.this,"No Video Recorded",Toast.LENGTH_SHORT).show();
   }
}

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (resultCode == RESULT_CANCELED)
    {
        //do not process data, I use return; to resume activity calling camera intent
        enter code here
    }
}