| Methods Summary |
|---|
| private boolean | checkBadComponentCount(int count)
if (mHasDefinedDefaultComponentCount && (mComponentCountActual != count)) {
return true;
}
return false;
|
| private boolean | checkOverflowForRational(Rational[] value)
for (Rational v : value) {
if (v.getNumerator() < LONG_MIN || v.getDenominator() < LONG_MIN
|| v.getNumerator() > LONG_MAX
|| v.getDenominator() > LONG_MAX) {
return true;
}
}
return false;
|
| private boolean | checkOverflowForUnsignedLong(long[] value)
for (long v : value) {
if (v < 0 || v > UNSIGNED_LONG_MAX) {
return true;
}
}
return false;
|
| private boolean | checkOverflowForUnsignedLong(int[] value)
for (int v : value) {
if (v < 0) {
return true;
}
}
return false;
|
| private boolean | checkOverflowForUnsignedRational(Rational[] value)
for (Rational v : value) {
if (v.getNumerator() < 0 || v.getDenominator() < 0
|| v.getNumerator() > UNSIGNED_LONG_MAX
|| v.getDenominator() > UNSIGNED_LONG_MAX) {
return true;
}
}
return false;
|
| private boolean | checkOverflowForUnsignedShort(int[] value)
for (int v : value) {
if (v > UNSIGNED_SHORT_MAX || v < 0) {
return true;
}
}
return false;
|
| private static java.lang.String | convertTypeToString(short type)
switch (type) {
case TYPE_UNSIGNED_BYTE:
return "UNSIGNED_BYTE";
case TYPE_ASCII:
return "ASCII";
case TYPE_UNSIGNED_SHORT:
return "UNSIGNED_SHORT";
case TYPE_UNSIGNED_LONG:
return "UNSIGNED_LONG";
case TYPE_UNSIGNED_RATIONAL:
return "UNSIGNED_RATIONAL";
case TYPE_UNDEFINED:
return "UNDEFINED";
case TYPE_LONG:
return "LONG";
case TYPE_RATIONAL:
return "RATIONAL";
default:
return "";
}
|
| public boolean | equals(java.lang.Object obj)
if (obj == null) {
return false;
}
if (obj instanceof ExifTag) {
ExifTag tag = (ExifTag) obj;
if (tag.mTagId != this.mTagId
|| tag.mComponentCountActual != this.mComponentCountActual
|| tag.mDataType != this.mDataType) {
return false;
}
if (mValue != null) {
if (tag.mValue == null) {
return false;
} else if (mValue instanceof long[]) {
if (!(tag.mValue instanceof long[])) {
return false;
}
return Arrays.equals((long[]) mValue, (long[]) tag.mValue);
} else if (mValue instanceof Rational[]) {
if (!(tag.mValue instanceof Rational[])) {
return false;
}
return Arrays.equals((Rational[]) mValue, (Rational[]) tag.mValue);
} else if (mValue instanceof byte[]) {
if (!(tag.mValue instanceof byte[])) {
return false;
}
return Arrays.equals((byte[]) mValue, (byte[]) tag.mValue);
} else {
return mValue.equals(tag.mValue);
}
} else {
return tag.mValue == null;
}
}
return false;
|
| public long | forceGetValueAsLong(long defaultValue)Gets a long representation of the value.
long[] l = getValueAsLongs();
if (l != null && l.length >= 1) {
return l[0];
}
byte[] b = getValueAsBytes();
if (b != null && b.length >= 1) {
return b[0];
}
Rational[] r = getValueAsRationals();
if (r != null && r.length >= 1 && r[0].getDenominator() != 0) {
return (long) r[0].toDouble();
}
return defaultValue;
|
| public java.lang.String | forceGetValueAsString()Gets a string representation of the value.
if (mValue == null) {
return "";
} else if (mValue instanceof byte[]) {
if (mDataType == TYPE_ASCII) {
return new String((byte[]) mValue, US_ASCII);
} else {
return Arrays.toString((byte[]) mValue);
}
} else if (mValue instanceof long[]) {
if (((long[]) mValue).length == 1) {
return String.valueOf(((long[]) mValue)[0]);
} else {
return Arrays.toString((long[]) mValue);
}
} else if (mValue instanceof Object[]) {
if (((Object[]) mValue).length == 1) {
Object val = ((Object[]) mValue)[0];
if (val == null) {
return "";
} else {
return val.toString();
}
} else {
return Arrays.toString((Object[]) mValue);
}
} else {
return mValue.toString();
}
|
| protected void | forceSetComponentCount(int count)Sets the component count of this tag. Call this function before
setValue() if the length of value does not match the component count.
mComponentCountActual = count;
|
| protected void | getBytes(byte[] buf)Equivalent to getBytes(buffer, 0, buffer.length).
getBytes(buf, 0, buf.length);
|
| protected void | getBytes(byte[] buf, int offset, int length)Gets the {@link #TYPE_UNDEFINED} or {@link #TYPE_UNSIGNED_BYTE} data.
if ((mDataType != TYPE_UNDEFINED) && (mDataType != TYPE_UNSIGNED_BYTE)) {
throw new IllegalArgumentException("Cannot get BYTE value from "
+ convertTypeToString(mDataType));
}
System.arraycopy(mValue, 0, buf, offset,
(length > mComponentCountActual) ? mComponentCountActual : length);
|
| public int | getComponentCount()Gets the component count of this tag.
return mComponentCountActual;
|
| public int | getDataSize()Gets the total data size in bytes of the value of this tag.
return getComponentCount() * getElementSize(getDataType());
|
| public short | getDataType()Gets the data type of this tag
return mDataType;
|
| public static int | getElementSize(short type)Gets the element size of the given data type in bytes.
return TYPE_TO_SIZE_MAP[type];
|
| public int | getIfd()Returns the ID of the IFD this tag belongs to.
return mIfd;
|
| protected int | getOffset()Gets the offset of this tag. This is only valid if this data size > 4 and
contains an offset to the location of the actual value.
return mOffset;
|
| protected Rational | getRational(int index)Gets the {@link #TYPE_RATIONAL} or {@link #TYPE_UNSIGNED_RATIONAL} data.
if ((mDataType != TYPE_RATIONAL) && (mDataType != TYPE_UNSIGNED_RATIONAL)) {
throw new IllegalArgumentException("Cannot get RATIONAL value from "
+ convertTypeToString(mDataType));
}
return ((Rational[]) mValue)[index];
|
| protected java.lang.String | getString()Gets the {@link #TYPE_ASCII} data.
if (mDataType != TYPE_ASCII) {
throw new IllegalArgumentException("Cannot get ASCII value from "
+ convertTypeToString(mDataType));
}
return new String((byte[]) mValue, US_ASCII);
|
| protected byte[] | getStringByte()
return (byte[]) mValue;
|
| public short | getTagId()Gets the TID of this tag.
return mTagId;
|
| public java.lang.Object | getValue()Gets the tag's value or null if none exists.
return mValue;
|
| public byte | getValueAsByte(byte defaultValue)Gets the value as a byte. If there are more than 1 bytes in this value,
gets the first byte. This method should be used for tags of type
{@link #TYPE_UNDEFINED} or {@link #TYPE_UNSIGNED_BYTE}.
byte[] b = getValueAsBytes();
if (b == null || b.length < 1) {
return defaultValue;
}
return b[0];
|
| public byte[] | getValueAsBytes()Gets the value as a byte array. This method should be used for tags of
type {@link #TYPE_UNDEFINED} or {@link #TYPE_UNSIGNED_BYTE}.
if (mValue instanceof byte[]) {
return (byte[]) mValue;
}
return null;
|
| public int | getValueAsInt(int defaultValue)Gets the value as an int. If there are more than 1 ints in this value,
gets the first one. This method should be used for tags of type
{@link #TYPE_UNSIGNED_SHORT}, {@link #TYPE_UNSIGNED_LONG}.
int[] i = getValueAsInts();
if (i == null || i.length < 1) {
return defaultValue;
}
return i[0];
|
| public int[] | getValueAsInts()Gets the value as an array of ints. This method should be used for tags
of type {@link #TYPE_UNSIGNED_SHORT}, {@link #TYPE_UNSIGNED_LONG}.
if (mValue == null) {
return null;
} else if (mValue instanceof long[]) {
long[] val = (long[]) mValue;
int[] arr = new int[val.length];
for (int i = 0; i < val.length; i++) {
arr[i] = (int) val[i]; // Truncates
}
return arr;
}
return null;
|
| public long | getValueAsLong(long defaultValue)Gets the value or null if none exists. If there are more than 1 longs in
this value, gets the first one. This method should be used for tags of
type {@link #TYPE_UNSIGNED_LONG}.
long[] l = getValueAsLongs();
if (l == null || l.length < 1) {
return defaultValue;
}
return l[0];
|
| public long[] | getValueAsLongs()Gets the value as an array of longs. This method should be used for tags
of type {@link #TYPE_UNSIGNED_LONG}.
if (mValue instanceof long[]) {
return (long[]) mValue;
}
return null;
|
| public Rational | getValueAsRational(Rational defaultValue)Gets the value as a Rational. If there are more than 1 Rationals in this
value, gets the first one. This method should be used for tags of type
{@link #TYPE_RATIONAL} or {@link #TYPE_UNSIGNED_RATIONAL}.
Rational[] r = getValueAsRationals();
if (r == null || r.length < 1) {
return defaultValue;
}
return r[0];
|
| public Rational | getValueAsRational(long defaultValue)Gets the value as a Rational. If there are more than 1 Rationals in this
value, gets the first one. This method should be used for tags of type
{@link #TYPE_RATIONAL} or {@link #TYPE_UNSIGNED_RATIONAL}.
Rational defaultVal = new Rational(defaultValue, 1);
return getValueAsRational(defaultVal);
|
| public Rational[] | getValueAsRationals()Gets the value as an array of Rationals. This method should be used for
tags of type {@link #TYPE_RATIONAL} or {@link #TYPE_UNSIGNED_RATIONAL}.
if (mValue instanceof Rational[]) {
return (Rational[]) mValue;
}
return null;
|
| public java.lang.String | getValueAsString()Gets the value as a String. This method should be used for tags of type
{@link #TYPE_ASCII}.
if (mValue == null) {
return null;
} else if (mValue instanceof String) {
return (String) mValue;
} else if (mValue instanceof byte[]) {
return new String((byte[]) mValue, US_ASCII);
}
return null;
|
| public java.lang.String | getValueAsString(java.lang.String defaultValue)Gets the value as a String. This method should be used for tags of type
{@link #TYPE_ASCII}.
String s = getValueAsString();
if (s == null) {
return defaultValue;
}
return s;
|
| protected long | getValueAt(int index)Gets the value for type {@link #TYPE_ASCII}, {@link #TYPE_LONG},
{@link #TYPE_UNDEFINED}, {@link #TYPE_UNSIGNED_BYTE},
{@link #TYPE_UNSIGNED_LONG}, or {@link #TYPE_UNSIGNED_SHORT}. For
{@link #TYPE_RATIONAL} or {@link #TYPE_UNSIGNED_RATIONAL}, call
{@link #getRational(int)} instead.
if (mValue instanceof long[]) {
return ((long[]) mValue)[index];
} else if (mValue instanceof byte[]) {
return ((byte[]) mValue)[index];
}
throw new IllegalArgumentException("Cannot get integer value from "
+ convertTypeToString(mDataType));
|
| protected boolean | hasDefinedCount()
return mHasDefinedDefaultComponentCount;
|
| public boolean | hasValue()Returns true if this ExifTag contains value; otherwise, this tag will
contain an offset value that is determined when the tag is written.
return mValue != null;
|
| public static boolean | isValidIfd(int ifdId)Returns true if the given IFD is a valid IFD.
return ifdId == IfdId.TYPE_IFD_0 || ifdId == IfdId.TYPE_IFD_1
|| ifdId == IfdId.TYPE_IFD_EXIF || ifdId == IfdId.TYPE_IFD_INTEROPERABILITY
|| ifdId == IfdId.TYPE_IFD_GPS;
|
| public static boolean | isValidType(short type)Returns true if a given type is a valid tag type.
return type == TYPE_UNSIGNED_BYTE || type == TYPE_ASCII ||
type == TYPE_UNSIGNED_SHORT || type == TYPE_UNSIGNED_LONG ||
type == TYPE_UNSIGNED_RATIONAL || type == TYPE_UNDEFINED ||
type == TYPE_LONG || type == TYPE_RATIONAL;
|
| protected void | setHasDefinedCount(boolean d)
mHasDefinedDefaultComponentCount = d;
|
| protected void | setIfd(int ifdId)
mIfd = ifdId;
|
| protected void | setOffset(int offset)Sets the offset of this tag.
mOffset = offset;
|
| public boolean | setTimeValue(long time)Sets a timestamp to this tag. The method converts the timestamp with the
format of "yyyy:MM:dd kk:mm:ss" and calls {@link #setValue(String)}. This
method will fail if the data type is not {@link #TYPE_ASCII} or the
component count of this tag is not 20 or undefined.
// synchronized on TIME_FORMAT as SimpleDateFormat is not thread safe
synchronized (TIME_FORMAT) {
return setValue(TIME_FORMAT.format(new Date(time)));
}
|
| public boolean | setValue(int[] value)Sets integer values into this tag. This method should be used for tags of
type {@link #TYPE_UNSIGNED_SHORT}. This method will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_SHORT},
{@link #TYPE_UNSIGNED_LONG}, or {@link #TYPE_LONG}.
- The value overflows.
- The value.length does NOT match the component count in the definition
for this tag.
if (checkBadComponentCount(value.length)) {
return false;
}
if (mDataType != TYPE_UNSIGNED_SHORT && mDataType != TYPE_LONG &&
mDataType != TYPE_UNSIGNED_LONG) {
return false;
}
if (mDataType == TYPE_UNSIGNED_SHORT && checkOverflowForUnsignedShort(value)) {
return false;
} else if (mDataType == TYPE_UNSIGNED_LONG && checkOverflowForUnsignedLong(value)) {
return false;
}
long[] data = new long[value.length];
for (int i = 0; i < value.length; i++) {
data[i] = value[i];
}
mValue = data;
mComponentCountActual = value.length;
return true;
|
| public boolean | setValue(int value)Sets integer value into this tag. This method should be used for tags of
type {@link #TYPE_UNSIGNED_SHORT}, or {@link #TYPE_LONG}. This method
will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_SHORT},
{@link #TYPE_UNSIGNED_LONG}, or {@link #TYPE_LONG}.
- The value overflows.
- The component count in the definition of this tag is not 1.
return setValue(new int[] {
value
});
|
| public boolean | setValue(long[] value)Sets long values into this tag. This method should be used for tags of
type {@link #TYPE_UNSIGNED_LONG}. This method will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_LONG}.
- The value overflows.
- The value.length does NOT match the component count in the definition
for this tag.
if (checkBadComponentCount(value.length) || mDataType != TYPE_UNSIGNED_LONG) {
return false;
}
if (checkOverflowForUnsignedLong(value)) {
return false;
}
mValue = value;
mComponentCountActual = value.length;
return true;
|
| public boolean | setValue(long value)Sets long values into this tag. This method should be used for tags of
type {@link #TYPE_UNSIGNED_LONG}. This method will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_LONG}.
- The value overflows.
- The component count in the definition for this tag is not 1.
return setValue(new long[] {
value
});
|
| public boolean | setValue(java.lang.String value)Sets a string value into this tag. This method should be used for tags of
type {@link #TYPE_ASCII}. The string is converted to an ASCII string.
Characters that cannot be converted are replaced with '?'. The length of
the string must be equal to either (component count -1) or (component
count). The final byte will be set to the string null terminator '\0',
overwriting the last character in the string if the value.length is equal
to the component count. This method will fail if:
- The data type is not {@link #TYPE_ASCII} or {@link #TYPE_UNDEFINED}.
- The length of the string is not equal to (component count -1) or
(component count) in the definition for this tag.
if (mDataType != TYPE_ASCII && mDataType != TYPE_UNDEFINED) {
return false;
}
byte[] buf = value.getBytes(US_ASCII);
byte[] finalBuf = buf;
if (buf.length > 0) {
finalBuf = (buf[buf.length - 1] == 0 || mDataType == TYPE_UNDEFINED) ? buf : Arrays
.copyOf(buf, buf.length + 1);
} else if (mDataType == TYPE_ASCII && mComponentCountActual == 1) {
finalBuf = new byte[] { 0 };
}
int count = finalBuf.length;
if (checkBadComponentCount(count)) {
return false;
}
mComponentCountActual = count;
mValue = finalBuf;
return true;
|
| public boolean | setValue(Rational[] value)Sets Rational values into this tag. This method should be used for tags
of type {@link #TYPE_UNSIGNED_RATIONAL}, or {@link #TYPE_RATIONAL}. This
method will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_RATIONAL}
or {@link #TYPE_RATIONAL}.
- The value overflows.
- The value.length does NOT match the component count in the definition
for this tag.
if (checkBadComponentCount(value.length)) {
return false;
}
if (mDataType != TYPE_UNSIGNED_RATIONAL && mDataType != TYPE_RATIONAL) {
return false;
}
if (mDataType == TYPE_UNSIGNED_RATIONAL && checkOverflowForUnsignedRational(value)) {
return false;
} else if (mDataType == TYPE_RATIONAL && checkOverflowForRational(value)) {
return false;
}
mValue = value;
mComponentCountActual = value.length;
return true;
|
| public boolean | setValue(Rational value)Sets a Rational value into this tag. This method should be used for tags
of type {@link #TYPE_UNSIGNED_RATIONAL}, or {@link #TYPE_RATIONAL}. This
method will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_RATIONAL}
or {@link #TYPE_RATIONAL}.
- The value overflows.
- The component count in the definition for this tag is not 1.
return setValue(new Rational[] {
value
});
|
| public boolean | setValue(byte[] value, int offset, int length)Sets byte values into this tag. This method should be used for tags of
type {@link #TYPE_UNSIGNED_BYTE} or {@link #TYPE_UNDEFINED}. This method
will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_BYTE} or
{@link #TYPE_UNDEFINED} .
- The length does NOT match the component count in the definition for
this tag.
if (checkBadComponentCount(length)) {
return false;
}
if (mDataType != TYPE_UNSIGNED_BYTE && mDataType != TYPE_UNDEFINED) {
return false;
}
mValue = new byte[length];
System.arraycopy(value, offset, mValue, 0, length);
mComponentCountActual = length;
return true;
|
| public boolean | setValue(byte[] value)Equivalent to setValue(value, 0, value.length).
return setValue(value, 0, value.length);
|
| public boolean | setValue(byte value)Sets byte value into this tag. This method should be used for tags of
type {@link #TYPE_UNSIGNED_BYTE} or {@link #TYPE_UNDEFINED}. This method
will fail if:
- The component type of this tag is not {@link #TYPE_UNSIGNED_BYTE} or
{@link #TYPE_UNDEFINED} .
- The component count in the definition for this tag is not 1.
return setValue(new byte[] {
value
});
|
| public boolean | setValue(java.lang.Object obj)Sets the value for this tag using an appropriate setValue method for the
given object. This method will fail if:
- The corresponding setValue method for the class of the object passed
in would fail.
- There is no obvious way to cast the object passed in into an EXIF tag
type.
if (obj == null) {
return false;
} else if (obj instanceof Short) {
return setValue(((Short) obj).shortValue() & 0x0ffff);
} else if (obj instanceof String) {
return setValue((String) obj);
} else if (obj instanceof int[]) {
return setValue((int[]) obj);
} else if (obj instanceof long[]) {
return setValue((long[]) obj);
} else if (obj instanceof Rational) {
return setValue((Rational) obj);
} else if (obj instanceof Rational[]) {
return setValue((Rational[]) obj);
} else if (obj instanceof byte[]) {
return setValue((byte[]) obj);
} else if (obj instanceof Integer) {
return setValue(((Integer) obj).intValue());
} else if (obj instanceof Long) {
return setValue(((Long) obj).longValue());
} else if (obj instanceof Byte) {
return setValue(((Byte) obj).byteValue());
} else if (obj instanceof Short[]) {
// Nulls in this array are treated as zeroes.
Short[] arr = (Short[]) obj;
int[] fin = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
fin[i] = (arr[i] == null) ? 0 : arr[i].shortValue() & 0x0ffff;
}
return setValue(fin);
} else if (obj instanceof Integer[]) {
// Nulls in this array are treated as zeroes.
Integer[] arr = (Integer[]) obj;
int[] fin = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
fin[i] = (arr[i] == null) ? 0 : arr[i].intValue();
}
return setValue(fin);
} else if (obj instanceof Long[]) {
// Nulls in this array are treated as zeroes.
Long[] arr = (Long[]) obj;
long[] fin = new long[arr.length];
for (int i = 0; i < arr.length; i++) {
fin[i] = (arr[i] == null) ? 0 : arr[i].longValue();
}
return setValue(fin);
} else if (obj instanceof Byte[]) {
// Nulls in this array are treated as zeroes.
Byte[] arr = (Byte[]) obj;
byte[] fin = new byte[arr.length];
for (int i = 0; i < arr.length; i++) {
fin[i] = (arr[i] == null) ? 0 : arr[i].byteValue();
}
return setValue(fin);
} else {
return false;
}
|
| public java.lang.String | toString()
return String.format("tag id: %04X\n", mTagId) + "ifd id: " + mIfd + "\ntype: "
+ convertTypeToString(mDataType) + "\ncount: " + mComponentCountActual
+ "\noffset: " + mOffset + "\nvalue: " + forceGetValueAsString() + "\n";
|
