正文

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

︶ㄣSDDLL学院 メ
SDDLL学院V管理员 / 阅读
0723
这篇文章主要介绍了Android开发之使用ExifInterface获取拍照后的图片属性,较为详细的分析了ExifInterface类操作图片的具体使用技巧,需要的朋友可以参考下

这篇文章主要介绍了Android开发之使用ExifInterface获取拍照后的图片属性,较为详细的分析了ExifInterface类操作图片的具体使用技巧,需要的朋友可以参考下

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

?
1
2
3
4
ExifInterface exif = new ExifInterface(file.getPath());
String widthStr = exif.getAttribute(ExifInterface.TAG_IMAGE_WIDTH);
String heightStr = exif.getAttribute(ExifInterface.TAG_IMAGE_LENGTH);
......
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
/*
 * 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程序设计有所帮助。