lecture des métadonnées EXIF d'android jpeg à partir de la fonction de rappel d'image

pour lire les métadonnées / EXIF de l'image byte[] (utile pour Camera.takePicture() ) en utilisant version 2.9.1 de la metadata extraction library in Java par Drew Noakes :

try
{
    // Extract metadata.
    Metadata metadata = ImageMetadataReader.readMetadata(new BufferedInputStream(new ByteArrayInputStream(imageData)), imageData.length);

    // Log each directory.
    for(Directory directory : metadata.getDirectories())
    {
        Log.d("LOG", "Directory: " + directory.getName());

        // Log all errors.
        for(String error : directory.getErrors())
        {
            Log.d("LOG", "> error: " + error);
        }

        // Log all tags.
        for(Tag tag : directory.getTags())
        {
            Log.d("LOG", "> tag: " + tag.getTagName() + " = " + tag.getDescription());
        }
    }
}
catch(Exception e)
{
    // TODO: handle exception
}

pour lire L'EXIF orientation de l'image (pas l'orientation de la vignette):

try
{
    // Get the EXIF orientation.
    final ExifIFD0Directory exifIFD0Directory = metadata.getFirstDirectoryOfType(ExifIFD0Directory.class);
    if(exifIFD0Directory.containsTag(ExifIFD0Directory.TAG_ORIENTATION))
    {
        final int exifOrientation = exifIFD0Directory.getInt(ExifIFD0Directory.TAG_ORIENTATION);

        /* Work on exifOrientation */
    }
    else
    {
        /* Not found */
    }
}
catch(Exception e)
{
    // TODO: handle exception
}

le l'orientation est de 1 à 8. Voir ici , ici , ici ou ici .

pour transformer une image bitmap basée sur son orientation EXIF:

try
{
    final Matrix bitmapMatrix = new Matrix();
    switch(exifOrientation)
    {
        case 1:                                                                                     break;  // top left
        case 2:                                                 bitmapMatrix.postScale(-1, 1);      break;  // top right
        case 3:         bitmapMatrix.postRotate(180);                                               break;  // bottom right
        case 4:         bitmapMatrix.postRotate(180);           bitmapMatrix.postScale(-1, 1);      break;  // bottom left
        case 5:         bitmapMatrix.postRotate(90);            bitmapMatrix.postScale(-1, 1);      break;  // left top
        case 6:         bitmapMatrix.postRotate(90);                                                break;  // right top
        case 7:         bitmapMatrix.postRotate(270);           bitmapMatrix.postScale(-1, 1);      break;  // right bottom
        case 8:         bitmapMatrix.postRotate(270);                                               break;  // left bottom
        default:                                                                                    break;  // Unknown
    }

    // Create new bitmap.
    final Bitmap transformedBitmap = Bitmap.createBitmap(imageBitmap, 0, 0, imageBitmap.getWidth(), imageBitmap.getHeight(), bitmapMatrix, false);
}
catch(Exception e)
{
    // TODO: handle exception
}

donc en utilisant ma suggestion edit et pcans, j'ai eu les données de l'image mais ce n'était pas ce à quoi je m'attendais. Plus précisément, tous les appareils ne donneront pas une orientation du tout. Si vous suivez ce chemin, notez que

• Le "Android" fixe " ExifReader bibliothèque que je pointe est en fait le édité 2.3.1 qui est un peu renonciataires vieux. Les nouveaux exemples sur le site web et dans la source se rapportent à la nouvelle 2.6.x où il modifie l'API de manière significative. À l'aide de la 2.3.1 interface, vous pouvez supprimer toutes les données EXIF d'un octet[] en faisant ce qui suit:

          Metadata header;    
          try {
              ByteArrayInputStream bais= new ByteArrayInputStream(data);
              ExifReader reader = new ExifReader(bais);
              header = reader.extract();
              Iterator<Directory> iter = header.getDirectoryIterator();
              while(iter.hasNext()){
                 Directory d = iter.next();
                 Iterator<Tag> iterTag = d.getTagIterator();
                 while(iterTag.hasNext()){
                    Tag t = iterTag.next();
                    Log.e("DEBUG", "TAG: " + t.getTagName() + " : " + t.getDescription());
                 }
              }
          } catch (JpegProcessingException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
          } catch (MetadataException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
          }
  

si vous voulez des valeurs numériques, remplacez simplement

t.getDescription()

avec

d.getInt(t.getTagType())

• bien que ExifReader ait un constructeur utilisant byte [], je dois avoir mal compris ce qu'il attend parce que si j'essaie de l'utiliser avec le tableau de données directement, je reçois des Tags dans le répertoire retourné.

Je n'ai vraiment pas ajouté grand chose en ce qui concerne la réponse est concerné donc j'accepte la réponse de pcans.

si vous utilisez la bibliothèque Glide, vous pouvez obtenir L'orientation Exif à partir d'une entrée:

InputStream is=getActivity().getContentResolver().openInputStream(originalUri);
int orientation=new ImageHeaderParser(is).getOrientation();

si vous voulez un moyen de lire des données EXIF qui ne sera pas si dépendante de l'endroit où votre URI est venu de vous, vous pouvez utiliser le bibliothèque de soutien exif et le lire à partir d'un flux. Par exemple, c'est comme ça que j'obtiens l'orientation de l'image.

dependencies {
...    
compile "com.android.support:exifinterface:25.0.1"
...
}

exemple de code:

import android.support.media.ExifInterface;
...
try (InputStream inputStream = context.getContentResolver().openInputStream(uri)) {
      ExifInterface exif = new ExifInterface(inputStream);
      int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
    } catch (IOException e) {
      e.printStackTrace();
    }

la raison pour laquelle j'ai dû le faire de cette façon une fois que nous avons commencé à cibler api 25 (peut-être un problème sur 24+ aussi) mais en supportant toujours l'api 19, sur android 7 notre application se planterait si je passais dans une URI qui référençait juste un fichier. J'ai donc dû créer une URI pour passer à l'intention de la caméra comme ça.

FileProvider.getUriForFile(context, context.getApplicationContext().getPackageName() + ".fileprovider", tempFile);

le problème est que le fichier n'est pas possible de transformer L'URI en un véritable chemin de fichier (autre que le maintien du chemin de fichier temporaire).

pour tous ceux qui pourraient être intéressés, voici comment obtenir la balise D'Orientation en utilisant l'interface 2.3.1 de https://github.com/strangecargo/metadata-extractor

Metadata header;
try {
    ByteArrayInputStream bais= new ByteArrayInputStream(data);
    ExifReader reader = new ExifReader(bais);
    header = reader.extract();
    Directory dir = header.getDirectory(ExifDirectory.class);
    if (dir.containsTag(ExifDirectory.TAG_ORIENTATION)) {
        Log.v(TAG, "tag_orientation exists: " + dir.getInt(ExifDirectory.TAG_ORIENTATION));
    }
    else {
        Log.v(TAG, "tag_orietation doesn't exist");
    }


} catch (JpegProcessingException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (MetadataException e) {
    e.printStackTrace();
}

si vous avez un content:// type de Uri , android fournit APIs à travers ContentResolver et il n'est pas nécessaire d'utiliser des bibliothèques externes:

public static int getExifAngle(Context context, Uri uri) {
    int angle = 0;
    Cursor c = context.getContentResolver().query(uri,
            new String[] { MediaStore.Images.ImageColumns.ORIENTATION },
            null,
            null,
            null);

    if (c != null && c.moveToFirst()) {
        int col = c.getColumnIndex( MediaStore.Images.ImageColumns.ORIENTATION );
        angle = c.getInt(col);
        c.close();
    }
    return angle;
}

vous pouvez également lire toute autre valeur que vous trouvez dans MediaStore.Images.ImageColumns , comme la latitude et la longitude.

cela ne fonctionne actuellement pas avec file:/// Uris mais peut être facilement modifié.