it-swarm.com.de

Löschen eines Galeriebildes nach einem aufgenommenen Foto

Ich weiß, dass dies auf viele verschiedene Arten gefragt wurde, aber ich kann immer noch nicht das Galeriebild aus dem Standardordner löschen. Ich speichere die Datei korrekt auf der SD-Karte und ich kann die Datei gut löschen, aber die Standardgalerie-Bilddatei, die unter dem Ordner Camera angezeigt wird, wird nicht gelöscht.

Ich möchte, dass das Bild gelöscht wird, sobald die Aktivität zurückgegeben wird, da die Datei bereits unter /Coupon2 auf der SD-Karte gespeichert ist. 

Irgendwelche Vorschläge?

public void startCamera() {
    Log.d("ANDRO_CAMERA", "Starting camera on the phone...");

    mManufacturerText = (EditText) findViewById(R.id.manufacturer);
    String ManufacturerText = mManufacturerText.getText().toString();
    String currentDateTimeString = new Date().toString();

    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    File filedir = new File(Environment.getExternalStorageDirectory()+"/Coupon2");
    filedir.mkdirs();

    File file = new File(Environment.getExternalStorageDirectory()+"/Coupon2", ManufacturerText+"-test.png");
    outputFileUri = Uri.fromFile(file);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);

    startActivityForResult(intent, CAMERA_PIC_REQUEST);
}

protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == CAMERA_PIC_REQUEST && resultCode == -1) {  
        Intent intent = new Intent("com.Android.camera.action.CROP");
        intent.putExtra("crop", "true");
        intent.putExtra("scale", "true");

        intent.putExtra("return-data", false);
        intent.setDataAndType(outputFileUri, "image/*");
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        startActivityForResult(intent, CAMERA_CROP_REQUEST);
    }else { 
        SetImage();
        saveState();
    }
}
64

Für meine Bewerbung muss ich eine Absicht nennen, um ein Foto aufzunehmen. Das Foto darf nicht in der Galerie sein, sondern muss sich in einem bestimmten Verzeichnis auf der SD-Karte befinden.

Ursprünglich habe ich nur den EXTRA_OUTPUT verwendet, entdeckte jedoch bald Folgendes: - Einige Geräte verwenden es vollständig und überspringen die Galerie . - Einige Geräte ignorieren es vollständig und verwenden NUR die Galerie . - Einige Geräte saugen wirklich ein Bild in voller Größe in der Galerie und speichern ein Miniaturbild nur an dem von mir gewünschten Ort. (HTC du weißt wer du bist ...)

Ich kann also eine Galerie-Datei nicht blind löschen, wenn ich fertig bin. Das zuletzt hinzugefügte Foto ist möglicherweise das Foto, das ich entfernen möchte. Möglicherweise muss ich diese Datei auch kopieren, um sie später zu ersetzen. Da meine Tätigkeit 2000 Zeilen umfasst und mein Unternehmen nicht möchte, dass der gesamte Code veröffentlicht wird, poste ich nur die Methoden, die dazu beitragen. Hoffentlich hilft das.

Ich werde auch sagen, dies ist meine erste Android-Anwendung. Es würde mich nicht wundern, wenn es einen besseren Weg gäbe, von dem ich nichts weiß, aber das ist es, was für mich funktioniert!

Also hier ist meine Lösung:

Zunächst definiere ich in meinem Anwendungskontext eine Variable wie folgt:

public ArrayList<String> GalleryList = new ArrayList<String>();

Als Nächstes definiere ich in meiner Aktivität eine Methode, um eine Liste aller Fotos in der Galerie zu erhalten:

private void FillPhotoList()
{
   // initialize the list!
   app.GalleryList.clear();
   String[] projection = { MediaStore.Images.ImageColumns.DISPLAY_NAME };
   // intialize the Uri and the Cursor, and the current expected size.
   Cursor c = null; 
   Uri u = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
   //
   // Query the Uri to get the data path.  Only if the Uri is valid.
   if (u != null)
   {
      c = managedQuery(u, projection, null, null, null);
   }

   // If we found the cursor and found a record in it (we also have the id).
   if ((c != null) && (c.moveToFirst())) 
   {
      do 
      {
        // Loop each and add to the list.
        app.GalleryList.add(c.getString(0));
      }     
      while (c.moveToNext());
   }
}

Hier ist eine Methode, um einen eindeutigen Dateinamen für mein neues Bild zurückzugeben:

private String getTempFileString()
{
   // Only one time will we grab this location.
   final File path = new File(Environment.getExternalStorageDirectory(), 
         getString(getApplicationInfo().labelRes));
   //
   // If this does not exist, we can create it here.
   if (!path.exists())
   {
      path.mkdir();
   }
   //
   return new File(path, String.valueOf(System.currentTimeMillis()) + ".jpg").getPath();
}

Ich habe drei Variablen in meiner Aktivität, die Informationen über eine aktuelle Datei für mich speichern. Eine Zeichenfolge (Pfad), eine Dateivariable und ein URI für diese Datei:

public static String sFilePath = ""; 
public static File CurrentFile = null;
public static Uri CurrentUri = null;

Ich setze diese nie direkt, ich rufe nur einen Setter im Dateipfad an:

public void setsFilePath(String value)
{
   // We just updated this value. Set the property first.
   sFilePath = value;
   //
   // initialize these two
   CurrentFile = null;
   CurrentUri = null;
   //
   // If we have something real, setup the file and the Uri.
   if (!sFilePath.equalsIgnoreCase(""))
   {
      CurrentFile = new File(sFilePath);
      CurrentUri = Uri.fromFile(CurrentFile);
   }
}

Nun rufe ich die Absicht auf, ein Foto zu machen.

public void startCamera()
{
   Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
   // Specify the output. This will be unique.
   setsFilePath(getTempFileString());
   //
   intent.putExtra(MediaStore.EXTRA_OUTPUT, CurrentUri);
   //
   // Keep a list for afterwards
   FillPhotoList();
   //
   // finally start the intent and wait for a result.
   startActivityForResult(intent, IMAGE_CAPTURE);
}

Sobald dies geschehen ist und die Aktivität zurückkommt, ist hier mein Code:

protected void onActivityResult(int requestCode, int resultCode, Intent data)
{
   if (requestCode == IMAGE_CAPTURE)
   {
      // based on the result we either set the preview or show a quick toast splash.
      if (resultCode == RESULT_OK)
      {
         // This is ##### ridiculous.  Some versions of Android save
         // to the MediaStore as well.  Not sure why!  We don't know what
         // name Android will give either, so we get to search for this
         // manually and remove it.  
         String[] projection = { MediaStore.Images.ImageColumns.SIZE,
                                 MediaStore.Images.ImageColumns.DISPLAY_NAME,
                                 MediaStore.Images.ImageColumns.DATA,
                                 BaseColumns._ID,};
         //    
         // intialize the Uri and the Cursor, and the current expected size.
         Cursor c = null; 
         Uri u = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
         //
         if (CurrentFile != null)
         {               
            // Query the Uri to get the data path.  Only if the Uri is valid,
            // and we had a valid size to be searching for.
            if ((u != null) && (CurrentFile.length() > 0))
            {
               c = managedQuery(u, projection, null, null, null);
            }
            //   
            // If we found the cursor and found a record in it (we also have the size).
            if ((c != null) && (c.moveToFirst())) 
            {
               do 
               {
                  // Check each area in the gallary we built before.
                  boolean bFound = false;
                  for (String sGallery : app.GalleryList)
                  {
                     if (sGallery.equalsIgnoreCase(c.getString(1)))
                     {
                        bFound = true;
                        break;
                     }
                  }
                  //       
                  // To here we looped the full gallery.
                  if (!bFound)
                  {
                     // This is the NEW image.  If the size is bigger, copy it.
                     // Then delete it!
                     File f = new File(c.getString(2));

                     // Ensure it's there, check size, and delete!
                     if ((f.exists()) && (CurrentFile.length() < c.getLong(0)) && (CurrentFile.delete()))
                     {
                        // Finally we can stop the copy.
                        try
                        {
                           CurrentFile.createNewFile();
                           FileChannel source = null;
                           FileChannel destination = null;
                           try 
                           {
                              source = new FileInputStream(f).getChannel();
                              destination = new FileOutputStream(CurrentFile).getChannel();
                              destination.transferFrom(source, 0, source.size());
                           }
                           finally 
                           {
                              if (source != null) 
                              {
                                 source.close();
                              }
                              if (destination != null) 
                              {
                                 destination.close();
                              }
                           }
                        }
                        catch (IOException e)
                        {
                           // Could not copy the file over.
                           app.CallToast(PhotosActivity.this, getString(R.string.ErrorOccured), 0);
                        }
                     }
                     //       
                     ContentResolver cr = getContentResolver();
                     cr.delete(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, 
                        BaseColumns._ID + "=" + c.getString(3), null);
                     break;                        
                  }
               } 
               while (c.moveToNext());
            }
         }
      }
   }      
}
69
Paul

Wenn jemand nach einer einfacheren Lösung für dieses Problem sucht, habe ich das Problem hier gelöst.

Ich habe einen Capture-Button, und wenn er gedrückt wird, wird die Absicht gesendet, und ich füge hinzu, dass ich auch die letzte ID aus dem Image-Mediastore bekomme und diese abspeichere:

/**
 * Gets the last image id from the media store
 * @return
 */
private int getLastImageId(){
    final String[] imageColumns = { MediaStore.Images.Media._ID };
    final String imageOrderBy = MediaStore.Images.Media._ID+" DESC";
    final String imageWhere = null;
    final String[] imageArguments = null;
    Cursor imageCursor = managedQuery(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, imageColumns, imageWhere, imageArguments, imageOrderBy);
    if(imageCursor.moveToFirst()){
        int id = imageCursor.getInt(imageCursor.getColumnIndex(MediaStore.Images.Media._ID));
        imageCursor.close();
        return id;
    }else{
        return 0;
    }
}

Wenn die Aktivität zurückkehrt, führe ich diesen Code aus, um nach der letzten Bild-ID vor der Erfassung zu suchen. Anschließend wird nach Abfragen für Bilder nach der Aufnahme eine größere ID als die aufgezeichnete und wenn es mehr ist, wird der Datensatz gelöscht, der sich an der von mir angegebenen Stelle befindet.), damit die Kamera in gespeichert werden kann.

/*
 * Checking for duplicate images
 * This is necessary because some camera implementation not only save where you want them to save but also in their default location.
 */
final String[] imageColumns = { MediaStore.Images.Media.DATA, MediaStore.Images.Media.DATE_TAKEN, MediaStore.Images.Media.SIZE, MediaStore.Images.Media._ID };
final String imageOrderBy = MediaStore.Images.Media._ID+" DESC";
final String imageWhere = MediaStore.Images.Media._ID+">?";
final String[] imageArguments = { Integer.toString(MyActivity.this.captureLastId) };
Cursor imageCursor = managedQuery(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, imageColumns, imageWhere, imageArguments, imageOrderBy);
if(imageCursor.getCount()>1){
    while(imageCursor.moveToNext()){
        int id = imageCursor.getInt(imageCursor.getColumnIndex(MediaStore.Images.Media._ID));
        String path = imageCursor.getString(imageCursor.getColumnIndex(MediaStore.Images.Media.DATA));
        Long takenTimeStamp = imageCursor.getLong(imageCursor.getColumnIndex(MediaStore.Images.Media.DATE_TAKEN));
        Long size = imageCursor.getLong(imageCursor.getColumnIndex(MediaStore.Images.Media.SIZE));
        if(path.contentEquals(MyActivity.this.capturePath)){
            // Remove it
            ContentResolver cr = getContentResolver();
            cr.delete(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, MediaStore.Images.Media._ID + "=?", new String[]{ Long.toString(id) } );
            break;
        }
    }               
}
imageCursor.close();

Für mich war dies eine viel einfachere Lösung, und ich testete mein HTC, auf dem dieses Problem auftrat.

Noch eine Randnotiz , ich habe ursprünglich * DATE_TAKEN * nicht * _ID * als Parameter verwendet, aber es scheint ein Fehler zu geben, dass einige der Bilder, die durch den Intent aufgenommen wurden, auf dem Emulator multipliziert mit dem Millsecond * DATE_TAKEN * multipliziert wurden eine 1000 also habe ich zu * _ID * gewechselt, was viel robuster erscheint.

15
Emil Davtyan

Dadurch wird die Datei aus der Galerie gelöscht:

protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == CAMERA_PIC_REQUEST && resultCode == RESULT_OK) { 

        /* Copy the file to other directory or whatever you want */

        // mContext is the context of the activity
        mContext.getContentResolver().delete(data.getData(), null, null);
    }
 }

Über das EXTRA_OUTPUT nicht das Standardverhalten. Ich denke, dieser Pseudo-Algorithmus sollte in jedem Fall funktionieren:

1) Verwenden Sie nicht EXTRA_OUTPUT. Das Bild/Foto wird immer an den Standort der Galerie verschoben.

2) Kopieren Sie die Datei vom Speicherort der Galerie an den gewünschten Speicherort.

3) Entfernen Sie (mit dem oberen Code) die Datei aus der Galerie.

Aber es scheint natürlich zu perfekt zu sein ... Bei einigen Geräten (z. B. dem ursprünglichen Galaxy Tab mit Android 2.3) müssen Sie EXTRA_OUTPUT mit ACTION_IMAGE_CAPTURE verwenden, ohne dass die Absicht nicht funktioniert.

15
ElYeante

Das ganze Problem, das ich denke, kommt von der Tatsache, dass Sie ein bestimmtes Ergebnis von einer anderen Anwendung erwarten, die nicht geschieht. Welches ist (nur um klar zu sein) - 

  • Starten Sie eine Aktivität, die Bilder aufnehmen kann, da Ihre Anwendung keine Bilder erfasst.
  • Teilen Sie der anderen Anwendung mit, wo Sie das Bild speichern möchten 
  • Verwenden Sie das gespeicherte Bild an dem von Ihnen angegebenen Ort. 
  • Das Problem ist jedoch, dass die andere Anwendung das Bild auch an einem anderen Ort gespeichert hat, was Sie nicht möchten.

Jetzt betrachten wir es aus der anderen Anwendungsperspektive, die das Bild erfasst. Betrachten wir zwei Szenarien (die möglich sind): 

  • Zunächst wird die Anwendung mit der Option Dateiname oder Speicherort des Bildes gestartet.
  • Zweitens wird die Anwendung ohne zusätzliche Informationen wie Dateiname oder Speicherort des Bildes gestartet. (Dies kann passieren, wenn die Capture-App direkt aus dem Menü gestartet wird). 

Im Idealfall sollte nun Folgendes geschehen, wenn zusätzliche Informationen wie Dateiname oder Speicherort vorhanden sind, sollte er diesen Speicherort verwendet haben, wenn nicht, dann kann er seine eigenen verwenden. Aber wir sind aus einer idealen Welt und da nichts in Stein gemeißelt ist, was passieren soll, wenn Sie eine Kamera-Anwendung starten, wird der Entwickler der Kamera-App seine eigene Interpretation haben.

Da für verschiedene Geräte unterschiedliche Kameraanwendungen als Standard festgelegt sind (Ja, die Standardkamera wird normalerweise ersetzt), sind die Ergebnisse unterschiedlich. 

Bei einigen Kameras kann es daher nur an einem Ort gespeichert werden, an einem anderen Ort kann es auch im Ordner Kamera gespeichert werden (da die Kameraanwendung das aufgenommene Bild möglicherweise immer im Ordner der Kamera speichert und es an einem anderen Ort speichert, erhalten Sie einen Bonus die Anwendung)

Wenn Sie einfach einen Dateinamen an die Kameraanwendung übergeben, sollte die Anwendung nach einem Foto wiederhergestellt werden? Ich denke nicht. Was sollte also in einem solchen Szenario sein? Es ist alles sehr vieldeutig oder eine Grauzone.

Wenn Sie nicht möchten, dass es im Ordner "Camera" gespeichert wird, können Sie herausfinden, ob Sie den Dateinamen des kürzlich aufgenommenen Bildes erhalten und dann löschen aus Ihrer Anwendung. Oder teilen Sie der Kameraanwendung nicht mit, wo sie gespeichert werden muss, sondern rufen Sie den Dateinamen auf und verschieben Sie den gewünschten Speicherort.

Wenn Sie den Dateinamen nicht erhalten, sind Sie dem anderen Anwendungsentwickler ausgeliefert. (Hey! Es ist auch nicht seine Schuld, er hat es einfach so entworfen, wie er will!)

5
bluefalcon

Ich denke, du kannst nicht tun, was du willst. Das ist traurig, aber ich kann keine andere Antwort finden.

Wenn Sie mit der Google Camera-Implementierung arbeiten, funktioniert das einwandfrei. Es wird einfach kein Foto in der Galerie gespeichert, wenn EXTRA_OUTPUT angegeben ist.

Wenn Sie jedoch auf andere Geräte stoßen, können sie etwas völlig anderes machen. Das liegt daran, dass HTC, LG und möglicherweise einige andere eine benutzerdefinierte Kameraimplementierung haben, und Sie können nichts dagegen tun. Sie können es so belassen wie es ist oder eine eigene Kamera schreiben, die genau so funktioniert, wie Sie es brauchen.

Eigentlich hat das nichts mit dieser Frage zu tun, aber eines Tages werden Sie feststellen, dass die CROP-Absicht auf einigen Geräten nicht funktioniert ( http://groups.google.com/group/Android-developers/browse_frm/thread/2dd647523926192c/4b6d087073a39607? Tvc = 1 & pli = 1 ). Wenn Sie es also brauchen, müssen Sie es selbst schreiben.

2
Fedor

Dies ist keine leicht zu lösende Aufgabe, kann aber eine knifflige Methode angehen. Wenn jemand eine einfache und funktionierende Lösung dafür benötigt. Versuchen Sie den folgenden Code:

  1. Speichern Sie die aktuelle Zeit in Millisekunden, bevor Sie die Kameraabsicht aufrufen.
  2. OnActivityResult fragt den Bilduri ab, dessen Aufnahmedatum in Schritt1 größer als die Millisekunde ist. Und lösche die Datei. Das ist es.
String[] projection = {MediaStore.Images.ImageColumns.SIZE,
                MediaStore.Images.ImageColumns.DISPLAY_NAME,
                MediaStore.Images.ImageColumns.DATA,
                BaseColumns._ID,MediaStore.Images.ImageColumns.DATE_ADDED};
        final String imageOrderBy = MediaStore.Images.Media._ID + " DESC";
        final String selection = MediaStore.Images.Media.DATE_TAKEN+" > "+mImageTakenTime;
        //// intialize the Uri and the Cursor, and the current expected size.
        Cursor c = null;
        Uri u = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
        c = getActivity().managedQuery(u, projection, selection, null, imageOrderBy);
        if(null != c && c.moveToFirst()){
            ContentResolver cr = getActivity().getContentResolver();
            cr.delete(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                    BaseColumns._ID + "=" + c.getString(3), null);
        }
2
ms shaiju

Ich habe auch mit diesem Thema zu kämpfen. Dieses Problem wird übrigens im Android Bug Tracker als Obsolete markiert. Aus irgendeinem Grund betrachtet das Android-Team dies nicht mehr als Fehler. Vielleicht, weil dies herstellerbezogen ist.

Es scheint, dass alle Lösungen (aus diesem Thread und anderen Blogbeiträgen usw.) den folgenden Algorithmus bilden:

  1. Speichern Sie eine eindeutige Kennung des zuletzt aufgenommenen Fotos.
  2. Starten Sie die Kameraaktivität mit Intent mit EXTRA_OUTPUT;
  3. Machen Sie ein Foto und prüfen Sie, ob sich eine ID des zuletzt in der Galerie aufgenommenen Fotos geändert hat, um zu entscheiden, ob es gelöscht werden soll.

Ähnliches wird in der akzeptierten Antwort vorgeschlagen.

Ich habe jedoch festgestellt, dass ein solcher Ansatz nicht in einem Produktionscode verwendet werden kann. Stellen wir uns zum Beispiel eine einfache Situation vor: 

Sie speichern eine ID des zuletzt aufgenommenen Fotos in der Galerie und starten die Kameraaktivität. Wenn der Benutzer auf einigen Geräten ein Foto macht, zeigt die Kameraaktivität einen Dialog mit den Tasten Cancel und OK (oder ähnlich). Und die Logik dahinter ist wie folgt: 

  • wenn der Benutzer Cancel drückt, kehrt er zur Kameraaktivität zurück und kann weiter Fotos aufnehmen. 
  • wenn er (der Benutzer) die OK-Taste drückt, gibt die Kameraaktivität das Ergebnis an Ihre App zurück. 

Die wichtigen Hinweise hier: Es stellt sich heraus, dass auf einigen Geräten (ich habe es auf LG und HTC getestet) das Bild bereits gespeichert werden können, während dieses Dialogfeld angezeigt wird. 

Stellen Sie sich nun vor, was passiert, wenn der Benutzer aus irgendeinem Grund beschließt, auf die Schaltfläche Home zu tippen und eine andere App zu starten (z. B. eine andere Kamera-App, bei der der Benutzer andere Fotos aufnehmen kann). Und kehrt dann zu Ihrer App zurück, bei der das Dialogfeld noch angezeigt wird, und drückt auf OK. Natürlich löscht Ihre App in diesem Fall die falsche Datei ... und enttäuscht den Benutzer :(

Nach langen Recherchen entschied ich, dass der beste Weg, dieses Problem zu überwinden, darin besteht, eine eigene Kamera-Engine zu schreiben oder einfach einige Drittanbieter-Bibliotheken wie diese zu verwenden: Materialkamera .

1
Stan Mots

Schau mal - das ist ein Stück Code, das Bilder im EXTRA_OUTPUT-Ordner speichert, ohne es in der Galerie zu speichern. Auf diese Weise habe ich in meiner Anwendung das Bild direkt von der Kamera aufgenommen und das aufgenommene Bild gelöscht.

1
barmaley

Dies ist der Code, den ich verwende, um ein Bild an dem angegebenen Ort zu speichern

Uri outputFileUri;

public void takePhoto() {
    File directory = new File(Environment.getExternalStorageDirectory()
            + "/HI-Tech" + "/");

    if (!directory.exists()) {
        directory.mkdir();
    }

    int count = 0;
    if (directory != null) {
        File[] files = directory.listFiles();
        if (files != null) {
            count = files.length;
        }
    }
    count++;
    String imagePath = "IMAGE_" + count + ".jpg";
    File file = new File(directory, imagePath);
    outputFileUri = Uri.fromFile(file);

        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
    startActivityForResult(intent, JobActivity.TAKE_PIC);
}

Ich kümmere mich dann um die Antwort.

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    try {
        if (resultCode == RESULT_OK) {
            if (requestCode == JobActivity.TAKE_PIC) {
                Bitmap bitmap = decodeFile(new File(outputFileUri.getPath()), 160, 120);
    } catch (Exception e) {
        Log.e("Error", "Unable to set thumbnail", e);
    }
}

Ich musste das outputFileUri als globale Variable deklarieren, da ich keine Möglichkeit fand, den gespeicherten Pfad aufActivityResult abzurufen. Wenn Sie das outputFileUri übergeben, werden Sie feststellen, dass das Bild nicht im Ordner Camera, sondern am angegebenen Ort gespeichert ist. Ich habe diesen Code auf meinem Nexus1 und einem billigen Samsung-Ding ausprobiert.

Hoffe das hilft

1
Bear
protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
    if (requestCode == CAMERA_REQUEST && resultCode == RESULT_OK) {

    Bitmap photo = (Bitmap) data.getExtras().get("data");
    Uri tempUri = Utils.getUri(getActivity(), photo);
    File finalFile = new File(getRealPathFromURI(tempUri));
    finalFile.delete();
    }  
}


public String getRealPathFromURI (Uri contentUri) {
    String path = null;
    String[] proj = { MediaStore.MediaColumns.DATA };
    Cursor cursor = getActivity().getContentResolver().query(contentUri, proj, null, null, null);
    if (cursor.moveToFirst()) {
        int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA);
        path = cursor.getString(column_index);
    }
    cursor.close();
    return path;
}
0
Vignes

Ihre beste Wette ist wahrscheinlich, die Camera-Klasse direkt zu handhaben und dann die JPEG- oder RAW-Dateien im Rückruf zu speichern, wo Sie möchten.

Alternativ können Sie versuchen, das aufgenommene Bild von _id vom Inhaltsanbieter für Medien zu löschen, nachdem es hinzugefügt wurde. Suchen Sie es einfach per Abfrage und löschen Sie es über die ContentResolver.delete.

0
HaMMeReD

Nachdem ich mich einige Zeit damit herumgekämpft hatte, biss ich die Kugel und schrieb meine eigene Kamera-Caputere-Aktivität . Ich bin überzeugt, dass dies viel tragbarer und sicherer ist als die MediaStore.ACTION_IMAGE_CAPTURE-Lösungen. Das Bild wird dort gespeichert, wo Sie es gespeichert haben, und Sie sind nirgendwo sonst in Gefahr, und es besteht keine Gefahr, dass eine nicht zusammenhängende Datei versehentlich gelöscht wird. Es ist auch möglich, die tatsächliche Kamerafunktion exakt an die Anforderungen anzupassen.

Aus Gründen der Portabilität habe ich die Klasse Camera verwendet, nicht Camera2. 

Es ist zu beachten, dass alle Kameraparameter eingestellt werden sollten, insbesondere Bildgröße, Fokusmodus und Blitzmodus. Beim Starten der Kamera befinden sich alle möglicherweise in einem unerwarteten Zustand.

Dies als Antwort posten, nicht als Kommentar, weil meiner Meinung nach die richtige Antwort zu minimalem Aufwand führt.

0
Moritz Both