Suppression d'une image de galerie après la prise d'une photo d'intention de l'appareil photo
Je sais que cela a été demandé de nombreuses manières différentes, mais je ne peux toujours pas sembler supprimer l'image de la galerie du dossier par défaut. J'enregistre correctement le fichier sur la carte SD et je peux le supprimer correctement, mais le fichier image de galerie par défaut affiché dans le dossier Appareil photo ne sera pas supprimé.
J'aimerais que l'image soit supprimée une fois que l'activité est renvoyée car le fichier est déjà stocké sur la carte SD sous /Coupon2.
Aucune suggestion?
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();
}
}
Ma demande nécessite que j'appelle l'intention de prendre une photo. La photo ne peut pas être dans la galerie mais doit plutôt se trouver dans un répertoire spécifique de la carte SD.
A l'origine, je venais d'utiliser EXTRA_OUTPUT, mais j'ai vite découvert ce qui suit: - Certains appareils l'utilisent complètement et sautent la galerie . - Certains appareils l'ignorent complètement et utilisent UNIQUEMENT la galerie . - Certains appareils sont vraiment nuls et enregistrent une image en taille réelle dans la galerie et enregistrent une vignette uniquement à l'emplacement de mon choix. (HTC tu sais qui tu es ...)
Donc, je ne peux pas supprimer aveuglément un fichier de galerie quand j'ai terminé. La dernière photo ajoutée peut être ou ne pas être celle que je veux supprimer. De plus, je devrai peut-être copier ce fichier en remplaçant le mien par la suite. Étant donné que mon activité est de 2 000 lignes et que mon entreprise ne souhaite pas que tout notre code soit publié, je poste uniquement les méthodes impliquées. Espérons que cela aide.
Aussi, je vais dire, ceci est ma première application Android. Je ne serais pas surpris s'il y avait une meilleure façon de faire cela que je ne connais pas, mais c'est ce qui fonctionne pour moi!
Alors, voici ma solution:
Premièrement, dans mon contexte d'application, je définis une variable comme suit:
public ArrayList<String> GalleryList = new ArrayList<String>();
Ensuite, dans mon activité, je définis une méthode pour obtenir une liste de toutes les photos de la galerie:
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());
}
}
Voici une méthode pour renvoyer un nom de fichier unique pour ma nouvelle image:
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();
}
J'ai trois variables dans mon activité qui stockent pour moi des informations sur un fichier en cours. Une chaîne (chemin), une variable de fichier et un URI dans ce fichier:
public static String sFilePath = "";
public static File CurrentFile = null;
public static Uri CurrentUri = null;
Je ne les ai jamais définies directement, je n’appelle qu’un setter sur le chemin du fichier:
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);
}
}
Maintenant, j'appelle l'intention de prendre une photo.
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);
}
Une fois que ceci est fait, et que l'activité revient, voici mon 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());
}
}
}
}
}
Si quelqu'un cherche un moyen plus simple de résoudre ce problème, voici comment j'ai résolu le problème.
J'ai un bouton de capture et quand on appuie dessus, l'intention est envoyée. Ce que j'ai ajouté, c'est que je vais aussi chercher le dernier identifiant de l'image mediastore et le stocker:
/**
* 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;
}
}
Ensuite, lorsque l'activité retourne, je lance ce code pour rechercher le dernier identifiant d'image avant la capture, puis les requêtes d'images après la capture ont un identificateur supérieur à celui enregistré et s'il en existe plusieurs, supprime l'enregistrement situé à l'emplacement que j'ai spécifié pour que la caméra enregistre.
/*
* 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();
Pour moi, c'était une solution beaucoup plus simple, et j'ai testé sur mon HTC qui avait ce problème.
Autre remarque , j'avais initialement utilisé * DATE_TAKEN * pas * _ID * comme paramètre, mais il semble y avoir un problème avec le fait que sur l'émulateur, certaines des images capturées via l'intention avaient leur millième de seconde * DATE_TAKEN * multipliée par un 1000 alors je suis passé à * _ID * qui semble être beaucoup plus robuste.
Cela supprimera le fichier de la galerie:
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);
}
}
À propos du comportement EXTRA_OUTPUT et non standard. Je pense que ce pseudo-algorithme devrait fonctionner dans tous les cas:
1) N'utilisez pas EXTRA_OUTPUT. L'image/photo ira toujours à l'emplacement de la galerie.
2) Copiez le fichier de l'emplacement de la galerie vers l'emplacement souhaité.
3) Supprimez (avec le code supérieur) le fichier de la galerie.
Mais bien sûr, cela semble trop parfait ... sur certains appareils (par exemple le Galaxy Tab d'origine avec Android 2.3), vous devez utiliser EXTRA_OUTPUT avec ACTION_IMAGE_CAPTURE, sans quoi l'intention ne fonctionne pas.
Je pense que tout le problème vient du fait que vous attendez un certain résultat d'une autre application qui ne se produit pas. Qui est (juste pour être clair) -
- Lancez une activité pouvant prendre des photos, car votre application ne capture pas d'images.
- Indiquez à l'autre application où vous souhaitez enregistrer la photo
- Utilisez l'image enregistrée à l'emplacement que vous avez spécifié.
- Mais le problème est que l'autre application a également enregistré l'image à un emplacement différent également, ce que vous ne voulez pas.
Examinons maintenant le point de vue de l’autre application, qui capture l’image. Permet de considérer deux scénarios (ce qui est possible) -
- Tout d'abord, l'application est lancée avec l'option du nom de fichier ou de l'emplacement où l'image doit être enregistrée.
- Deuxièmement, l'application est lancée sans aucune information supplémentaire, telle que le nom de fichier ou l'emplacement où l'image doit être enregistrée (cela pourrait se produire si l'application de capture est lancée directement à partir du menu).
Maintenant, idéalement, ce qui devrait se passer est que s’il ya des informations supplémentaires telles que nom_fichier ou emplacement, il aurait dû utiliser cet emplacement, sinon il peut utiliser le sien. Mais hélas, nous appartenons à un monde idéal et, comme rien n’est écrit sur ce qui devrait se passer lorsque vous lancez une application d’appareil photo, le développeur de cette application aura sa propre interprétation.
Comme différents appareils ont différentes applications de caméra définies par défaut (oui, la caméra standard est généralement remplacée), les résultats obtenus sont/seront différents.
Ainsi, dans certains appareils photo, il peut être enregistré à un emplacement sur un autre. Il peut également être enregistré dans le dossier Appareil photo (étant donné que l'application Appareil photo peut toujours enregistrer l'image capturée dans le dossier de l'appareil photo et l'enregistrer dans un emplacement différent L'application)
Si vous passez juste un nom de fichier à l'application Appareil photo, cette application doit-elle être renvoyée après avoir pris une photo? Je crois que non. Alors, que devrait dans un tel scénario? C'est très ambigu ou une zone grise.
Désormais, si vous ne souhaitez pas qu'il soit enregistré dans le dossier Appareil photo, déterminez si vous pouvez simplement obtenir le nom du fichier correspondant à l'image récemment capturée, puis le supprimer de votre application. Ou ne dites pas à l'application de la caméra où il doit être sauvegardé, récupérez simplement le nom de fichier et déplacez-le comme vous le souhaitez.
Si vous n'obtenez pas le nom du fichier, vous êtes à la merci de l'autre développeur. (Hé! Ce n’est pas sa faute non plus, il l’a conçu comme il le souhaite!)
Je pense que tu ne peux pas faire ce que tu veux. C'est triste mais je ne peux pas trouver une autre réponse.
Si vous travaillez avec la mise en œuvre de Google Camera, cela fonctionne bien. Cela ne stocke simplement pas les photos dans la galerie car EXTRA_OUTPUT est spécifié.
Mais quand vous faites face à d'autres appareils, ils peuvent faire quelque chose de complètement différent. En effet, HTC, LG et peut-être d'autres ont une implémentation personnalisée de l'appareil photo et vous ne pouvez rien y faire. Vous pouvez le laisser tel quel ou écrire votre propre appareil photo qui fonctionnera exactement comme vous en avez besoin.
En réalité, la question n’est pas liée à cette question, mais vous découvrirez un jour que l’intention de CROP ne fonctionne pas sur certains appareils ( http://groups.google.com/group/Android-developers/browse_frm/thread/2dd647523926192c/4b6d087073a39607? Tvc = 1 & pli = 1 ). Encore une fois si vous en avez besoin, vous devrez l'écrire vous-même.
Ce n’est pas une tâche facile à résoudre mais une approche délicate peut être envisagée. Si vous avez besoin d’une solution simple et efficace pour cela. Essayez le code ci-dessous:
- Enregistrez le temps actuel en millisecondes avant d'appeler l'objectif de la caméra.
- OnActivityResult interroge l'image uri dont la date de prise est supérieure à la milliseconde dans l'étape1. Et supprimez le fichier. C'est tout.
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);
}
Je me battais aussi avec ce problème. Au fait, ce problème est marqué comme suit: Obsolete dans le traqueur Android bug . Pour une raison quelconque, l'équipe Android ne considère plus cela comme un bug. Peut-être parce que c'est lié au fabricant.
Il semble que toutes les solutions (de ce fil de discussion et d'autres articles de blog, etc.) forment l'algorithme suivant:
- Enregistrer un identifiant unique de la dernière photo prise;
- Lancer l'activité de la caméra en utilisant
IntentavecEXTRA_OUTPUT; - Prenez une photo et vérifiez si l'identifiant de la dernière photo prise dans Galerie a été modifié pour décider si elle doit être supprimée.
Quelque chose de similaire est proposé dans la réponse acceptée.
Mais j’ai trouvé qu’une telle approche ne pouvait pas être utilisée dans un code de production. Par exemple, imaginons une situation simple:
Vous stockez un identifiant de la dernière photo prise dans Galerie et lancez l'activité de l'appareil photo. Lorsque l'utilisateur prend une photo sur certains appareils, l'activité de l'appareil photo affiche une boîte de dialogue avec les boutons Cancel et OK (ou quelque chose comme ça). Et la logique derrière eux est la suivante:
- si l'utilisateur appuie sur
Cancel, il revient à l'activité de l'appareil photo et peut continuer à prendre des photos. - s'il/elle (l'utilisateur) appuie sur le bouton
OK, l'activité de la caméra renvoie le résultat à votre application.
Les notes importantes ici: il s’avère que sur certains appareils (j’ai testé sur LG et HTC), l’image peut déjà être enregistrée pendant la présentation de cette boîte de dialogue.
Maintenant, imaginez ce qui se passe si, pour une raison quelconque, l'utilisateur décide d'appuyer sur le bouton Home et de démarrer une autre application (par exemple, une autre application d'appareil photo où l'utilisateur peut prendre différentes photos!). Et puis retourne à votre application où cette boîte de dialogue est toujours présentée et appuie sur OK. Évidemment, dans ce cas, votre application supprimera le mauvais fichier ... et décevra l'utilisateur :(
Après de nombreuses recherches, j’ai donc décidé que la meilleure approche pour surmonter ce problème consiste à écrire votre propre moteur de caméra ou tout simplement à utiliser des bibliothèques tierces comme celle-ci: camera matériel .
Regardez ici - c'est un morceau de code qui enregistre l'image dans le dossier EXTRA_OUTPUT sans l'enregistrer dans la galerie. Ainsi, dans mon application, j'avais l'habitude de prendre une photo directement à partir de l'appareil photo, puis de supprimer une photo prise.
C’est le code que j’utilise qui prend une photo et l’enregistre à l’emplacement spécifié
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);
}
Je gère ensuite la réponse.
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);
}
}
J'ai dû déclarer outputFileUri en tant que variable globale car je ne trouvais aucun moyen d'acquérir le chemin enregistré onActivityResult. En passant le fichier outputFileUri, vous remarquerez que l'image n'est pas enregistrée dans le dossier de la caméra, mais à l'emplacement spécifié. J'ai essayé ce code sur mon Nexus1 et un truc samsung bon marché.
J'espère que cela t'aides
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;
}
Votre meilleur pari est probablement de gérer directement la classe Camera, puis de stocker le fichier jpeg ou raw renvoyé dans le rappel où vous le souhaitez.
Vous pouvez également essayer de supprimer l'image prise par _id du fournisseur de contenu pour le média après son ajout. Il suffit de le trouver par requête et de le supprimer via le ContentResolver.delete, mais vous n'êtes pas sûr de son implémentation.
Après avoir lutté avec cela pendant un certain temps, j'ai mordu la balle et a écrit ma propre activité de caméra cachée. Je suis convaincu que cette solution est beaucoup plus portable et plus sûre que les solutions MediaStore.ACTION_IMAGE_CAPTURE. L'image sera stockée où vous la stockez et nulle part ailleurs et vous n'êtes pas en danger de supprimer par accident un fichier non lié. En outre, il est possible d’adapter exactement la fonction réelle de la caméra aux besoins.
Pour des raisons de portabilité, j'ai utilisé la classe Camera, pas camera2.
Il convient de noter que tous les paramètres de l'appareil photo doivent être définis, notamment la taille de l'image, le mode de mise au point et le mode flash. Ils risquent tous d'être dans un état inattendu lors du démarrage de l'appareil photo.
Afficher ceci comme une réponse et non comme un commentaire, car j’estime que c’est la bonne réponse qui donne un effort minimal.