Android开发之使用ExifInterface获取拍照后的图片属性

本文实例讲述了Android开发之使用ExifInterface获取拍照后的图片属性。分享给大家供大家参考，具体如下：

ExifInterface exif = new ExifInterface(file.getPath());
String widthStr = exif.getAttribute(ExifInterface.TAG_IMAGE_WIDTH);
String heightStr = exif.getAttribute(ExifInterface.TAG_IMAGE_LENGTH);
......

/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.media;
import java.io.IOException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.TimeZone;
/**
* This is a class for reading and writing Exif tags in a JPEG file.
*/
public class ExifInterface {
 // The Exif tag names
 /** Type is int. */
 public static final String TAG_ORIENTATION = "Orientation";
 /** Type is String. */
 public static final String TAG_DATETIME = "DateTime";
 /** Type is String. */
 public static final String TAG_MAKE = "Make";
 /** Type is String. */
 public static final String TAG_MODEL = "Model";
 /** Type is int. */
 public static final String TAG_FLASH = "Flash";
 /** Type is int. */
 public static final String TAG_IMAGE_WIDTH = "ImageWidth";
 /** Type is int. */
 public static final String TAG_IMAGE_LENGTH = "ImageLength";
 /** String. Format is "num1/denom1,num2/denom2,num3/denom3". */
 public static final String TAG_GPS_LATITUDE = "GPSLatitude";
 /** String. Format is "num1/denom1,num2/denom2,num3/denom3". */
 public static final String TAG_GPS_LONGITUDE = "GPSLongitude";
 /** Type is String. */
 public static final String TAG_GPS_LATITUDE_REF = "GPSLatitudeRef";
 /** Type is String. */
 public static final String TAG_GPS_LONGITUDE_REF = "GPSLongitudeRef";
 /** Type is String. */
 public static final String TAG_GPS_TIMESTAMP = "GPSTimeStamp";
 /** Type is String. */
 public static final String TAG_GPS_DATESTAMP = "GPSDateStamp";
 /** Type is int. */
 public static final String TAG_WHITE_BALANCE = "WhiteBalance";
 /** Type is rational. */
 public static final String TAG_FOCAL_LENGTH = "FocalLength";
 /** Type is String. Name of GPS processing method used for location finding. */
 public static final String TAG_GPS_PROCESSING_METHOD = "GPSProcessingMethod";
 // Constants used for the Orientation Exif tag.
 public static final int ORIENTATION_UNDEFINED = 0;
 public static final int ORIENTATION_NORMAL = 1;
 public static final int ORIENTATION_FLIP_HORIZONTAL = 2; // left right reversed mirror
 public static final int ORIENTATION_ROTATE_180 = 3;
 public static final int ORIENTATION_FLIP_VERTICAL = 4; // upside down mirror
 public static final int ORIENTATION_TRANSPOSE = 5; // flipped about top-left <--> bottom-right axis
 public static final int ORIENTATION_ROTATE_90 = 6; // rotate 90 cw to right it
 public static final int ORIENTATION_TRANSVERSE = 7; // flipped about top-right <--> bottom-left axis
 public static final int ORIENTATION_ROTATE_270 = 8; // rotate 270 to right it
 // Constants used for white balance
 public static final int WHITEBALANCE_AUTO = 0;
 public static final int WHITEBALANCE_MANUAL = 1;
 private static SimpleDateFormat sFormatter;
 static {
   System.loadLibrary("exif");
   sFormatter = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss");
   sFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
 }
 private String mFilename;
 private HashMap<String, String> mAttributes;
 private boolean mHasThumbnail;
 // Because the underlying implementation (jhead) uses static variables,
 // there can only be one user at a time for the native functions (and
 // they cannot keep state in the native code across function calls). We
 // use sLock to serialize the accesses.
 private static Object sLock = new Object();
 /**
  * Reads Exif tags from the specified JPEG file.
  */
 public ExifInterface(String filename) throws IOException {
   mFilename = filename;
   loadAttributes();
 }
 /**
  * Returns the value of the specified tag or {@code null} if there
  * is no such tag in the JPEG file.
  *
  * @param tag the name of the tag.
  */
 public String getAttribute(String tag) {
   return mAttributes.get(tag);
 }
 /**
  * Returns the integer value of the specified tag. If there is no such tag
  * in the JPEG file or the value cannot be parsed as integer, return
  * <var>defaultValue</var>.
  *
  * @param tag the name of the tag.
  * @param defaultValue the value to return if the tag is not available.
  */
 public int getAttributeInt(String tag, int defaultValue) {
   String value = mAttributes.get(tag);
   if (value == null) return defaultValue;
   try {
     return Integer.valueOf(value);
   } catch (NumberFormatException ex) {
     return defaultValue;
   }
 }
 /**
  * Returns the double value of the specified rational tag. If there is no
  * such tag in the JPEG file or the value cannot be parsed as double, return
  * <var>defaultValue</var>.
  *
  * @param tag the name of the tag.
  * @param defaultValue the value to return if the tag is not available.
  */
 public double getAttributeDouble(String tag, double defaultValue) {
   String value = mAttributes.get(tag);
   if (value == null) return defaultValue;
   try {
     int index = value.indexOf("/");
     if (index == -1) return defaultValue;
     double denom = Double.parseDouble(value.substring(index + 1));
     if (denom == 0) return defaultValue;
     double num = Double.parseDouble(value.substring(0, index));
     return num / denom;
   } catch (NumberFormatException ex) {
     return defaultValue;
   }
 }
 /**
  * Set the value of the specified tag.
  *
  * @param tag the name of the tag.
  * @param value the value of the tag.
  */
 public void setAttribute(String tag, String value) {
   mAttributes.put(tag, value);
 }
 /**
  * Initialize mAttributes with the attributes from the file mFilename.
  *
  * mAttributes is a HashMap which stores the Exif attributes of the file.
  * The key is the standard tag name and the value is the tag's value: e.g.
  * Model -> Nikon. Numeric values are stored as strings.
  *
  * This function also initialize mHasThumbnail to indicate whether the
  * file has a thumbnail inside.
  */
 private void loadAttributes() throws IOException {
   // format of string passed from native C code:
   // "attrCnt attr1=valueLen value1attr2=value2Len value2..."
   // example:
   // "4 attrPtr ImageLength=4 1024Model=6 FooImageWidth=4 1280Make=3 FOO"
   mAttributes = new HashMap<String, String>();
   String attrStr;
   synchronized (sLock) {
     attrStr = getAttributesNative(mFilename);
   }
   // get count
   int ptr = attrStr.indexOf(' ');
   int count = Integer.parseInt(attrStr.substring(0, ptr));
   // skip past the space between item count and the rest of the attributes
   ++ptr;
   for (int i = 0; i < count; i++) {
     // extract the attribute name
     int equalPos = attrStr.indexOf('=', ptr);
     String attrName = attrStr.substring(ptr, equalPos);
     ptr = equalPos + 1;   // skip past =
     // extract the attribute value length
     int lenPos = attrStr.indexOf(' ', ptr);
     int attrLen = Integer.parseInt(attrStr.substring(ptr, lenPos));
     ptr = lenPos + 1;    // skip pas the space
     // extract the attribute value
     String attrValue = attrStr.substring(ptr, ptr + attrLen);
     ptr += attrLen;
     if (attrName.equals("hasThumbnail")) {
       mHasThumbnail = attrValue.equalsIgnoreCase("true");
     } else {
       mAttributes.put(attrName, attrValue);
     }
   }
 }
 /**
  * Save the tag data into the JPEG file. This is expensive because it involves
  * copying all the JPG data from one file to another and deleting the old file
  * and renaming the other. It's best to use {@link #setAttribute(String,String)}
  * to set all attributes to write and make a single call rather than multiple
  * calls for each attribute.
  */
 public void saveAttributes() throws IOException {
   // format of string passed to native C code:
   // "attrCnt attr1=valueLen value1attr2=value2Len value2..."
   // example:
   // "4 attrPtr ImageLength=4 1024Model=6 FooImageWidth=4 1280Make=3 FOO"
   StringBuilder sb = new StringBuilder();
   int size = mAttributes.size();
   if (mAttributes.containsKey("hasThumbnail")) {
     --size;
   }
   sb.append(size + " ");
   for (Map.Entry<String, String> iter : mAttributes.entrySet()) {
     String key = iter.getKey();
     if (key.equals("hasThumbnail")) {
       // this is a fake attribute not saved as an exif tag
       continue;
     }
     String val = iter.getValue();
     sb.append(key + "=");
     sb.append(val.length() + " ");
     sb.append(val);
   }
   String s = sb.toString();
   synchronized (sLock) {
     saveAttributesNative(mFilename, s);
     commitChangesNative(mFilename);
   }
 }
 /**
  * Returns true if the JPEG file has a thumbnail.
  */
 public boolean hasThumbnail() {
   return mHasThumbnail;
 }
 /**
  * Returns the thumbnail inside the JPEG file, or {@code null} if there is no thumbnail.
  * The returned data is in JPEG format and can be decoded using
  * {@link android.graphics.BitmapFactory#decodeByteArray(byte[],int,int)}
  */
 public byte[] getThumbnail() {
   synchronized (sLock) {
     return getThumbnailNative(mFilename);
   }
 }
 /**
  * Stores the latitude and longitude value in a float array. The first element is
  * the latitude, and the second element is the longitude. Returns false if the
  * Exif tags are not available.
  */
 public boolean getLatLong(float output[]) {
   String latValue = mAttributes.get(ExifInterface.TAG_GPS_LATITUDE);
   String latRef = mAttributes.get(ExifInterface.TAG_GPS_LATITUDE_REF);
   String lngValue = mAttributes.get(ExifInterface.TAG_GPS_LONGITUDE);
   String lngRef = mAttributes.get(ExifInterface.TAG_GPS_LONGITUDE_REF);
   if (latValue != null && latRef != null && lngValue != null && lngRef != null) {
     output[0] = convertRationalLatLonToFloat(latValue, latRef);
     output[1] = convertRationalLatLonToFloat(lngValue, lngRef);
     return true;
   } else {
     return false;
   }
 }
 /**
  * Returns number of milliseconds since Jan. 1, 1970, midnight.
  * Returns -1 if the date time information if not available.
  * @hide
  */
 public long getDateTime() {
   String dateTimeString = mAttributes.get(TAG_DATETIME);
   if (dateTimeString == null) return -1;
   ParsePosition pos = new ParsePosition(0);
   try {
     Date datetime = sFormatter.parse(dateTimeString, pos);
     if (datetime == null) return -1;
     return datetime.getTime();
   } catch (IllegalArgumentException ex) {
     return -1;
   }
 }
 /**
  * Returns number of milliseconds since Jan. 1, 1970, midnight UTC.
  * Returns -1 if the date time information if not available.
  * @hide
  */
 public long getGpsDateTime() {
   String date = mAttributes.get(TAG_GPS_DATESTAMP);
   String time = mAttributes.get(TAG_GPS_TIMESTAMP);
   if (date == null || time == null) return -1;
   String dateTimeString = date + ' ' + time;
   if (dateTimeString == null) return -1;
   ParsePosition pos = new ParsePosition(0);
   try {
     Date datetime = sFormatter.parse(dateTimeString, pos);
     if (datetime == null) return -1;
     return datetime.getTime();
   } catch (IllegalArgumentException ex) {
     return -1;
   }
 }
 private static float convertRationalLatLonToFloat(
     String rationalString, String ref) {
   try {
     String [] parts = rationalString.split(",");
     String [] pair;
     pair = parts[0].split("/");
     int degrees = (int) (Float.parseFloat(pair[0].trim())
         / Float.parseFloat(pair[1].trim()));
     pair = parts[1].split("/");
     int minutes = (int) ((Float.parseFloat(pair[0].trim())
         / Float.parseFloat(pair[1].trim())));
     pair = parts[2].split("/");
     float seconds = Float.parseFloat(pair[0].trim())
         / Float.parseFloat(pair[1].trim());
     float result = degrees + (minutes / 60F) + (seconds / (60F * 60F));
     if ((ref.equals("S") || ref.equals("W"))) {
       return -result;
     }
     return result;
   } catch (RuntimeException ex) {
     // if for whatever reason we can't parse the lat long then return
     // null
     return 0f;
   }
 }
 private native boolean appendThumbnailNative(String fileName,
     String thumbnailFileName);
 private native void saveAttributesNative(String fileName,
     String compressedAttributes);
 private native String getAttributesNative(String fileName);
 private native void commitChangesNative(String fileName);
 private native byte[] getThumbnailNative(String fileName);
}

希望本文所述对大家Android程序设计有所帮助。