Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

camera2: Update native<->managed camera metadata marshalers

Browse Source 
* Improve existing marshalers:
 - each managed/native type combination can be queried marshal support
 - marshalers can recursively call other marshalers for nested types
 - support marshaling/unmarshaling generic classes by using super type tokens

* Add new marshalers for:
 - ColorSpaceTransform
 - MeteringRectangle
 - Parcelable
 - Range<T>
 - ReprocessFormatsMap
 - RggbChannelVector
 - SizeF
 - StreamConfiguration
 - StreamConfigurationDuration

Batteries included; so are unit tests.

Bug: 14628001
Change-Id: I38d3e646ccfb3953898cd6f750c33e4097328482
This commit is contained in:
Igor Murashkin
2014-04-22 15:05:50 -07:00
parent bee74c2b47
commit 3c40a046cf
48 changed files with 3981 additions and 747 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
core/java/android/hardware/camera2/CameraMetadata.java
View File

@@ -17,6 +17,7 @@
package android.hardware.camera2;
import android.hardware.camera2.impl.CameraMetadataNative;
import android.hardware.camera2.utils.TypeReference;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
@@ -126,11 +127,13 @@ public abstract class CameraMetadata {
return keyList;
}
// TODO: make final or abstract
public static class Key<T> {
private boolean mHasTag;
private int mTag;
private final Class<T> mType;
private final TypeReference<T> mTypeReference;
private final String mName;
/**
@@ -144,6 +147,22 @@ public abstract class CameraMetadata {
}
mName = name;
mType = type;
mTypeReference = TypeReference.createSpecializedTypeReference(type);
}
/**
* @hide
*/
@SuppressWarnings("unchecked")
public Key(String name, TypeReference<T> typeReference) {
if (name == null) {
throw new NullPointerException("Key needs a valid name");
} else if (typeReference == null) {
throw new NullPointerException("TypeReference needs to be non-null");
}
mName = name;
mType = (Class<T>)typeReference.getRawType();
mTypeReference = typeReference;
}
public final String getName() {
@@ -152,11 +171,10 @@ public abstract class CameraMetadata {
@Override
public final int hashCode() {
return mName.hashCode();
return mName.hashCode() ^ mTypeReference.hashCode();
}
@Override
@SuppressWarnings("unchecked")
public final boolean equals(Object o) {
if (this == o) {
return true;
@@ -166,9 +184,8 @@ public abstract class CameraMetadata {
return false;
}
Key lhs = (Key) o;
return mName.equals(lhs.mName) && mType.equals(lhs.mType);
Key<?> lhs = (Key<?>)o;
return mName.equals(lhs.mName) && mTypeReference.equals(lhs.mTypeReference);
}
/**
@@ -192,11 +209,29 @@ public abstract class CameraMetadata {
}
/**
* Get the raw class backing the type {@code T} for this key.
*
* <p>The distinction is only important if {@code T} is a generic, e.g.
* {@code Range<Integer>} since the nested type will be erased.</p>
*
* @hide
*/
public final Class<T> getType() {
// TODO: remove this; other places should use #getTypeReference() instead
return mType;
}
/**
* Get the type reference backing the type {@code T} for this key.
*
* <p>The distinction is only important if {@code T} is a generic, e.g.
* {@code Range<Integer>} since the nested type will be retained.</p>
*
* @hide
*/
public final TypeReference<T> getTypeReference() {
return mTypeReference;
}
}
/*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~

3
core/java/android/hardware/camera2/ColorSpaceTransform.java
View File

@@ -17,7 +17,8 @@
package android.hardware.camera2;
import static com.android.internal.util.Preconditions.*;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
import java.util.Arrays;

2
core/java/android/hardware/camera2/LensShadingMap.java
View File

@@ -19,7 +19,7 @@ package android.hardware.camera2;
import static com.android.internal.util.Preconditions.*;
import static android.hardware.camera2.RggbChannelVector.*;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
import java.util.Arrays;

7
core/java/android/hardware/camera2/MeteringRectangle.java
View File

@@ -20,7 +20,7 @@ import static com.android.internal.util.Preconditions.*;
import android.graphics.Point;
import android.graphics.Rect;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
/**
* An immutable class to represent a rectangle {@code (x,y, width, height)} with an
@@ -186,10 +186,7 @@ public final class MeteringRectangle {
*/
@Override
public boolean equals(final Object other) {
if (other instanceof MeteringRectangle) {
return equals(other);
}
return false;
return other instanceof MeteringRectangle && equals((MeteringRectangle)other);
}
/**

17
core/java/android/hardware/camera2/Rational.java
View File

@@ -91,14 +91,14 @@ public final class Rational {
* <p>A reduced form of a Rational is calculated by dividing both the numerator and the
* denominator by their greatest common divisor.</p>
*
* <pre>
* <pre>{@code
* (new Rational(1, 2)).equals(new Rational(1, 2)) == true // trivially true
* (new Rational(2, 3)).equals(new Rational(1, 2)) == false // trivially false
* (new Rational(1, 2)).equals(new Rational(2, 4)) == true // true after reduction
* (new Rational(0, 0)).equals(new Rational(0, 0)) == true // NaN.equals(NaN)
* (new Rational(1, 0)).equals(new Rational(5, 0)) == true // both are +infinity
* (new Rational(1, 0)).equals(new Rational(-1, 0)) == false // +infinity != -infinity
* </pre>
* }</pre>
*
* @param obj a reference to another object
*
@@ -159,16 +159,15 @@ public final class Rational {
return (float) mNumerator / (float) mDenominator;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
final long INT_MASK = 0xffffffffL;
// Bias the hash code for the first (2^16) values for both numerator and denominator
int numeratorFlipped = mNumerator << 16 | mNumerator >>> 16;
long asLong = INT_MASK & mNumerator;
asLong <<= 32;
asLong |= (INT_MASK & mDenominator);
return ((Long)asLong).hashCode();
return mDenominator ^ numeratorFlipped;
}
/**

2
core/java/android/hardware/camera2/ReprocessFormatsMap.java
View File

@@ -18,7 +18,7 @@ package android.hardware.camera2;
import static com.android.internal.util.Preconditions.*;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
import java.util.Arrays;

4
core/java/android/hardware/camera2/StreamConfiguration.java
View File

@@ -20,7 +20,7 @@ import static com.android.internal.util.Preconditions.*;
import static android.hardware.camera2.StreamConfigurationMap.checkArgumentFormatInternal;
import android.graphics.ImageFormat;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
import android.util.Size;
/**
@@ -57,7 +57,7 @@ public final class StreamConfiguration {
final int format, final int width, final int height, final boolean input) {
mFormat = checkArgumentFormatInternal(format);
mWidth = checkArgumentPositive(width, "width must be positive");
mHeight = checkArgumentPositive(width, "height must be positive");
mHeight = checkArgumentPositive(height, "height must be positive");
mInput = input;
}

4
core/java/android/hardware/camera2/StreamConfigurationDuration.java
View File

@@ -20,7 +20,7 @@ import static com.android.internal.util.Preconditions.*;
import static android.hardware.camera2.StreamConfigurationMap.checkArgumentFormatInternal;
import android.graphics.ImageFormat;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
import android.util.Size;
/**
@@ -54,7 +54,7 @@ public final class StreamConfigurationDuration {
final int format, final int width, final int height, final long durationNs) {
mFormat = checkArgumentFormatInternal(format);
mWidth = checkArgumentPositive(width, "width must be positive");
mHeight = checkArgumentPositive(width, "height must be positive");
mHeight = checkArgumentPositive(height, "height must be positive");
mDurationNs = checkArgumentNonnegative(durationNs, "durationNs must be non-negative");
}

2
core/java/android/hardware/camera2/StreamConfigurationMap.java
View File

@@ -18,7 +18,7 @@ package android.hardware.camera2;
import android.graphics.ImageFormat;
import android.graphics.PixelFormat;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
import android.view.Surface;
import android.util.Size;

2
core/java/android/hardware/camera2/TonemapCurve.java
View File

@@ -19,7 +19,7 @@ package android.hardware.camera2;
import static com.android.internal.util.Preconditions.*;
import android.graphics.PointF;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
import java.util.Arrays;

461
core/java/android/hardware/camera2/impl/CameraMetadataNative.java
View File

@@ -23,16 +23,33 @@ import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraMetadata;
import android.hardware.camera2.CaptureResult;
import android.hardware.camera2.Face;
import android.hardware.camera2.Rational;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.marshal.MarshalRegistry;
import android.hardware.camera2.marshal.impl.MarshalQueryableArray;
import android.hardware.camera2.marshal.impl.MarshalQueryableBoolean;
import android.hardware.camera2.marshal.impl.MarshalQueryableColorSpaceTransform;
import android.hardware.camera2.marshal.impl.MarshalQueryableEnum;
import android.hardware.camera2.marshal.impl.MarshalQueryableMeteringRectangle;
import android.hardware.camera2.marshal.impl.MarshalQueryableNativeByteToInteger;
import android.hardware.camera2.marshal.impl.MarshalQueryableParcelable;
import android.hardware.camera2.marshal.impl.MarshalQueryablePrimitive;
import android.hardware.camera2.marshal.impl.MarshalQueryableRange;
import android.hardware.camera2.marshal.impl.MarshalQueryableRect;
import android.hardware.camera2.marshal.impl.MarshalQueryableReprocessFormatsMap;
import android.hardware.camera2.marshal.impl.MarshalQueryableRggbChannelVector;
import android.hardware.camera2.marshal.impl.MarshalQueryableSize;
import android.hardware.camera2.marshal.impl.MarshalQueryableSizeF;
import android.hardware.camera2.marshal.impl.MarshalQueryableStreamConfiguration;
import android.hardware.camera2.marshal.impl.MarshalQueryableStreamConfigurationDuration;
import android.hardware.camera2.marshal.impl.MarshalQueryableString;
import android.os.Parcelable;
import android.os.Parcel;
import android.util.Log;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.HashMap;
/**
* Implementation of camera metadata marshal/unmarshal across Binder to
@@ -89,7 +106,6 @@ public class CameraMetadataNative extends CameraMetadata implements Parcelable {
nativeWriteToParcel(dest);
}
@SuppressWarnings("unchecked")
@Override
public <T> T get(Key<T> key) {
T value = getOverride(key);
@@ -169,275 +185,6 @@ public class CameraMetadataNative extends CameraMetadata implements Parcelable {
mMetadataPtr = 0; // set it to 0 again to prevent eclipse from making this field final
}
private static int getTypeSize(int nativeType) {
switch(nativeType) {
case TYPE_BYTE:
return 1;
case TYPE_INT32:
case TYPE_FLOAT:
return 4;
case TYPE_INT64:
case TYPE_DOUBLE:
case TYPE_RATIONAL:
return 8;
}
throw new UnsupportedOperationException("Unknown type, can't get size "
+ nativeType);
}
private static Class<?> getExpectedType(int nativeType) {
switch(nativeType) {
case TYPE_BYTE:
return Byte.TYPE;
case TYPE_INT32:
return Integer.TYPE;
case TYPE_FLOAT:
return Float.TYPE;
case TYPE_INT64:
return Long.TYPE;
case TYPE_DOUBLE:
return Double.TYPE;
case TYPE_RATIONAL:
return Rational.class;
}
throw new UnsupportedOperationException("Unknown type, can't map to Java type "
+ nativeType);
}
@SuppressWarnings("unchecked")
private static <T> int packSingleNative(T value, ByteBuffer buffer, Class<T> type,
int nativeType, boolean sizeOnly) {
if (!sizeOnly) {
/**
* Rewrite types when the native type doesn't match the managed type
* - Boolean -> Byte
* - Integer -> Byte
*/
if (nativeType == TYPE_BYTE && type == Boolean.TYPE) {
// Since a boolean can't be cast to byte, and we don't want to use putBoolean
boolean asBool = (Boolean) value;
byte asByte = (byte) (asBool ? 1 : 0);
value = (T) (Byte) asByte;
} else if (nativeType == TYPE_BYTE && type == Integer.TYPE) {
int asInt = (Integer) value;
byte asByte = (byte) asInt;
value = (T) (Byte) asByte;
} else if (type != getExpectedType(nativeType)) {
throw new UnsupportedOperationException("Tried to pack a type of " + type +
" but we expected the type to be " + getExpectedType(nativeType));
}
if (nativeType == TYPE_BYTE) {
buffer.put((Byte) value);
} else if (nativeType == TYPE_INT32) {
buffer.putInt((Integer) value);
} else if (nativeType == TYPE_FLOAT) {
buffer.putFloat((Float) value);
} else if (nativeType == TYPE_INT64) {
buffer.putLong((Long) value);
} else if (nativeType == TYPE_DOUBLE) {
buffer.putDouble((Double) value);
} else if (nativeType == TYPE_RATIONAL) {
Rational r = (Rational) value;
buffer.putInt(r.getNumerator());
buffer.putInt(r.getDenominator());
}
}
return getTypeSize(nativeType);
}
@SuppressWarnings({"unchecked", "rawtypes"})
private static <T> int packSingle(T value, ByteBuffer buffer, Class<T> type, int nativeType,
boolean sizeOnly) {
int size = 0;
if (type.isPrimitive() || type == Rational.class) {
size = packSingleNative(value, buffer, type, nativeType, sizeOnly);
} else if (type.isEnum()) {
size = packEnum((Enum)value, buffer, (Class<Enum>)type, nativeType, sizeOnly);
} else if (type.isArray()) {
size = packArray(value, buffer, type, nativeType, sizeOnly);
} else {
size = packClass(value, buffer, type, nativeType, sizeOnly);
}
return size;
}
private static <T extends Enum<T>> int packEnum(T value, ByteBuffer buffer, Class<T> type,
int nativeType, boolean sizeOnly) {
// TODO: add support for enums with their own values.
return packSingleNative(getEnumValue(value), buffer, Integer.TYPE, nativeType, sizeOnly);
}
@SuppressWarnings("unchecked")
private static <T> int packClass(T value, ByteBuffer buffer, Class<T> type, int nativeType,
boolean sizeOnly) {
MetadataMarshalClass<T> marshaler = getMarshaler(type, nativeType);
if (marshaler == null) {
throw new IllegalArgumentException(String.format("Unknown Key type: %s", type));
}
return marshaler.marshal(value, buffer, nativeType, sizeOnly);
}
private static <T> int packArray(T value, ByteBuffer buffer, Class<T> type, int nativeType,
boolean sizeOnly) {
int size = 0;
int arrayLength = Array.getLength(value);
@SuppressWarnings("unchecked")
Class<Object> componentType = (Class<Object>)type.getComponentType();
for (int i = 0; i < arrayLength; ++i) {
size += packSingle(Array.get(value, i), buffer, componentType, nativeType, sizeOnly);
}
return size;
}
@SuppressWarnings("unchecked")
private static <T> T unpackSingleNative(ByteBuffer buffer, Class<T> type, int nativeType) {
T val;
if (nativeType == TYPE_BYTE) {
val = (T) (Byte) buffer.get();
} else if (nativeType == TYPE_INT32) {
val = (T) (Integer) buffer.getInt();
} else if (nativeType == TYPE_FLOAT) {
val = (T) (Float) buffer.getFloat();
} else if (nativeType == TYPE_INT64) {
val = (T) (Long) buffer.getLong();
} else if (nativeType == TYPE_DOUBLE) {
val = (T) (Double) buffer.getDouble();
} else if (nativeType == TYPE_RATIONAL) {
val = (T) new Rational(buffer.getInt(), buffer.getInt());
} else {
throw new UnsupportedOperationException("Unknown type, can't unpack a native type "
+ nativeType);
}
/**
* Rewrite types when the native type doesn't match the managed type
* - Byte -> Boolean
* - Byte -> Integer
*/
if (nativeType == TYPE_BYTE && type == Boolean.TYPE) {
// Since a boolean can't be cast to byte, and we don't want to use getBoolean
byte asByte = (Byte) val;
boolean asBool = asByte != 0;
val = (T) (Boolean) asBool;
} else if (nativeType == TYPE_BYTE && type == Integer.TYPE) {
byte asByte = (Byte) val;
int asInt = asByte;
val = (T) (Integer) asInt;
} else if (type != getExpectedType(nativeType)) {
throw new UnsupportedOperationException("Tried to unpack a type of " + type +
" but we expected the type to be " + getExpectedType(nativeType));
}
return val;
}
@SuppressWarnings({"unchecked", "rawtypes"})
private static <T> T unpackSingle(ByteBuffer buffer, Class<T> type, int nativeType) {
if (type.isPrimitive() || type == Rational.class) {
return unpackSingleNative(buffer, type, nativeType);
}
if (type.isEnum()) {
return (T) unpackEnum(buffer, (Class<Enum>)type, nativeType);
}
if (type.isArray()) {
return unpackArray(buffer, type, nativeType);
}
T instance = unpackClass(buffer, type, nativeType);
return instance;
}
private static <T extends Enum<T>> T unpackEnum(ByteBuffer buffer, Class<T> type,
int nativeType) {
int ordinal = unpackSingleNative(buffer, Integer.TYPE, nativeType);
return getEnumFromValue(type, ordinal);
}
private static <T> T unpackClass(ByteBuffer buffer, Class<T> type, int nativeType) {
MetadataMarshalClass<T> marshaler = getMarshaler(type, nativeType);
if (marshaler == null) {
throw new IllegalArgumentException("Unknown class type: " + type);
}
return marshaler.unmarshal(buffer, nativeType);
}
@SuppressWarnings("unchecked")
private static <T> T unpackArray(ByteBuffer buffer, Class<T> type, int nativeType) {
Class<?> componentType = type.getComponentType();
Object array;
int elementSize = getTypeSize(nativeType);
MetadataMarshalClass<?> marshaler = getMarshaler(componentType, nativeType);
if (marshaler != null) {
elementSize = marshaler.getNativeSize(nativeType);
}
if (elementSize != MetadataMarshalClass.NATIVE_SIZE_DYNAMIC) {
int remaining = buffer.remaining();
int arraySize = remaining / elementSize;
if (VERBOSE) {
Log.v(TAG,
String.format(
"Attempting to unpack array (count = %d, element size = %d, bytes " +
"remaining = %d) for type %s",
arraySize, elementSize, remaining, type));
}
array = Array.newInstance(componentType, arraySize);
for (int i = 0; i < arraySize; ++i) {
Object elem = unpackSingle(buffer, componentType, nativeType);
Array.set(array, i, elem);
}
} else {
// Dynamic size, use an array list.
ArrayList<Object> arrayList = new ArrayList<Object>();
int primitiveSize = getTypeSize(nativeType);
while (buffer.remaining() >= primitiveSize) {
Object elem = unpackSingle(buffer, componentType, nativeType);
arrayList.add(elem);
}
array = arrayList.toArray((T[]) Array.newInstance(componentType, 0));
}
if (buffer.remaining() != 0) {
Log.e(TAG, "Trailing bytes (" + buffer.remaining() + ") left over after unpacking "
+ type);
}
return (T) array;
}
private <T> T getBase(Key<T> key) {
int tag = key.getTag();
byte[] values = readValues(tag);
@@ -445,10 +192,9 @@ public class CameraMetadataNative extends CameraMetadata implements Parcelable {
return null;
}
int nativeType = getNativeType(tag);
Marshaler<T> marshaler = getMarshalerForKey(key);
ByteBuffer buffer = ByteBuffer.wrap(values).order(ByteOrder.nativeOrder());
return unpackSingle(buffer, key.getType(), nativeType);
return marshaler.unmarshal(buffer);
}
// Need overwrite some metadata that has different definitions between native
@@ -632,19 +378,19 @@ public class CameraMetadataNative extends CameraMetadata implements Parcelable {
int tag = key.getTag();
if (value == null) {
writeValues(tag, null);
// Erase the entry
writeValues(tag, /*src*/null);
return;
}
} // else update the entry to a new value
int nativeType = getNativeType(tag);
int size = packSingle(value, null, key.getType(), nativeType, /* sizeOnly */true);
Marshaler<T> marshaler = getMarshalerForKey(key);
int size = marshaler.calculateMarshalSize(value);
// TODO: Optimization. Cache the byte[] and reuse if the size is big enough.
byte[] values = new byte[size];
ByteBuffer buffer = ByteBuffer.wrap(values).order(ByteOrder.nativeOrder());
packSingle(value, buffer, key.getType(), nativeType, /*sizeOnly*/false);
marshaler.marshal(value, buffer);
writeValues(tag, values);
}
@@ -870,125 +616,64 @@ public class CameraMetadataNative extends CameraMetadata implements Parcelable {
}
}
private static final HashMap<Class<? extends Enum>, int[]> sEnumValues =
new HashMap<Class<? extends Enum>, int[]>();
/**
* Register a non-sequential set of values to be used with the pack/unpack functions.
* This enables get/set to correctly marshal the enum into a value that is C-compatible.
* Get the marshaler compatible with the {@code key} and type {@code T}.
*
* @param enumType The class for an enum
* @param values A list of values mapping to the ordinals of the enum
*
* @hide
* @throws UnsupportedOperationException
* if the native/managed type combination for {@code key} is not supported
*/
public static <T extends Enum<T>> void registerEnumValues(Class<T> enumType, int[] values) {
if (enumType.getEnumConstants().length != values.length) {
throw new IllegalArgumentException(
"Expected values array to be the same size as the enumTypes values "
+ values.length + " for type " + enumType);
}
if (VERBOSE) {
Log.v(TAG, "Registered enum values for type " + enumType + " values");
}
sEnumValues.put(enumType, values);
private static <T> Marshaler<T> getMarshalerForKey(Key<T> key) {
return MarshalRegistry.getMarshaler(key.getTypeReference(),
getNativeType(key.getTag()));
}
/**
* Get the numeric value from an enum. This is usually the same as the ordinal value for
* enums that have fully sequential values, although for C-style enums the range of values
* may not map 1:1.
*
* @param enumValue Enum instance
* @return Int guaranteed to be ABI-compatible with the C enum equivalent
*/
private static <T extends Enum<T>> int getEnumValue(T enumValue) {
int[] values;
values = sEnumValues.get(enumValue.getClass());
int ordinal = enumValue.ordinal();
if (values != null) {
return values[ordinal];
}
return ordinal;
}
/**
* Finds the enum corresponding to it's numeric value. Opposite of {@link #getEnumValue} method.
*
* @param enumType Class of the enum we want to find
* @param value The numeric value of the enum
* @return An instance of the enum
*/
private static <T extends Enum<T>> T getEnumFromValue(Class<T> enumType, int value) {
int ordinal;
int[] registeredValues = sEnumValues.get(enumType);
if (registeredValues != null) {
ordinal = -1;
for (int i = 0; i < registeredValues.length; ++i) {
if (registeredValues[i] == value) {
ordinal = i;
break;
}
}
} else {
ordinal = value;
}
T[] values = enumType.getEnumConstants();
if (ordinal < 0 || ordinal >= values.length) {
throw new IllegalArgumentException(
String.format(
"Argument 'value' (%d) was not a valid enum value for type %s "
+ "(registered? %b)",
value,
enumType, (registeredValues != null)));
}
return values[ordinal];
}
static HashMap<Class<?>, MetadataMarshalClass<?>> sMarshalerMap = new
HashMap<Class<?>, MetadataMarshalClass<?>>();
private static <T> void registerMarshaler(MetadataMarshalClass<T> marshaler) {
sMarshalerMap.put(marshaler.getMarshalingClass(), marshaler);
}
@SuppressWarnings("unchecked")
private static <T> MetadataMarshalClass<T> getMarshaler(Class<T> type, int nativeType) {
MetadataMarshalClass<T> marshaler = (MetadataMarshalClass<T>) sMarshalerMap.get(type);
if (marshaler != null && !marshaler.isNativeTypeSupported(nativeType)) {
throw new UnsupportedOperationException("Unsupported type " + nativeType +
" to be marshalled to/from a " + type);
}
return marshaler;
}
/**
* We use a class initializer to allow the native code to cache some field offsets
*/
static {
nativeClassInit();
@SuppressWarnings({ "unchecked", "rawtypes" })
private static void registerAllMarshalers() {
if (VERBOSE) {
Log.v(TAG, "Shall register metadata marshalers");
}
// load built-in marshallers
registerMarshaler(new MetadataMarshalRect());
registerMarshaler(new MetadataMarshalSize());
registerMarshaler(new MetadataMarshalString());
MarshalQueryable[] queryList = new MarshalQueryable[] {
// marshalers for standard types
new MarshalQueryablePrimitive(),
new MarshalQueryableEnum(),
new MarshalQueryableArray(),
// pseudo standard types, that expand/narrow the native type into a managed type
new MarshalQueryableBoolean(),
new MarshalQueryableNativeByteToInteger(),
// marshalers for custom types
new MarshalQueryableRect(),
new MarshalQueryableSize(),
new MarshalQueryableSizeF(),
new MarshalQueryableString(),
new MarshalQueryableReprocessFormatsMap(),
new MarshalQueryableRange(),
new MarshalQueryableMeteringRectangle(),
new MarshalQueryableColorSpaceTransform(),
new MarshalQueryableStreamConfiguration(),
new MarshalQueryableStreamConfigurationDuration(),
new MarshalQueryableRggbChannelVector(),
// generic parcelable marshaler (MUST BE LAST since it has lowest priority)
new MarshalQueryableParcelable(),
};
for (MarshalQueryable query : queryList) {
MarshalRegistry.registerMarshalQueryable(query);
}
if (VERBOSE) {
Log.v(TAG, "Registered metadata marshalers");
}
}
static {
/*
* We use a class initializer to allow the native code to cache some field offsets
*/
nativeClassInit();
registerAllMarshalers();
}
}

67
core/java/android/hardware/camera2/impl/MetadataMarshalClass.java
View File

@@ -1,67 +0,0 @@
/*
* Copyright (C) 2013 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.hardware.camera2.impl;
import java.nio.ByteBuffer;
public interface MetadataMarshalClass<T> {
/**
* Marshal the specified object instance (value) into a byte buffer.
*
* @param value the value of type T that we wish to write into the byte buffer
* @param buffer the byte buffer into which the marshalled object will be written
* @param nativeType the native type, e.g.
* {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}.
* Guaranteed to be one for which isNativeTypeSupported returns true.
* @param sizeOnly if this is true, don't write to the byte buffer. calculate the size only.
* @return the size that needs to be written to the byte buffer
*/
int marshal(T value, ByteBuffer buffer, int nativeType, boolean sizeOnly);
/**
* Unmarshal a new object instance from the byte buffer.
* @param buffer the byte buffer, from which we will read the object
* @param nativeType the native type, e.g.
* {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}.
* Guaranteed to be one for which isNativeTypeSupported returns true.
* @return a new instance of type T read from the byte buffer
*/
T unmarshal(ByteBuffer buffer, int nativeType);
Class<T> getMarshalingClass();
/**
* Determines whether or not this marshaller supports this native type. Most marshallers
* will are likely to only support one type.
*
* @param nativeType the native type, e.g.
* {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}
* @return true if it supports, false otherwise
*/
boolean isNativeTypeSupported(int nativeType);
public static int NATIVE_SIZE_DYNAMIC = -1;
/**
* How many bytes T will take up if marshalled to/from nativeType
* @param nativeType the native type, e.g.
* {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}
* @return a size in bytes, or NATIVE_SIZE_DYNAMIC if the size is dynamic
*/
int getNativeSize(int nativeType);
}

67
core/java/android/hardware/camera2/impl/MetadataMarshalRect.java
View File

@@ -1,67 +0,0 @@
/*
* Copyright (C) 2013 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.hardware.camera2.impl;
import android.graphics.Rect;
import java.nio.ByteBuffer;
public class MetadataMarshalRect implements MetadataMarshalClass<Rect> {
private static final int SIZE = 16;
@Override
public int marshal(Rect value, ByteBuffer buffer, int nativeType, boolean sizeOnly) {
if (sizeOnly) {
return SIZE;
}
buffer.putInt(value.left);
buffer.putInt(value.top);
buffer.putInt(value.width());
buffer.putInt(value.height());
return SIZE;
}
@Override
public Rect unmarshal(ByteBuffer buffer, int nativeType) {
int left = buffer.getInt();
int top = buffer.getInt();
int width = buffer.getInt();
int height = buffer.getInt();
int right = left + width;
int bottom = top + height;
return new Rect(left, top, right, bottom);
}
@Override
public Class<Rect> getMarshalingClass() {
return Rect.class;
}
@Override
public boolean isNativeTypeSupported(int nativeType) {
return nativeType == CameraMetadataNative.TYPE_INT32;
}
@Override
public int getNativeSize(int nativeType) {
return SIZE;
}
}

60
core/java/android/hardware/camera2/impl/MetadataMarshalSize.java
View File

@@ -1,60 +0,0 @@
/*
* Copyright (C) 2013 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.hardware.camera2.impl;
import android.hardware.camera2.Size;
import java.nio.ByteBuffer;
public class MetadataMarshalSize implements MetadataMarshalClass<Size> {
private static final int SIZE = 8;
@Override
public int marshal(Size value, ByteBuffer buffer, int nativeType, boolean sizeOnly) {
if (sizeOnly) {
return SIZE;
}
buffer.putInt(value.getWidth());
buffer.putInt(value.getHeight());
return SIZE;
}
@Override
public Size unmarshal(ByteBuffer buffer, int nativeType) {
int width = buffer.getInt();
int height = buffer.getInt();
return new Size(width, height);
}
@Override
public Class<Size> getMarshalingClass() {
return Size.class;
}
@Override
public boolean isNativeTypeSupported(int nativeType) {
return nativeType == CameraMetadataNative.TYPE_INT32;
}
@Override
public int getNativeSize(int nativeType) {
return SIZE;
}
}

79
core/java/android/hardware/camera2/impl/MetadataMarshalString.java
View File

@@ -1,79 +0,0 @@
/*
* Copyright (C) 2013 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.hardware.camera2.impl;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
public class MetadataMarshalString implements MetadataMarshalClass<String> {
private static final Charset UTF8_CHARSET = Charset.forName("UTF-8");
@Override
public int marshal(String value, ByteBuffer buffer, int nativeType, boolean sizeOnly) {
byte[] arr = value.getBytes(UTF8_CHARSET);
if (!sizeOnly) {
buffer.put(arr);
buffer.put((byte)0); // metadata strings are NULL-terminated
}
return arr.length + 1;
}
@Override
public String unmarshal(ByteBuffer buffer, int nativeType) {
buffer.mark(); // save the current position
boolean foundNull = false;
int stringLength = 0;
while (buffer.hasRemaining()) {
if (buffer.get() == (byte)0) {
foundNull = true;
break;
}
stringLength++;
}
if (!foundNull) {
throw new IllegalArgumentException("Strings must be null-terminated");
}
buffer.reset(); // go back to the previously marked position
byte[] strBytes = new byte[stringLength + 1];
buffer.get(strBytes, /*dstOffset*/0, stringLength + 1); // including null character
// not including null character
return new String(strBytes, /*offset*/0, stringLength, UTF8_CHARSET);
}
@Override
public Class<String> getMarshalingClass() {
return String.class;
}
@Override
public boolean isNativeTypeSupported(int nativeType) {
return nativeType == CameraMetadataNative.TYPE_BYTE;
}
@Override
public int getNativeSize(int nativeType) {
return NATIVE_SIZE_DYNAMIC;
}
}

243
core/java/android/hardware/camera2/marshal/MarshalHelpers.java Normal file
View File

@@ -0,0 +1,243 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static com.android.internal.util.Preconditions.*;
import android.hardware.camera2.Rational;
import android.hardware.camera2.impl.CameraMetadataNative;
/**
* Static functions in order to help implementing various marshaler functionality.
*
* <p>The intention is to statically import everything from this file into another file when
* implementing a new marshaler (or marshal queryable).</p>
*
* <p>The helpers are centered around providing primitive knowledge of the native types,
* such as the native size, the managed class wrappers, and various precondition checks.</p>
*/
public final class MarshalHelpers {
public static final int SIZEOF_BYTE = 1;
public static final int SIZEOF_INT32 = Integer.SIZE / Byte.SIZE;
public static final int SIZEOF_INT64 = Long.SIZE / Byte.SIZE;
public static final int SIZEOF_FLOAT = Float.SIZE / Byte.SIZE;
public static final int SIZEOF_DOUBLE = Double.SIZE / Byte.SIZE;
public static final int SIZEOF_RATIONAL = SIZEOF_INT32 * 2;
/**
* Get the size in bytes for the native camera metadata type.
*
* <p>This used to determine how many bytes it would take to encode/decode a single value
* of that {@link nativeType}.</p>
*
* @param nativeType the native type, e.g.
* {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}.
* @return size in bytes >= 1
*
* @throws UnsupportedOperationException if nativeType was not one of the built-in types
*/
public static int getPrimitiveTypeSize(int nativeType) {
switch (nativeType) {
case TYPE_BYTE:
return SIZEOF_BYTE;
case TYPE_INT32:
return SIZEOF_INT32;
case TYPE_FLOAT:
return SIZEOF_FLOAT;
case TYPE_INT64:
return SIZEOF_INT64;
case TYPE_DOUBLE:
return SIZEOF_DOUBLE;
case TYPE_RATIONAL:
return SIZEOF_RATIONAL;
}
throw new UnsupportedOperationException("Unknown type, can't get size for "
+ nativeType);
}
/**
* Ensure that the {@code klass} is one of the metadata-primitive classes.
*
* @param klass a non-{@code null} reference
* @return {@code klass} instance
*
* @throws UnsupportedOperationException if klass was not one of the built-in classes
* @throws NullPointerException if klass was null
*
* @see #isPrimitiveClass
*/
public static <T> Class<T> checkPrimitiveClass(Class<T> klass) {
checkNotNull(klass, "klass must not be null");
if (isPrimitiveClass(klass)) {
return klass;
}
throw new UnsupportedOperationException("Unsupported class '" + klass +
"'; expected a metadata primitive class");
}
/**
* Checks whether or not {@code klass} is one of the metadata-primitive classes.
*
* <p>The following types (whether boxed or unboxed) are considered primitive:
* <ul>
* <li>byte
* <li>int
* <li>float
* <li>double
* <li>Rational
* </ul>
* </p>
*
* <p>This doesn't strictly follow the java understanding of primitive since
* boxed objects are included, Rational is included, and other types such as char and
* short are not included.</p>
*
* @param klass a {@link Class} instance; using {@code null} will return {@code false}
* @return {@code true} if primitive, {@code false} otherwise
*/
public static <T> boolean isPrimitiveClass(Class<T> klass) {
if (klass == null) {
return false;
}
if (klass == byte.class || klass == Byte.class) {
return true;
} else if (klass == int.class || klass == Integer.class) {
return true;
} else if (klass == float.class || klass == Float.class) {
return true;
} else if (klass == long.class || klass == Long.class) {
return true;
} else if (klass == double.class || klass == Double.class) {
return true;
} else if (klass == Rational.class) {
return true;
}
return false;
}
/**
* Wrap {@code klass} with its wrapper variant if it was a {@code Class} corresponding
* to a Java primitive.
*
* <p>Non-primitive classes are passed through as-is.</p>
*
* <p>For example, for a primitive {@code int.class => Integer.class},
* but for a non-primitive {@code Rational.class => Rational.class}.</p>
*
* @param klass a {@code Class} reference
*
* @return wrapped class object, or same class object if non-primitive
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> wrapClassIfPrimitive(Class<T> klass) {
if (klass == byte.class) {
return (Class<T>)Byte.class;
} else if (klass == int.class) {
return (Class<T>)Integer.class;
} else if (klass == float.class) {
return (Class<T>)Float.class;
} else if (klass == long.class) {
return (Class<T>)Long.class;
} else if (klass == double.class) {
return (Class<T>)Double.class;
}
return klass;
}
/**
* Return a human-readable representation of the {@code nativeType}, e.g. "TYPE_INT32"
*
* <p>Out-of-range values return a string with "UNKNOWN" as the prefix.</p>
*
* @param nativeType the native type
*
* @return human readable type name
*/
public static String toStringNativeType(int nativeType) {
switch (nativeType) {
case TYPE_BYTE:
return "TYPE_BYTE";
case TYPE_INT32:
return "TYPE_INT32";
case TYPE_FLOAT:
return "TYPE_FLOAT";
case TYPE_INT64:
return "TYPE_INT64";
case TYPE_DOUBLE:
return "TYPE_DOUBLE";
case TYPE_RATIONAL:
return "TYPE_RATIONAL";
}
return "UNKNOWN(" + nativeType + ")";
}
/**
* Ensure that the {@code nativeType} is one of the native types supported
* by {@link CameraMetadataNative}.
*
* @param nativeType the native type
*
* @return the native type
*
* @throws UnsupportedOperationException if the native type was invalid
*/
public static int checkNativeType(int nativeType) {
switch (nativeType) {
case TYPE_BYTE:
case TYPE_INT32:
case TYPE_FLOAT:
case TYPE_INT64:
case TYPE_DOUBLE:
case TYPE_RATIONAL:
return nativeType;
}
throw new UnsupportedOperationException("Unknown nativeType " + nativeType);
}
/**
* Ensure that the expected and actual native types are equal.
*
* @param expectedNativeType the expected native type
* @param actualNativeType the actual native type
* @return the actual native type
*
* @throws UnsupportedOperationException if the types are not equal
*/
public static int checkNativeTypeEquals(int expectedNativeType, int actualNativeType) {
if (expectedNativeType != actualNativeType) {
throw new UnsupportedOperationException(
String.format("Expected native type %d, but got %d",
expectedNativeType, actualNativeType));
}
return actualNativeType;
}
private MarshalHelpers() {
throw new AssertionError();
}
}

63
core/java/android/hardware/camera2/marshal/MarshalQueryable.java Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal;
import android.hardware.camera2.utils.TypeReference;
/**
* Query if a marshaler can marshal to/from a particular native and managed type; if it supports
* the combination, allow creating a marshaler instance to do the serialization.
*
* <p>Not all queryable instances will support exactly one combination. Some, such as the
* primitive queryable will support all primitive to/from managed mappings (as long as they are
* 1:1). Others, such as the rectangle queryable will only support integer to rectangle mappings.
* </p>
*
* <p>Yet some others are codependent on other queryables; e.g. array queryables might only support
* a type map for {@code T[]} if another queryable exists with support for the component type
* {@code T}.</p>
*/
public interface MarshalQueryable<T> {
/**
* Create a marshaler between the selected managed and native type.
*
* <p>This marshaler instance is only good for that specific type mapping; and will refuse
* to map other managed types, other native types, or an other combination that isn't
* this exact one.</p>
*
* @param managedType a managed type reference
* @param nativeType the native type, e.g.
* {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}
* @return
*
* @throws UnsupportedOperationException
* if {@link #isTypeMappingSupported} returns {@code false}
*/
public Marshaler<T> createMarshaler(
TypeReference<T> managedType, int nativeType);
/**
* Determine whether or not this query marshal is able to create a marshaler that will
* support the managed type and native type mapping.
*
* <p>If this returns {@code true}, then a marshaler can be instantiated by
* {@link #createMarshaler} that will marshal data to/from the native type
* from/to the managed type.</p>
*
* <p>Most marshalers are likely to only support one type map.</p>
*/
public boolean isTypeMappingSupported(TypeReference<T> managedType, int nativeType);
}

133
core/java/android/hardware/camera2/marshal/MarshalRegistry.java Normal file
View File

@@ -0,0 +1,133 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal;
import android.hardware.camera2.impl.CameraMetadataNative;
import android.hardware.camera2.utils.TypeReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* Registry of supported marshalers; add new query-able marshalers or lookup existing ones.</p>
*/
public class MarshalRegistry {
/**
* Register a marshal queryable for the managed type {@code T}.
*
* <p>Multiple marshal queryables for the same managed type {@code T} may be registered;
* this is desirable if they support different native types (e.g. marshaler 1 supports
* {@code Integer <-> TYPE_INT32}, marshaler 2 supports {@code Integer <-> TYPE_BYTE}.</p>
*
* @param queryable a non-{@code null} marshal queryable that supports marshaling {@code T}
*/
public static <T> void registerMarshalQueryable(MarshalQueryable<T> queryable) {
sRegisteredMarshalQueryables.add(queryable);
}
/**
* Lookup a marshaler between {@code T} and {@code nativeType}.
*
* <p>Marshalers are looked up in the order they were registered; earlier registered
* marshal queriers get priority.</p>
*
* @param typeToken The compile-time type reference for {@code T}
* @param nativeType The native type, e.g. {@link CameraMetadataNative#TYPE_BYTE TYPE_BYTE}
* @return marshaler a non-{@code null} marshaler that supports marshaling the type combo
*
* @throws UnsupportedOperationException If no marshaler matching the args could be found
*/
@SuppressWarnings("unchecked")
public static <T> Marshaler<T> getMarshaler(TypeReference<T> typeToken, int nativeType) {
// TODO: can avoid making a new token each time by code-genning
// the list of type tokens and native types from the keys (at the call sites)
MarshalToken<T> marshalToken = new MarshalToken<T>(typeToken, nativeType);
/*
* Marshalers are instantiated lazily once they are looked up; successive lookups
* will not instantiate new marshalers.
*/
Marshaler<T> marshaler =
(Marshaler<T>) sMarshalerMap.get(marshalToken);
if (sRegisteredMarshalQueryables.size() == 0) {
throw new AssertionError("No available query marshalers registered");
}
if (marshaler == null) {
// Query each marshaler to see if they support the native/managed type combination
for (MarshalQueryable<?> potentialMarshaler : sRegisteredMarshalQueryables) {
MarshalQueryable<T> castedPotential =
(MarshalQueryable<T>)potentialMarshaler;
if (castedPotential.isTypeMappingSupported(typeToken, nativeType)) {
marshaler = castedPotential.createMarshaler(typeToken, nativeType);
break;
}
}
}
if (marshaler == null) {
throw new UnsupportedOperationException(
"Could not find marshaler that matches the requested " +
"combination of type reference " +
typeToken + " and native type " +
MarshalHelpers.toStringNativeType(nativeType));
}
sMarshalerMap.put(marshalToken, marshaler);
return marshaler;
}
private static class MarshalToken<T> {
public MarshalToken(TypeReference<T> typeReference, int nativeType) {
this.typeReference = typeReference;
this.nativeType = nativeType;
}
final TypeReference<T> typeReference;
final int nativeType;
@Override
public boolean equals(Object other) {
if (other instanceof MarshalToken<?>) {
MarshalToken<?> otherToken = (MarshalToken<?>)other;
return typeReference.equals(otherToken.typeReference) &&
nativeType == otherToken.nativeType;
}
return false;
}
@Override
public int hashCode() {
return typeReference.hashCode() ^ nativeType;
}
}
private static List<MarshalQueryable<?>> sRegisteredMarshalQueryables =
new ArrayList<MarshalQueryable<?>>();
private static HashMap<MarshalToken<?>, Marshaler<?>> sMarshalerMap =
new HashMap<MarshalToken<?>, Marshaler<?>>();
private MarshalRegistry() {
throw new AssertionError();
}
}

148
core/java/android/hardware/camera2/marshal/Marshaler.java Normal file
View File

@@ -0,0 +1,148 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal;
import android.hardware.camera2.utils.TypeReference;
import java.nio.ByteBuffer;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import static com.android.internal.util.Preconditions.*;
/**
* Base class to marshal data to/from managed/native metadata byte buffers.
*
* <p>This class should not be created directly; an instance of it can be obtained
* using {@link MarshalQueryable#createMarshaler} for the same type {@code T} if the native type
* mapping for {@code T} {@link MarshalQueryable#isTypeMappingSupported supported}.</p>
*
* @param <T> the compile-time managed type
*/
public abstract class Marshaler<T> {
protected final TypeReference<T> mTypeReference;
protected final int mNativeType;
/**
* Instantiate a marshaler between a single managed/native type combination.
*
* <p>This particular managed/native type combination must be supported by
* {@link #isTypeMappingSupported}.</p>
*
* @param query an instance of {@link MarshalQueryable}
* @param typeReference the managed type reference
* Must be one for which {@link #isTypeMappingSupported} returns {@code true}
* @param nativeType the native type, e.g.
* {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}.
* Must be one for which {@link #isTypeMappingSupported} returns {@code true}.
*
* @throws NullPointerException if any args were {@code null}
* @throws UnsupportedOperationException if the type mapping was not supported
*/
protected Marshaler(
MarshalQueryable<T> query, TypeReference<T> typeReference, int nativeType) {
mTypeReference = checkNotNull(typeReference, "typeReference must not be null");
mNativeType = checkNativeType(nativeType);
if (!query.isTypeMappingSupported(typeReference, nativeType)) {
throw new UnsupportedOperationException(
"Unsupported type marshaling for managed type "
+ typeReference + " and native type "
+ MarshalHelpers.toStringNativeType(nativeType));
}
}
/**
* Marshal the specified object instance (value) into a byte buffer.
*
* <p>Upon completion, the {@link ByteBuffer#position()} will have advanced by
* the {@link #calculateMarshalSize marshal size} of {@code value}.</p>
*
* @param value the value of type T that we wish to write into the byte buffer
* @param buffer the byte buffer into which the marshaled object will be written
*/
public abstract void marshal(T value, ByteBuffer buffer);
/**
* Get the size in bytes for how much space would be required to write this {@code value}
* into a byte buffer using the given {@code nativeType}.
*
* <p>If the size of this {@code T} instance when serialized into a buffer is always constant,
* then this method will always return the same value (and particularly, it will return
* an equivalent value to {@link #getNativeSize()}.</p>
*
* <p>Overriding this method is a must when the size is {@link NATIVE_SIZE_DYNAMIC dynamic}.</p>
*
* @param value the value of type T that we wish to write into the byte buffer
* @return the size that would need to be written to the byte buffer
*/
public int calculateMarshalSize(T value) {
int nativeSize = getNativeSize();
if (nativeSize == NATIVE_SIZE_DYNAMIC) {
throw new AssertionError("Override this function for dynamically-sized objects");
}
return nativeSize;
}
/**
* Unmarshal a new object instance from the byte buffer into its managed type.
*
* <p>Upon completion, the {@link ByteBuffer#position()} will have advanced by
* the {@link #calculateMarshalSize marshal size} of the returned {@code T} instance.</p>
*
* @param buffer the byte buffer, from which we will read the object
* @return a new instance of type T read from the byte buffer
*/
public abstract T unmarshal(ByteBuffer buffer);
/**
* Used to denote variable-length data structures.
*
* <p>If the size is dynamic then we can't know ahead of time how big of a data structure
* to preallocate for e.g. arrays, so one object must be unmarshaled at a time.</p>
*/
public static int NATIVE_SIZE_DYNAMIC = -1;
/**
* How many bytes a single instance of {@code T} will take up if marshalled to/from
* {@code nativeType}.
*
* <p>When unmarshaling data from native to managed, the instance {@code T} is not yet
* available. If the native size is always a fixed mapping regardless of the instance of
* {@code T} (e.g. if the type is not a container of some sort), it can be used to preallocate
* containers for {@code T} to avoid resizing them.</p>
*
* <p>In particular, the array marshaler takes advantage of this (when size is not dynamic)
* to preallocate arrays of the right length when unmarshaling an array {@code T[]}.</p>
*
* @return a size in bytes, or {@link #NATIVE_SIZE_DYNAMIC} if the size is dynamic
*/
public abstract int getNativeSize();
/**
* The type reference for {@code T} for the managed type side of this marshaler.
*/
public TypeReference<T> getTypeReference() {
return mTypeReference;
}
/** The native type corresponding to this marshaler for the native side of this marshaler.*/
public int getNativeType() {
return mNativeType;
}
}

182
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableArray.java Normal file
View File

@@ -0,0 +1,182 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.marshal.MarshalRegistry;
import android.hardware.camera2.utils.TypeReference;
import android.util.Log;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal any array {@code T}.
*
* <p>To marshal any {@code T} to/from a native type, the marshaler for T to/from that native type
* also has to exist.</p>
*
* <p>{@code T} can be either a T2[] where T2 is an object type, or a P[] where P is a
* built-in primitive (e.g. int[], float[], etc).</p>
* @param <T> the type of the array (e.g. T = int[], or T = Rational[])
*/
public class MarshalQueryableArray<T> implements MarshalQueryable<T> {
private static final String TAG = MarshalQueryableArray.class.getSimpleName();
private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
private class MarshalerArray extends Marshaler<T> {
private final Class<T> mClass;
private final Marshaler<?> mComponentMarshaler;
private final Class<?> mComponentClass;
@SuppressWarnings("unchecked")
protected MarshalerArray(TypeReference<T> typeReference, int nativeType) {
super(MarshalQueryableArray.this, typeReference, nativeType);
mClass = (Class<T>)typeReference.getRawType();
TypeReference<?> componentToken = typeReference.getComponentType();
mComponentMarshaler = MarshalRegistry.getMarshaler(componentToken, mNativeType);
mComponentClass = componentToken.getRawType();
}
@Override
public void marshal(T value, ByteBuffer buffer) {
int length = Array.getLength(value);
for (int i = 0; i < length; ++i) {
marshalArrayElement(mComponentMarshaler, buffer, value, i);
}
}
@Override
public T unmarshal(ByteBuffer buffer) {
Object array;
int elementSize = mComponentMarshaler.getNativeSize();
if (elementSize != Marshaler.NATIVE_SIZE_DYNAMIC) {
int remaining = buffer.remaining();
int arraySize = remaining / elementSize;
if (remaining % elementSize != 0) {
throw new UnsupportedOperationException("Arrays for " + mTypeReference
+ " must be packed tighly into a multiple of " + elementSize
+ "; but there are " + (remaining % elementSize) + " left over bytes");
}
if (VERBOSE) {
Log.v(TAG, String.format(
"Attempting to unpack array (count = %d, element size = %d, bytes "
+ "remaining = %d) for type %s",
arraySize, elementSize, remaining, mClass));
}
array = Array.newInstance(mComponentClass, arraySize);
for (int i = 0; i < arraySize; ++i) {
Object elem = mComponentMarshaler.unmarshal(buffer);
Array.set(array, i, elem);
}
} else {
// Dynamic size, use an array list.
ArrayList<Object> arrayList = new ArrayList<Object>();
// Assumes array is packed tightly; no unused bytes allowed
while (buffer.hasRemaining()) {
Object elem = mComponentMarshaler.unmarshal(buffer);
arrayList.add(elem);
}
int arraySize = arrayList.size();
array = copyListToArray(arrayList, Array.newInstance(mComponentClass, arraySize));
}
if (buffer.remaining() != 0) {
Log.e(TAG, "Trailing bytes (" + buffer.remaining() + ") left over after unpacking "
+ mClass);
}
return mClass.cast(array);
}
@Override
public int getNativeSize() {
return NATIVE_SIZE_DYNAMIC;
}
@Override
public int calculateMarshalSize(T value) {
int elementSize = mComponentMarshaler.getNativeSize();
int arrayLength = Array.getLength(value);
if (elementSize != Marshaler.NATIVE_SIZE_DYNAMIC) {
// The fast way. Every element size is uniform.
return elementSize * arrayLength;
} else {
// The slow way. Accumulate size for each element.
int size = 0;
for (int i = 0; i < arrayLength; ++i) {
size += calculateElementMarshalSize(mComponentMarshaler, value, i);
}
return size;
}
}
/*
* Helpers to avoid compiler errors regarding types with wildcards (?)
*/
@SuppressWarnings("unchecked")
private <TElem> void marshalArrayElement(Marshaler<TElem> marshaler,
ByteBuffer buffer, Object array, int index) {
marshaler.marshal((TElem)Array.get(array, index), buffer);
}
@SuppressWarnings("unchecked")
private Object copyListToArray(ArrayList<?> arrayList, Object arrayDest) {
return arrayList.toArray((T[]) arrayDest);
}
@SuppressWarnings("unchecked")
private <TElem> int calculateElementMarshalSize(Marshaler<TElem> marshaler,
Object array, int index) {
Object elem = Array.get(array, index);
return marshaler.calculateMarshalSize((TElem) elem);
}
}
@Override
public Marshaler<T> createMarshaler(TypeReference<T> managedType, int nativeType) {
return new MarshalerArray(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<T> managedType, int nativeType) {
// support both ConcreteType[] and GenericType<ConcreteType>[]
return managedType.getRawType().isArray();
// TODO: Should this recurse deeper and check that there is
// a valid marshaler for the ConcreteType as well?
}
}

67
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableBoolean.java Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import java.nio.ByteBuffer;
/**
* Marshal booleans: TYPE_BYTE <-> boolean/Boolean
*/
public class MarshalQueryableBoolean implements MarshalQueryable<Boolean> {
private class MarshalerBoolean extends Marshaler<Boolean> {
protected MarshalerBoolean(TypeReference<Boolean> typeReference, int nativeType) {
super(MarshalQueryableBoolean.this, typeReference, nativeType);
}
@Override
public void marshal(Boolean value, ByteBuffer buffer) {
boolean unboxValue = value;
buffer.put((byte)(unboxValue ? 1 : 0));
}
@Override
public Boolean unmarshal(ByteBuffer buffer) {
return buffer.get() != 0;
}
@Override
public int getNativeSize() {
return SIZEOF_BYTE;
}
}
@Override
public Marshaler<Boolean> createMarshaler(TypeReference<Boolean> managedType,
int nativeType) {
return new MarshalerBoolean(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<Boolean> managedType, int nativeType) {
return (Boolean.class.equals(managedType.getType())
|| boolean.class.equals(managedType.getType())) && nativeType == TYPE_BYTE;
}
}

84
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableColorSpaceTransform.java Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.ColorSpaceTransform;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import java.nio.ByteBuffer;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal {@link ColorSpaceTransform} to/from {@link #TYPE_RATIONAL}
*/
public class MarshalQueryableColorSpaceTransform implements
MarshalQueryable<ColorSpaceTransform> {
private static final int ELEMENTS_INT32 = 3 * 3 * (SIZEOF_RATIONAL / SIZEOF_INT32);
private static final int SIZE = SIZEOF_INT32 * ELEMENTS_INT32;
/** rational x 3 x 3 */
private class MarshalerColorSpaceTransform extends Marshaler<ColorSpaceTransform> {
protected MarshalerColorSpaceTransform(TypeReference<ColorSpaceTransform> typeReference,
int nativeType) {
super(MarshalQueryableColorSpaceTransform.this, typeReference, nativeType);
}
@Override
public void marshal(ColorSpaceTransform value, ByteBuffer buffer) {
int[] transformAsArray = new int[ELEMENTS_INT32];
value.copyElements(transformAsArray, /*offset*/0);
for (int i = 0; i < ELEMENTS_INT32; ++i) {
buffer.putInt(transformAsArray[i]);
}
}
@Override
public ColorSpaceTransform unmarshal(ByteBuffer buffer) {
int[] transformAsArray = new int[ELEMENTS_INT32];
for (int i = 0; i < ELEMENTS_INT32; ++i) {
transformAsArray[i] = buffer.getInt();
}
return new ColorSpaceTransform(transformAsArray);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<ColorSpaceTransform> createMarshaler(
TypeReference<ColorSpaceTransform> managedType, int nativeType) {
return new MarshalerColorSpaceTransform(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(
TypeReference<ColorSpaceTransform> managedType, int nativeType) {
return nativeType == TYPE_RATIONAL &&
ColorSpaceTransform.class.equals(managedType.getType());
}
}

220
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableEnum.java Normal file
View File

@@ -0,0 +1,220 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import android.util.Log;
import java.nio.ByteBuffer;
import java.util.HashMap;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal any simple enum (0-arg constructors only) into/from either
* {@code TYPE_BYTE} or {@code TYPE_INT32}.
*
* <p>Default values of the enum are mapped to its ordinal; this can be overridden
* by providing a manual value with {@link #registerEnumValues}.</p>
* @param <T> the type of {@code Enum}
*/
public class MarshalQueryableEnum<T extends Enum<T>> implements MarshalQueryable<T> {
private static final String TAG = MarshalQueryableEnum.class.getSimpleName();
private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
private static final int UINT8_MIN = 0x0;
private static final int UINT8_MAX = (1 << Byte.SIZE) - 1;
private static final int UINT8_MASK = UINT8_MAX;
private class MarshalerEnum extends Marshaler<T> {
private final Class<T> mClass;
@SuppressWarnings("unchecked")
protected MarshalerEnum(TypeReference<T> typeReference, int nativeType) {
super(MarshalQueryableEnum.this, typeReference, nativeType);
mClass = (Class<T>)typeReference.getRawType();
}
@Override
public void marshal(T value, ByteBuffer buffer) {
int enumValue = getEnumValue(value);
if (mNativeType == TYPE_INT32) {
buffer.putInt(enumValue);
} else if (mNativeType == TYPE_BYTE) {
if (enumValue < UINT8_MIN || enumValue > UINT8_MAX) {
throw new UnsupportedOperationException(String.format(
"Enum value %x too large to fit into unsigned byte", enumValue));
}
buffer.put((byte)enumValue);
} else {
throw new AssertionError();
}
}
@Override
public T unmarshal(ByteBuffer buffer) {
int enumValue;
switch (mNativeType) {
case TYPE_INT32:
enumValue = buffer.getInt();
break;
case TYPE_BYTE:
// get the unsigned byte value; avoid sign extension
enumValue = buffer.get() & UINT8_MASK;
break;
default:
throw new AssertionError(
"Unexpected native type; impossible since its not supported");
}
return getEnumFromValue(mClass, enumValue);
}
@Override
public int getNativeSize() {
return getPrimitiveTypeSize(mNativeType);
}
}
@Override
public Marshaler<T> createMarshaler(TypeReference<T> managedType, int nativeType) {
return new MarshalerEnum(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<T> managedType, int nativeType) {
if (nativeType == TYPE_INT32 || nativeType == TYPE_BYTE) {
if (managedType.getType() instanceof Class<?>) {
Class<?> typeClass = (Class<?>)managedType.getType();
if (typeClass.isEnum()) {
if (VERBOSE) {
Log.v(TAG, "possible enum detected for " + typeClass);
}
// The enum must not take extra arguments
try {
// match a class like: "public enum Fruits { Apple, Orange; }"
typeClass.getDeclaredConstructor(String.class, int.class);
return true;
} catch (NoSuchMethodException e) {
// Skip: custom enum with a special constructor e.g. Foo(T), but need Foo()
Log.e(TAG, "Can't marshal class " + typeClass + "; no default constructor");
} catch (SecurityException e) {
// Skip: wouldn't be able to touch the enum anyway
Log.e(TAG, "Can't marshal class " + typeClass + "; not accessible");
}
}
}
}
return false;
}
@SuppressWarnings("rawtypes")
private static final HashMap<Class<? extends Enum>, int[]> sEnumValues =
new HashMap<Class<? extends Enum>, int[]>();
/**
* Register a non-sequential set of values to be used with the marshal/unmarshal functions.
*
* <p>This enables get/set to correctly marshal the enum into a value that is C-compatible.</p>
*
* @param enumType The class for an enum
* @param values A list of values mapping to the ordinals of the enum
*/
public static <T extends Enum<T>> void registerEnumValues(Class<T> enumType, int[] values) {
if (enumType.getEnumConstants().length != values.length) {
throw new IllegalArgumentException(
"Expected values array to be the same size as the enumTypes values "
+ values.length + " for type " + enumType);
}
if (VERBOSE) {
Log.v(TAG, "Registered enum values for type " + enumType + " values");
}
sEnumValues.put(enumType, values);
}
/**
* Get the numeric value from an enum.
*
* <p>This is usually the same as the ordinal value for
* enums that have fully sequential values, although for C-style enums the range of values
* may not map 1:1.</p>
*
* @param enumValue Enum instance
* @return Int guaranteed to be ABI-compatible with the C enum equivalent
*/
private static <T extends Enum<T>> int getEnumValue(T enumValue) {
int[] values;
values = sEnumValues.get(enumValue.getClass());
int ordinal = enumValue.ordinal();
if (values != null) {
return values[ordinal];
}
return ordinal;
}
/**
* Finds the enum corresponding to it's numeric value. Opposite of {@link #getEnumValue} method.
*
* @param enumType Class of the enum we want to find
* @param value The numeric value of the enum
* @return An instance of the enum
*/
private static <T extends Enum<T>> T getEnumFromValue(Class<T> enumType, int value) {
int ordinal;
int[] registeredValues = sEnumValues.get(enumType);
if (registeredValues != null) {
ordinal = -1;
for (int i = 0; i < registeredValues.length; ++i) {
if (registeredValues[i] == value) {
ordinal = i;
break;
}
}
} else {
ordinal = value;
}
T[] values = enumType.getEnumConstants();
if (ordinal < 0 || ordinal >= values.length) {
throw new IllegalArgumentException(
String.format(
"Argument 'value' (%d) was not a valid enum value for type %s "
+ "(registered? %b)",
value,
enumType, (registeredValues != null)));
}
return values[ordinal];
}
}

88
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableMeteringRectangle.java Normal file
View File

@@ -0,0 +1,88 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.MeteringRectangle;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import java.nio.ByteBuffer;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal {@link MeteringRectangle} to/from {@link #TYPE_INT32}
*/
public class MarshalQueryableMeteringRectangle implements MarshalQueryable<MeteringRectangle> {
private static final int SIZE = SIZEOF_INT32 * 5;
/** (xmin, ymin, xmax, ymax, weight) */
private class MarshalerMeteringRectangle extends Marshaler<MeteringRectangle> {
protected MarshalerMeteringRectangle(TypeReference<MeteringRectangle> typeReference,
int nativeType) {
super(MarshalQueryableMeteringRectangle.this, typeReference, nativeType);
}
@Override
public void marshal(MeteringRectangle value, ByteBuffer buffer) {
int xMin = value.getX();
int yMin = value.getY();
int xMax = xMin + value.getWidth();
int yMax = yMin + value.getHeight();
int weight = value.getMeteringWeight();
buffer.putInt(xMin);
buffer.putInt(yMin);
buffer.putInt(xMax);
buffer.putInt(yMax);
buffer.putInt(weight);
}
@Override
public MeteringRectangle unmarshal(ByteBuffer buffer) {
int xMin = buffer.getInt();
int yMin = buffer.getInt();
int xMax = buffer.getInt();
int yMax = buffer.getInt();
int weight = buffer.getInt();
int width = xMax - xMin;
int height = yMax - yMin;
return new MeteringRectangle(xMin, yMin, width, height, weight);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<MeteringRectangle> createMarshaler(
TypeReference<MeteringRectangle> managedType, int nativeType) {
return new MarshalerMeteringRectangle(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(
TypeReference<MeteringRectangle> managedType, int nativeType) {
return nativeType == TYPE_INT32 && MeteringRectangle.class.equals(managedType.getType());
}
}

70
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableNativeByteToInteger.java Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import java.nio.ByteBuffer;
/**
* Marshal fake native enums (ints): TYPE_BYTE <-> int/Integer
*/
public class MarshalQueryableNativeByteToInteger implements MarshalQueryable<Integer> {
private static final int UINT8_MASK = (1 << Byte.SIZE) - 1;
private class MarshalerNativeByteToInteger extends Marshaler<Integer> {
protected MarshalerNativeByteToInteger(TypeReference<Integer> typeReference,
int nativeType) {
super(MarshalQueryableNativeByteToInteger.this, typeReference, nativeType);
}
@Override
public void marshal(Integer value, ByteBuffer buffer) {
buffer.put((byte)(int)value); // truncate down to byte
}
@Override
public Integer unmarshal(ByteBuffer buffer) {
// expand unsigned byte to int; avoid sign extension
return buffer.get() & UINT8_MASK;
}
@Override
public int getNativeSize() {
return SIZEOF_BYTE;
}
}
@Override
public Marshaler<Integer> createMarshaler(TypeReference<Integer> managedType,
int nativeType) {
return new MarshalerNativeByteToInteger(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<Integer> managedType, int nativeType) {
return (Integer.class.equals(managedType.getType())
|| int.class.equals(managedType.getType())) && nativeType == TYPE_BYTE;
}
}

193
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableParcelable.java Normal file
View File

@@ -0,0 +1,193 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal any {@code T extends Parcelable} to/from any native type
*
* <p>Use with extreme caution! File descriptors and binders will not be marshaled across.</p>
*/
public class MarshalQueryableParcelable<T extends Parcelable>
implements MarshalQueryable<T> {
private static final String TAG = "MarshalParcelable";
private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
private static final String FIELD_CREATOR = "CREATOR";
private class MarshalerParcelable extends Marshaler<T> {
private final Class<T> mClass;
private final Parcelable.Creator<T> mCreator;
@SuppressWarnings("unchecked")
protected MarshalerParcelable(TypeReference<T> typeReference,
int nativeType) {
super(MarshalQueryableParcelable.this, typeReference, nativeType);
mClass = (Class<T>)typeReference.getRawType();
Field creatorField;
try {
creatorField = mClass.getDeclaredField(FIELD_CREATOR);
} catch (NoSuchFieldException e) {
// Impossible. All Parcelable implementations must have a 'CREATOR' static field
throw new AssertionError(e);
}
try {
mCreator = (Parcelable.Creator<T>)creatorField.get(null);
} catch (IllegalAccessException e) {
// Impossible: All 'CREATOR' static fields must be public
throw new AssertionError(e);
} catch (IllegalArgumentException e) {
// Impossible: This is a static field, so null must be ok
throw new AssertionError(e);
}
}
@Override
public void marshal(T value, ByteBuffer buffer) {
if (VERBOSE) {
Log.v(TAG, "marshal " + value);
}
Parcel parcel = Parcel.obtain();
byte[] parcelContents;
try {
value.writeToParcel(parcel, /*flags*/0);
if (parcel.hasFileDescriptors()) {
throw new UnsupportedOperationException(
"Parcelable " + value + " must not have file descriptors");
}
parcelContents = parcel.marshall();
}
finally {
parcel.recycle();
}
if (parcelContents.length == 0) {
throw new AssertionError("No data marshaled for " + value);
}
buffer.put(parcelContents);
}
@Override
public T unmarshal(ByteBuffer buffer) {
if (VERBOSE) {
Log.v(TAG, "unmarshal, buffer remaining " + buffer.remaining());
}
/*
* Quadratically slow when marshaling an array of parcelables.
*
* Read out the entire byte buffer as an array, then copy it into the parcel.
*
* Once we unparcel the entire object, advance the byte buffer by only how many
* bytes the parcel actually used up.
*
* Future: If we ever do need to use parcelable arrays, we can do this a little smarter
* by reading out a chunk like 4,8,16,24 each time, but not sure how to detect
* parcels being too short in this case.
*
* Future: Alternatively use Parcel#obtain(long) directly into the native
* pointer of a ByteBuffer, which would not copy if the ByteBuffer was direct.
*/
buffer.mark();
Parcel parcel = Parcel.obtain();
try {
int maxLength = buffer.remaining();
byte[] remaining = new byte[maxLength];
buffer.get(remaining);
parcel.unmarshall(remaining, /*offset*/0, maxLength);
parcel.setDataPosition(/*pos*/0);
T value = mCreator.createFromParcel(parcel);
int actualLength = parcel.dataPosition();
if (actualLength == 0) {
throw new AssertionError("No data marshaled for " + value);
}
// set the position past the bytes the parcelable actually used
buffer.reset();
buffer.position(buffer.position() + actualLength);
if (VERBOSE) {
Log.v(TAG, "unmarshal, parcel length was " + actualLength);
Log.v(TAG, "unmarshal, value is " + value);
}
return mClass.cast(value);
} finally {
parcel.recycle();
}
}
@Override
public int getNativeSize() {
return NATIVE_SIZE_DYNAMIC;
}
@Override
public int calculateMarshalSize(T value) {
Parcel parcel = Parcel.obtain();
try {
value.writeToParcel(parcel, /*flags*/0);
int length = parcel.marshall().length;
if (VERBOSE) {
Log.v(TAG, "calculateMarshalSize, length when parceling "
+ value + " is " + length);
}
return length;
} finally {
parcel.recycle();
}
}
}
@Override
public Marshaler<T> createMarshaler(TypeReference<T> managedType, int nativeType) {
return new MarshalerParcelable(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<T> managedType, int nativeType) {
return Parcelable.class.isAssignableFrom(managedType.getRawType());
}
}

185
core/java/android/hardware/camera2/marshal/impl/MarshalQueryablePrimitive.java Normal file
View File

@@ -0,0 +1,185 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.Rational;
import android.hardware.camera2.impl.CameraMetadataNative;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import static com.android.internal.util.Preconditions.*;
import java.nio.ByteBuffer;
/**
* Marshal/unmarshal built-in primitive types to and from a {@link ByteBuffer}.
*
* <p>The following list of type marshaling is supported:
* <ul>
* <li>byte <-> TYPE_BYTE
* <li>int <-> TYPE_INT32
* <li>long <-> TYPE_INT64
* <li>float <-> TYPE_FLOAT
* <li>double <-> TYPE_DOUBLE
* <li>Rational <-> TYPE_RATIONAL
* </ul>
* </p>
*
* <p>Due to the nature of generics, values are always boxed; this also means that both
* the boxed and unboxed types are supported (i.e. both {@code int} and {@code Integer}).</p>
*
* <p>Each managed type <!--(other than boolean)--> must correspond 1:1 to the native type
* (e.g. a byte will not map to a {@link CameraMetadataNative#TYPE_INT32 TYPE_INT32} or vice versa)
* for marshaling.</p>
*/
public final class MarshalQueryablePrimitive<T> implements MarshalQueryable<T> {
private class MarshalerPrimitive extends Marshaler<T> {
/** Always the wrapped class variant of the primitive class for {@code T} */
private final Class<T> mClass;
@SuppressWarnings("unchecked")
protected MarshalerPrimitive(TypeReference<T> typeReference, int nativeType) {
super(MarshalQueryablePrimitive.this, typeReference, nativeType);
// Turn primitives into wrappers, otherwise int.class.cast(Integer) will fail
mClass = wrapClassIfPrimitive((Class<T>)typeReference.getRawType());
}
@Override
public T unmarshal(ByteBuffer buffer) {
return mClass.cast(unmarshalObject(buffer));
}
@Override
public int calculateMarshalSize(T value) {
return getPrimitiveTypeSize(mNativeType);
}
@Override
public void marshal(T value, ByteBuffer buffer) {
if (value instanceof Integer) {
checkNativeTypeEquals(TYPE_INT32, mNativeType);
final int val = (Integer) value;
marshalPrimitive(val, buffer);
} else if (value instanceof Float) {
checkNativeTypeEquals(TYPE_FLOAT, mNativeType);
final float val = (Float) value;
marshalPrimitive(val, buffer);
} else if (value instanceof Long) {
checkNativeTypeEquals(TYPE_INT64, mNativeType);
final long val = (Long) value;
marshalPrimitive(val, buffer);
} else if (value instanceof Rational) {
checkNativeTypeEquals(TYPE_RATIONAL, mNativeType);
marshalPrimitive((Rational) value, buffer);
} else if (value instanceof Double) {
checkNativeTypeEquals(TYPE_DOUBLE, mNativeType);
final double val = (Double) value;
marshalPrimitive(val, buffer);
} else if (value instanceof Byte) {
checkNativeTypeEquals(TYPE_BYTE, mNativeType);
final byte val = (Byte) value;
marshalPrimitive(val, buffer);
} else {
throw new UnsupportedOperationException(
"Can't marshal managed type " + mTypeReference);
}
}
private void marshalPrimitive(int value, ByteBuffer buffer) {
buffer.putInt(value);
}
private void marshalPrimitive(float value, ByteBuffer buffer) {
buffer.putFloat(value);
}
private void marshalPrimitive(double value, ByteBuffer buffer) {
buffer.putDouble(value);
}
private void marshalPrimitive(long value, ByteBuffer buffer) {
buffer.putLong(value);
}
private void marshalPrimitive(Rational value, ByteBuffer buffer) {
buffer.putInt(value.getNumerator());
buffer.putInt(value.getDenominator());
}
private void marshalPrimitive(byte value, ByteBuffer buffer) {
buffer.put(value);
}
private Object unmarshalObject(ByteBuffer buffer) {
switch (mNativeType) {
case TYPE_INT32:
return buffer.getInt();
case TYPE_FLOAT:
return buffer.getFloat();
case TYPE_INT64:
return buffer.getLong();
case TYPE_RATIONAL:
int numerator = buffer.getInt();
int denominator = buffer.getInt();
return new Rational(numerator, denominator);
case TYPE_DOUBLE:
return buffer.getDouble();
case TYPE_BYTE:
return buffer.get(); // getByte
default:
throw new UnsupportedOperationException(
"Can't unmarshal native type " + mNativeType);
}
}
@Override
public int getNativeSize() {
return getPrimitiveTypeSize(mNativeType);
}
}
@Override
public Marshaler<T> createMarshaler(TypeReference<T> managedType, int nativeType) {
return new MarshalerPrimitive(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<T> managedType, int nativeType) {
if (managedType.getType() instanceof Class<?>) {
Class<?> klass = (Class<?>)managedType.getType();
if (klass == byte.class || klass == Byte.class) {
return nativeType == TYPE_BYTE;
} else if (klass == int.class || klass == Integer.class) {
return nativeType == TYPE_INT32;
} else if (klass == float.class || klass == Float.class) {
return nativeType == TYPE_FLOAT;
} else if (klass == long.class || klass == Long.class) {
return nativeType == TYPE_INT64;
} else if (klass == double.class || klass == Double.class) {
return nativeType == TYPE_DOUBLE;
} else if (klass == Rational.class) {
return nativeType == TYPE_RATIONAL;
}
}
return false;
}
}

139
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableRange.java Normal file
View File

@@ -0,0 +1,139 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.marshal.MarshalRegistry;
import android.hardware.camera2.utils.TypeReference;
import android.util.Range;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.nio.ByteBuffer;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal {@link Range} to/from any native type
*/
public class MarshalQueryableRange<T extends Comparable<? super T>>
implements MarshalQueryable<Range<T>> {
private static final int RANGE_COUNT = 2;
private class MarshalerRange extends Marshaler<Range<T>> {
private final Class<? super Range<T>> mClass;
private final Constructor<Range<T>> mConstructor;
/** Marshal the {@code T} inside of {@code Range<T>} */
private final Marshaler<T> mNestedTypeMarshaler;
@SuppressWarnings("unchecked")
protected MarshalerRange(TypeReference<Range<T>> typeReference,
int nativeType) {
super(MarshalQueryableRange.this, typeReference, nativeType);
mClass = typeReference.getRawType();
/*
* Lookup the actual type argument, e.g. Range<Integer> --> Integer
* and then get the marshaler for that managed type.
*/
ParameterizedType paramType;
try {
paramType = (ParameterizedType) typeReference.getType();
} catch (ClassCastException e) {
throw new AssertionError("Raw use of Range is not supported", e);
}
Type actualTypeArgument = paramType.getActualTypeArguments()[0];
TypeReference<?> actualTypeArgToken =
TypeReference.createSpecializedTypeReference(actualTypeArgument);
mNestedTypeMarshaler = (Marshaler<T>)MarshalRegistry.getMarshaler(
actualTypeArgToken, mNativeType);
try {
mConstructor = (Constructor<Range<T>>)mClass.getConstructor(
Comparable.class, Comparable.class);
} catch (NoSuchMethodException e) {
throw new AssertionError(e);
}
}
@Override
public void marshal(Range<T> value, ByteBuffer buffer) {
mNestedTypeMarshaler.marshal(value.getLower(), buffer);
mNestedTypeMarshaler.marshal(value.getUpper(), buffer);
}
@Override
public Range<T> unmarshal(ByteBuffer buffer) {
T lower = mNestedTypeMarshaler.unmarshal(buffer);
T upper = mNestedTypeMarshaler.unmarshal(buffer);
try {
return mConstructor.newInstance(lower, upper);
} catch (InstantiationException e) {
throw new AssertionError(e);
} catch (IllegalAccessException e) {
throw new AssertionError(e);
} catch (IllegalArgumentException e) {
throw new AssertionError(e);
} catch (InvocationTargetException e) {
throw new AssertionError(e);
}
}
@Override
public int getNativeSize() {
int nestedSize = mNestedTypeMarshaler.getNativeSize();
if (nestedSize != NATIVE_SIZE_DYNAMIC) {
return nestedSize * RANGE_COUNT;
} else {
return NATIVE_SIZE_DYNAMIC;
}
}
@Override
public int calculateMarshalSize(Range<T> value) {
int nativeSize = getNativeSize();
if (nativeSize != NATIVE_SIZE_DYNAMIC) {
return nativeSize;
} else {
int lowerSize = mNestedTypeMarshaler.calculateMarshalSize(value.getLower());
int upperSize = mNestedTypeMarshaler.calculateMarshalSize(value.getUpper());
return lowerSize + upperSize;
}
}
}
@Override
public Marshaler<Range<T>> createMarshaler(TypeReference<Range<T>> managedType,
int nativeType) {
return new MarshalerRange(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<Range<T>> managedType, int nativeType) {
return (Range.class.equals(managedType.getRawType()));
}
}

77
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableRect.java Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.graphics.Rect;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import java.nio.ByteBuffer;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal {@link Rect} to/from {@link #TYPE_INT32}
*/
public class MarshalQueryableRect implements MarshalQueryable<Rect> {
private static final int SIZE = SIZEOF_INT32 * 4;
private class MarshalerRect extends Marshaler<Rect> {
protected MarshalerRect(TypeReference<Rect> typeReference,
int nativeType) {
super(MarshalQueryableRect.this, typeReference, nativeType);
}
@Override
public void marshal(Rect value, ByteBuffer buffer) {
buffer.putInt(value.left);
buffer.putInt(value.top);
buffer.putInt(value.width());
buffer.putInt(value.height());
}
@Override
public Rect unmarshal(ByteBuffer buffer) {
int left = buffer.getInt();
int top = buffer.getInt();
int width = buffer.getInt();
int height = buffer.getInt();
int right = left + width;
int bottom = top + height;
return new Rect(left, top, right, bottom);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<Rect> createMarshaler(TypeReference<Rect> managedType, int nativeType) {
return new MarshalerRect(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<Rect> managedType, int nativeType) {
return nativeType == TYPE_INT32 && (Rect.class.equals(managedType.getType()));
}
}

129
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableReprocessFormatsMap.java Normal file
View File

@@ -0,0 +1,129 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.ReprocessFormatsMap;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
/**
* Marshaler for {@code android.scaler.availableInputOutputFormatsMap} custom class
* {@link ReprocessFormatsMap}
*/
public class MarshalQueryableReprocessFormatsMap
implements MarshalQueryable<ReprocessFormatsMap> {
private class MarshalerReprocessFormatsMap extends Marshaler<ReprocessFormatsMap> {
protected MarshalerReprocessFormatsMap(
TypeReference<ReprocessFormatsMap> typeReference, int nativeType) {
super(MarshalQueryableReprocessFormatsMap.this, typeReference, nativeType);
}
@Override
public void marshal(ReprocessFormatsMap value, ByteBuffer buffer) {
/*
* // writing (static example, DNG+ZSL)
* int32_t[] contents = {
* RAW_OPAQUE, 3, RAW16, YUV_420_888, BLOB,
* RAW16, 2, YUV_420_888, BLOB,
* ...,
* INPUT_FORMAT, OUTPUT_FORMAT_COUNT, [OUTPUT_0, OUTPUT_1, ..., OUTPUT_FORMAT_COUNT-1]
* };
*/
int[] inputs = value.getInputs();
for (int input : inputs) {
// INPUT_FORMAT
buffer.putInt(input);
int[] outputs = value.getOutputs(input);
// OUTPUT_FORMAT_COUNT
buffer.putInt(outputs.length);
// [OUTPUT_0, OUTPUT_1, ..., OUTPUT_FORMAT_COUNT-1]
for (int output : outputs) {
buffer.putInt(output);
}
}
}
@Override
public ReprocessFormatsMap unmarshal(ByteBuffer buffer) {
int len = buffer.remaining() / SIZEOF_INT32;
if (buffer.remaining() % SIZEOF_INT32 != 0) {
throw new AssertionError("ReprocessFormatsMap was not TYPE_INT32");
}
int[] entries = new int[len];
IntBuffer intBuffer = buffer.asIntBuffer();
intBuffer.get(entries);
// TODO: consider moving rest of parsing code from ReprocessFormatsMap to here
return new ReprocessFormatsMap(entries);
}
@Override
public int getNativeSize() {
return NATIVE_SIZE_DYNAMIC;
}
@Override
public int calculateMarshalSize(ReprocessFormatsMap value) {
/*
* // writing (static example, DNG+ZSL)
* int32_t[] contents = {
* RAW_OPAQUE, 3, RAW16, YUV_420_888, BLOB,
* RAW16, 2, YUV_420_888, BLOB,
* ...,
* INPUT_FORMAT, OUTPUT_FORMAT_COUNT, [OUTPUT_0, OUTPUT_1, ..., OUTPUT_FORMAT_COUNT-1]
* };
*/
int length = 0;
int[] inputs = value.getInputs();
for (int input : inputs) {
length += 1; // INPUT_FORMAT
length += 1; // OUTPUT_FORMAT_COUNT
int[] outputs = value.getOutputs(input);
length += outputs.length; // [OUTPUT_0, OUTPUT_1, ..., OUTPUT_FORMAT_COUNT-1]
}
return length * SIZEOF_INT32;
}
}
@Override
public Marshaler<ReprocessFormatsMap> createMarshaler(
TypeReference<ReprocessFormatsMap> managedType, int nativeType) {
return new MarshalerReprocessFormatsMap(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<ReprocessFormatsMap> managedType,
int nativeType) {
return nativeType == TYPE_INT32 && managedType.getType().equals(ReprocessFormatsMap.class);
}
}

75
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableRggbChannelVector.java Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.RggbChannelVector;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import java.nio.ByteBuffer;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
/**
* Marshal {@link RggbChannelVector} to/from {@link #TYPE_FLOAT} {@code x 4}
*/
public class MarshalQueryableRggbChannelVector implements MarshalQueryable<RggbChannelVector> {
private static final int SIZE = SIZEOF_FLOAT * RggbChannelVector.COUNT;
private class MarshalerRggbChannelVector extends Marshaler<RggbChannelVector> {
protected MarshalerRggbChannelVector(TypeReference<RggbChannelVector> typeReference,
int nativeType) {
super(MarshalQueryableRggbChannelVector.this, typeReference, nativeType);
}
@Override
public void marshal(RggbChannelVector value, ByteBuffer buffer) {
for (int i = 0; i < RggbChannelVector.COUNT; ++i) {
buffer.putFloat(value.getComponent(i));
}
}
@Override
public RggbChannelVector unmarshal(ByteBuffer buffer) {
float red = buffer.getFloat();
float gEven = buffer.getFloat();
float gOdd = buffer.getFloat();
float blue = buffer.getFloat();
return new RggbChannelVector(red, gEven, gOdd, blue);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<RggbChannelVector> createMarshaler(
TypeReference<RggbChannelVector> managedType, int nativeType) {
return new MarshalerRggbChannelVector(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(
TypeReference<RggbChannelVector> managedType, int nativeType) {
return nativeType == TYPE_FLOAT && (RggbChannelVector.class.equals(managedType.getType()));
}
}

68
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableSize.java Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.Size;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import java.nio.ByteBuffer;
/**
* Marshal {@link Size} to/from {@code TYPE_INT32}
*/
public class MarshalQueryableSize implements MarshalQueryable<Size> {
private static final int SIZE = SIZEOF_INT32 * 2;
private class MarshalerSize extends Marshaler<Size> {
protected MarshalerSize(TypeReference<Size> typeReference, int nativeType) {
super(MarshalQueryableSize.this, typeReference, nativeType);
}
@Override
public void marshal(Size value, ByteBuffer buffer) {
buffer.putInt(value.getWidth());
buffer.putInt(value.getHeight());
}
@Override
public Size unmarshal(ByteBuffer buffer) {
int width = buffer.getInt();
int height = buffer.getInt();
return new Size(width, height);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<Size> createMarshaler(TypeReference<Size> managedType, int nativeType) {
return new MarshalerSize(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<Size> managedType, int nativeType) {
return nativeType == TYPE_INT32 && (Size.class.equals(managedType.getType()));
}
}

72
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableSizeF.java Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import android.util.SizeF;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import java.nio.ByteBuffer;
/**
* Marshal {@link SizeF} to/from {@code TYPE_FLOAT}
*/
public class MarshalQueryableSizeF implements MarshalQueryable<SizeF> {
private static final int SIZE = SIZEOF_FLOAT * 2;
private class MarshalerSizeF extends Marshaler<SizeF> {
protected MarshalerSizeF(TypeReference<SizeF> typeReference, int nativeType) {
super(MarshalQueryableSizeF.this, typeReference, nativeType);
}
@Override
public void marshal(SizeF value, ByteBuffer buffer) {
buffer.putFloat(value.getWidth());
buffer.putFloat(value.getHeight());
}
@Override
public SizeF unmarshal(ByteBuffer buffer) {
float width = buffer.getFloat();
float height = buffer.getFloat();
return new SizeF(width, height);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<SizeF> createMarshaler(
TypeReference<SizeF> managedType, int nativeType) {
return new MarshalerSizeF(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<SizeF> managedType, int nativeType) {
return nativeType == TYPE_FLOAT && (SizeF.class.equals(managedType.getType()));
}
}

80
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableStreamConfiguration.java Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.StreamConfiguration;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import java.nio.ByteBuffer;
/**
* Marshaler for {@code android.scaler.availableStreamConfigurations} custom class
* {@link StreamConfiguration}
*
* <p>Data is stored as {@code (format, width, height, input?)} tuples (int32).</p>
*/
public class MarshalQueryableStreamConfiguration
implements MarshalQueryable<StreamConfiguration> {
private static final int SIZE = SIZEOF_INT32 * 4;
private class MarshalerStreamConfiguration extends Marshaler<StreamConfiguration> {
protected MarshalerStreamConfiguration(TypeReference<StreamConfiguration> typeReference,
int nativeType) {
super(MarshalQueryableStreamConfiguration.this, typeReference, nativeType);
}
@Override
public void marshal(StreamConfiguration value, ByteBuffer buffer) {
buffer.putInt(value.getFormat());
buffer.putInt(value.getWidth());
buffer.putInt(value.getHeight());
buffer.putInt(value.isInput() ? 1 : 0);
}
@Override
public StreamConfiguration unmarshal(ByteBuffer buffer) {
int format = buffer.getInt();
int width = buffer.getInt();
int height = buffer.getInt();
boolean input = buffer.getInt() != 0;
return new StreamConfiguration(format, width, height, input);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<StreamConfiguration> createMarshaler(
TypeReference<StreamConfiguration> managedType, int nativeType) {
return new MarshalerStreamConfiguration(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<StreamConfiguration> managedType,
int nativeType) {
return nativeType == TYPE_INT32 && managedType.getType().equals(StreamConfiguration.class);
}
}

90
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableStreamConfigurationDuration.java Normal file
View File

@@ -0,0 +1,90 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.StreamConfigurationDuration;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static android.hardware.camera2.marshal.MarshalHelpers.*;
import java.nio.ByteBuffer;
/**
* Marshaler for custom class {@link StreamConfigurationDuration} for min-frame and stall durations.
*
* <p>
* Data is stored as {@code (format, width, height, durationNs)} tuples (int64).
* </p>
*/
public class MarshalQueryableStreamConfigurationDuration
implements MarshalQueryable<StreamConfigurationDuration> {
private static final int SIZE = SIZEOF_INT64 * 4;
/**
* Values and-ed with this will do an unsigned int to signed long conversion;
* in other words the sign bit from the int will not be extended.
* */
private static final long MASK_UNSIGNED_INT = 0x00000000ffffffffL;
private class MarshalerStreamConfigurationDuration
extends Marshaler<StreamConfigurationDuration> {
protected MarshalerStreamConfigurationDuration(
TypeReference<StreamConfigurationDuration> typeReference, int nativeType) {
super(MarshalQueryableStreamConfigurationDuration.this, typeReference, nativeType);
}
@Override
public void marshal(StreamConfigurationDuration value, ByteBuffer buffer) {
buffer.putLong(value.getFormat() & MASK_UNSIGNED_INT); // unsigned int -> long
buffer.putLong(value.getWidth());
buffer.putLong(value.getHeight());
buffer.putLong(value.getDuration());
}
@Override
public StreamConfigurationDuration unmarshal(ByteBuffer buffer) {
int format = (int)buffer.getLong();
int width = (int)buffer.getLong();
int height = (int)buffer.getLong();
long durationNs = buffer.getLong();
return new StreamConfigurationDuration(format, width, height, durationNs);
}
@Override
public int getNativeSize() {
return SIZE;
}
}
@Override
public Marshaler<StreamConfigurationDuration> createMarshaler(
TypeReference<StreamConfigurationDuration> managedType, int nativeType) {
return new MarshalerStreamConfigurationDuration(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<StreamConfigurationDuration> managedType,
int nativeType) {
return nativeType == TYPE_INT64 &&
(StreamConfigurationDuration.class.equals(managedType.getType()));
}
}

110
core/java/android/hardware/camera2/marshal/impl/MarshalQueryableString.java Normal file
View File

@@ -0,0 +1,110 @@
/*
* Copyright (C) 2014 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.hardware.camera2.marshal.impl;
import android.hardware.camera2.marshal.Marshaler;
import android.hardware.camera2.marshal.MarshalQueryable;
import android.hardware.camera2.utils.TypeReference;
import android.util.Log;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
/**
* Marshal {@link String} to/from {@link #TYPE_BYTE}.
*/
public class MarshalQueryableString implements MarshalQueryable<String> {
private static final String TAG = MarshalQueryableString.class.getSimpleName();
private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
private static final Charset UTF8_CHARSET = Charset.forName("UTF-8");
private static final byte NUL = (byte)'\0'; // used as string terminator
private class MarshalerString extends Marshaler<String> {
protected MarshalerString(TypeReference<String> typeReference, int nativeType) {
super(MarshalQueryableString.this, typeReference, nativeType);
}
@Override
public void marshal(String value, ByteBuffer buffer) {
byte[] arr = value.getBytes(UTF8_CHARSET);
buffer.put(arr);
buffer.put(NUL); // metadata strings are NUL-terminated
}
@Override
public int calculateMarshalSize(String value) {
byte[] arr = value.getBytes(UTF8_CHARSET);
return arr.length + 1; // metadata strings are NUL-terminated
}
@Override
public String unmarshal(ByteBuffer buffer) {
buffer.mark(); // save the current position
boolean foundNull = false;
int stringLength = 0;
while (buffer.hasRemaining()) {
if (buffer.get() == NUL) {
foundNull = true;
break;
}
stringLength++;
}
if (VERBOSE) {
Log.v(TAG,
"unmarshal - scanned " + stringLength + " characters; found null? "
+ foundNull);
}
if (!foundNull) {
throw new UnsupportedOperationException("Strings must be null-terminated");
}
buffer.reset(); // go back to the previously marked position
byte[] strBytes = new byte[stringLength + 1];
buffer.get(strBytes, /*dstOffset*/0, stringLength + 1); // including null character
// not including null character
return new String(strBytes, /*offset*/0, stringLength, UTF8_CHARSET);
}
@Override
public int getNativeSize() {
return NATIVE_SIZE_DYNAMIC;
}
}
@Override
public Marshaler<String> createMarshaler(
TypeReference<String> managedType, int nativeType) {
return new MarshalerString(managedType, nativeType);
}
@Override
public boolean isTypeMappingSupported(TypeReference<String> managedType, int nativeType) {
return nativeType == TYPE_BYTE && String.class.equals(managedType.getType());
}
}

3
core/java/android/hardware/camera2/marshal/impl/package.html Normal file
View File

@@ -0,0 +1,3 @@
<body>
{@hide}
</body>

3
core/java/android/hardware/camera2/marshal/package.html Normal file
View File

@@ -0,0 +1,3 @@
<body>
{@hide}
</body>

2
core/java/android/hardware/camera2/impl/HashCodeHelpers.java → core/java/android/hardware/camera2/utils/HashCodeHelpers.java
View File

@@ -14,7 +14,7 @@
* limitations under the License.
*/
package android.hardware.camera2.impl;
package android.hardware.camera2.utils;
/**
* Provide hashing functions using the Modified Bernstein hash

435
core/java/android/hardware/camera2/utils/TypeReference.java Normal file
View File

@@ -0,0 +1,435 @@
/*
* Copyright (C) 2014 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.hardware.camera2.utils;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import static com.android.internal.util.Preconditions.*;
/**
* Super type token; allows capturing generic types at runtime by forcing them to be reified.
*
* <p>Usage example: <pre>{@code
* // using anonymous classes (preferred)
* TypeReference&lt;Integer> intToken = new TypeReference&lt;Integer>() {{ }};
*
* // using named classes
* class IntTypeReference extends TypeReference&lt;Integer> {...}
* TypeReference&lt;Integer> intToken = new IntTypeReference();
* }</p></pre>
*
* <p>Unlike the reference implementation, this bans nested TypeVariables; that is all
* dynamic types must equal to the static types.</p>
*
* <p>See <a href="http://gafter.blogspot.com/2007/05/limitation-of-super-type-tokens.html">
* http://gafter.blogspot.com/2007/05/limitation-of-super-type-tokens.html</a>
* for more details.</p>
*/
public abstract class TypeReference<T> {
private final Type mType;
/**
* Create a new type reference for {@code T}.
*
* @throws IllegalArgumentException if {@code T}'s actual type contains a type variable
*
* @see TypeReference
*/
protected TypeReference() {
ParameterizedType thisType = (ParameterizedType)getClass().getGenericSuperclass();
// extract the "T" from TypeReference<T>
mType = thisType.getActualTypeArguments()[0];
/*
* Prohibit type references with type variables such as
*
* class GenericListToken<T> extends TypeReference<List<T>>
*
* Since the "T" there is not known without an instance of T, type equality would
* consider *all* Lists equal regardless of T. Allowing this would defeat
* some of the type safety of a type reference.
*/
if (containsTypeVariable(mType)) {
throw new IllegalArgumentException(
"Including a type variable in a type reference is not allowed");
}
}
/**
* Return the dynamic {@link Type} corresponding to the captured type {@code T}.
*/
public Type getType() {
return mType;
}
private TypeReference(Type type) {
mType = type;
if (containsTypeVariable(mType)) {
throw new IllegalArgumentException(
"Including a type variable in a type reference is not allowed");
}
}
private static class SpecializedTypeReference<T> extends TypeReference<T> {
public SpecializedTypeReference(Class<T> klass) {
super(klass);
}
}
@SuppressWarnings("rawtypes")
private static class SpecializedBaseTypeReference extends TypeReference {
public SpecializedBaseTypeReference(Type type) {
super(type);
}
}
/**
* Create a specialized type reference from a dynamic class instance,
* bypassing the standard compile-time checks.
*
* <p>As with a regular type reference, the {@code klass} must not contain
* any type variables.</p>
*
* @param klass a non-{@code null} {@link Class} instance
*
* @return a type reference which captures {@code T} at runtime
*
* @throws IllegalArgumentException if {@code T} had any type variables
*/
public static <T> TypeReference<T> createSpecializedTypeReference(Class<T> klass) {
return new SpecializedTypeReference<T>(klass);
}
/**
* Create a specialized type reference from a dynamic {@link Type} instance,
* bypassing the standard compile-time checks.
*
* <p>As with a regular type reference, the {@code type} must not contain
* any type variables.</p>
*
* @param type a non-{@code null} {@link Type} instance
*
* @return a type reference which captures {@code T} at runtime
*
* @throws IllegalArgumentException if {@code type} had any type variables
*/
public static TypeReference<?> createSpecializedTypeReference(Type type) {
return new SpecializedBaseTypeReference(type);
}
/**
* Returns the raw type of T.
*
* <p><ul>
* <li>If T is a Class itself, T itself is returned.
* <li>If T is a ParameterizedType, the raw type of the parameterized type is returned.
* <li>If T is a GenericArrayType, the returned type is the corresponding array class.
* For example: {@code List<Integer>[]} => {@code List[]}.
* <li>If T is a type variable or a wildcard type, the raw type of the first upper bound is
* returned. For example: {@code <X extends Foo>} => {@code Foo}.
* </ul>
*
* @return the raw type of {@code T}
*/
@SuppressWarnings("unchecked")
public final Class<? super T> getRawType() {
return (Class<? super T>)getRawType(mType);
}
private static final Class<?> getRawType(Type type) {
if (type == null) {
throw new NullPointerException("type must not be null");
}
if (type instanceof Class<?>) {
return (Class<?>)type;
} else if (type instanceof ParameterizedType) {
return (Class<?>)(((ParameterizedType)type).getRawType());
} else if (type instanceof GenericArrayType) {
return getArrayClass(getRawType(((GenericArrayType)type).getGenericComponentType()));
} else if (type instanceof WildcardType) {
// Should be at most 1 upper bound, but treat it like an array for simplicity
return getRawType(((WildcardType) type).getUpperBounds());
} else if (type instanceof TypeVariable) {
throw new AssertionError("Type variables are not allowed in type references");
} else {
// Impossible
throw new AssertionError("Unhandled branch to get raw type for type " + type);
}
}
private static final Class<?> getRawType(Type[] types) {
if (types == null) {
return null;
}
for (Type type : types) {
Class<?> klass = getRawType(type);
if (klass != null) {
return klass;
}
}
return null;
}
private static final Class<?> getArrayClass(Class<?> componentType) {
return Array.newInstance(componentType, 0).getClass();
}
/**
* Get the component type, e.g. {@code T} from {@code T[]}.
*
* @return component type, or {@code null} if {@code T} is not an array
*/
public TypeReference<?> getComponentType() {
Type componentType = getComponentType(mType);
return (componentType != null) ?
createSpecializedTypeReference(componentType) :
null;
}
private static Type getComponentType(Type type) {
checkNotNull(type, "type must not be null");
if (type instanceof Class<?>) {
return ((Class<?>) type).getComponentType();
} else if (type instanceof ParameterizedType) {
return null;
} else if (type instanceof GenericArrayType) {
return ((GenericArrayType)type).getGenericComponentType();
} else if (type instanceof WildcardType) {
// Should be at most 1 upper bound, but treat it like an array for simplicity
throw new UnsupportedOperationException("TODO: support wild card components");
} else if (type instanceof TypeVariable) {
throw new AssertionError("Type variables are not allowed in type references");
} else {
// Impossible
throw new AssertionError("Unhandled branch to get component type for type " + type);
}
}
/**
* Compare two objects for equality.
*
* <p>A TypeReference is only equal to another TypeReference if their captured type {@code T}
* is also equal.</p>
*/
@Override
public boolean equals(Object o) {
// Note that this comparison could inaccurately return true when comparing types
// with nested type variables; therefore we ban type variables in the constructor.
return o instanceof TypeReference<?> && mType.equals(((TypeReference<?>)o).mType);
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return mType.hashCode();
}
/**
* Check if the {@code type} contains a {@link TypeVariable} recursively.
*
* <p>Intuitively, a type variable is a type in a type expression that refers to a generic
* type which is not known at the definition of the expression (commonly seen when
* type parameters are used, e.g. {@code class Foo<T>}).</p>
*
* <p>See <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.4">
* http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.4</a>
* for a more formal definition of a type variable</p>.
*
* @param type a type object ({@code null} is allowed)
* @return {@code true} if there were nested type variables; {@code false} otherwise
*/
public static boolean containsTypeVariable(Type type) {
if (type == null) {
// Trivially false
return false;
} else if (type instanceof TypeVariable<?>) {
/*
* T -> trivially true
*/
return true;
} else if (type instanceof Class<?>) {
/*
* class Foo -> no type variable
* class Foo<T> - has a type variable
*
* This also covers the case of class Foo<T> extends ... / implements ...
* since everything on the right hand side would either include a type variable T
* or have no type variables.
*/
Class<?> klass = (Class<?>)type;
// Empty array => class is not generic
if (klass.getTypeParameters().length != 0) {
return true;
} else {
// Does the outer class(es) contain any type variables?
/*
* class Outer<T> {
* class Inner {
* T field;
* }
* }
*
* In this case 'Inner' has no type parameters itself, but it still has a type
* variable as part of the type definition.
*/
return containsTypeVariable(klass.getDeclaringClass());
}
} else if (type instanceof ParameterizedType) {
/*
* This is the "Foo<T1, T2, T3, ... Tn>" in the scope of a
*
* // no type variables here, T1-Tn are known at this definition
* class X extends Foo<T1, T2, T3, ... Tn>
*
* // T1 is a type variable, T2-Tn are known at this definition
* class X<T1> extends Foo<T1, T2, T3, ... Tn>
*/
ParameterizedType p = (ParameterizedType) type;
// This needs to be recursively checked
for (Type arg : p.getActualTypeArguments()) {
if (containsTypeVariable(arg)) {
return true;
}
}
return false;
} else if (type instanceof WildcardType) {
WildcardType wild = (WildcardType) type;
/*
* This is is the "?" inside of a
*
* Foo<?> --> unbounded; trivially no type variables
* Foo<? super T> --> lower bound; does T have a type variable?
* Foo<? extends T> --> upper bound; does T have a type variable?
*/
/*
* According to JLS 4.5.1
* (http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.5.1):
*
* - More than 1 lower/upper bound is illegal
* - Both a lower and upper bound is illegal
*
* However, we use this 'array OR array' approach for readability
*/
return containsTypeVariable(wild.getLowerBounds()) ||
containsTypeVariable(wild.getUpperBounds());
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("TypeReference<");
toString(getType(), builder);
builder.append(">");
return builder.toString();
}
private static void toString(Type type, StringBuilder out) {
if (type == null) {
return;
} else if (type instanceof TypeVariable<?>) {
// T
out.append(((TypeVariable<?>)type).getName());
} else if (type instanceof Class<?>) {
Class<?> klass = (Class<?>)type;
out.append(klass.getName());
toString(klass.getTypeParameters(), out);
} else if (type instanceof ParameterizedType) {
// "Foo<T1, T2, T3, ... Tn>"
ParameterizedType p = (ParameterizedType) type;
out.append(((Class<?>)p.getRawType()).getName());
toString(p.getActualTypeArguments(), out);
} else if (type instanceof GenericArrayType) {
GenericArrayType gat = (GenericArrayType)type;
toString(gat.getGenericComponentType(), out);
out.append("[]");
} else { // WildcardType, BoundedType
// TODO:
out.append(type.toString());
}
}
private static void toString(Type[] types, StringBuilder out) {
if (types == null) {
return;
} else if (types.length == 0) {
return;
}
out.append("<");
for (int i = 0; i < types.length; ++i) {
toString(types[i], out);
if (i != types.length - 1) {
out.append(", ");
}
}
out.append(">");
}
/**
* Check if any of the elements in this array contained a type variable.
*
* <p>Empty and null arrays trivially have no type variables.</p>
*
* @param typeArray an array ({@code null} is ok) of types
* @return true if any elements contained a type variable; false otherwise
*/
private static boolean containsTypeVariable(Type[] typeArray) {
if (typeArray == null) {
return false;
}
for (Type type : typeArray) {
if (containsTypeVariable(type)) {
return true;
}
}
return false;
}
}

2
core/java/android/util/Range.java
View File

@@ -18,7 +18,7 @@ package android.util;
import static com.android.internal.util.Preconditions.*;
import android.hardware.camera2.impl.HashCodeHelpers;
import android.hardware.camera2.utils.HashCodeHelpers;
/**
* Immutable class for describing the range of two numeric values.

11
core/jni/android_hardware_camera2_CameraMetadata.cpp
View File

@@ -489,8 +489,13 @@ static jint CameraMetadata_getTagFromKey(JNIEnv *env, jobject thiz, jstring keyN
sp<VendorTagDescriptor> vTags = VendorTagDescriptor::getGlobalVendorTagDescriptor();
SortedVector<String8> vendorSections = vTags->getAllSectionNames();
size_t vendorSectionCount = vendorSections.size();
SortedVector<String8> vendorSections;
size_t vendorSectionCount = 0;
if (vTags != 0) {
vendorSections = vTags->getAllSectionNames();
vendorSectionCount = vendorSections.size();
}
// First, find the section by the longest string match
const char *section = NULL;
@@ -561,7 +566,7 @@ static jint CameraMetadata_getTagFromKey(JNIEnv *env, jobject thiz, jstring keyN
"Could not find tag name for key '%s')", key);
return 0;
}
} else {
} else if (vTags != 0) {
// Match vendor tags (typically com.*)
const String8 sectionName(section);
const String8 tagName(keyTagName);

2
media/tests/MediaFrameworkTest/Android.mk
View File

@@ -7,7 +7,7 @@ LOCAL_SRC_FILES := $(call all-subdir-java-files)
LOCAL_JAVA_LIBRARIES := android.test.runner
LOCAL_STATIC_JAVA_LIBRARIES := easymocklib mockito-target
LOCAL_STATIC_JAVA_LIBRARIES := easymocklib mockito-target core-tests android-support-test
LOCAL_PACKAGE_NAME := mediaframeworktest

4
media/tests/MediaFrameworkTest/AndroidManifest.xml
View File

@@ -76,4 +76,8 @@
android:label="MediaFramework integration tests InstrumentationRunner">
</instrumentation>
<instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
android:targetPackage="com.android.mediaframeworktest"
android:label="media framework tests"/>
</manifest>

1
media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkUnitTestRunner.java
View File

@@ -63,6 +63,7 @@ public class MediaFrameworkUnitTestRunner extends InstrumentationTestRunner {
suite.addTestSuite(CameraUtilsRuntimeExceptionTest.class);
suite.addTestSuite(CameraUtilsUncheckedThrowTest.class);
suite.addTestSuite(CameraUtilsBinderDecoratorTest.class);
suite.addTestSuite(CameraUtilsTypeReferenceTest.class);
suite.addTestSuite(CameraMetadataTest.class);
}

253
media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/unit/ByteArrayHelpers.java Normal file
View File

@@ -0,0 +1,253 @@
/*
* Copyright (C) 2014 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 com.android.mediaframeworktest.unit;
import android.util.Log;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
public class ByteArrayHelpers {
private static final String TAG = "ByteArrayHelpers";
private static boolean VERBOSE = false;
/**
* Convert an array of byte primitives to a {@code byte[]} using native endian order.
*
* <p>This function is a pass-through; it's here only to provide overloads for
* every single type of primitive arrays.
*
* @param array array of primitives
* @return array
*/
public static byte[] toByteArray(byte[] array) {
return array;
}
/**
* Convert an array of shorts to a {@code byte[]} using native endian order.
*
* @param array array of shorts
* @return array converted into byte array using native endian order
*/
public static byte[] toByteArray(short[] array) {
return toByteArray(array, Short.SIZE);
}
/**
* Convert an array of chars to a {@code byte[]} using native endian order.
*
* @param array array of chars
* @return array converted into byte array using native endian order
*/
public static byte[] toByteArray(char[] array) {
return toByteArray(array, Character.SIZE);
}
/**
* Convert an array of ints to a {@code byte[]} using native endian order.
*
* @param array array of ints
* @return array converted into byte array using native endian order
*/
public static byte[] toByteArray(int[] array) {
return toByteArray(array, Integer.SIZE);
}
/**
* Convert an array of longs to a {@code byte[]} using native endian order.
*
* @param array array of longs
* @return array converted into byte array using native endian order
*/
public static byte[] toByteArray(long[] array) {
return toByteArray(array, Long.SIZE);
}
/**
* Convert an array of floats to a {@code byte[]} using native endian order.
*
* @param array array of floats
* @return array converted into byte array using native endian order
*/
public static byte[] toByteArray(float[] array) {
return toByteArray(array, Float.SIZE);
}
/**
* Convert an array of doubles to a {@code byte[]} using native endian order.
*
* @param array array of doubles
* @return array converted into byte array using native endian order
*/
public static byte[] toByteArray(double[] array) {
return toByteArray(array, Double.SIZE);
}
/**
* Convert an array of primitives to a {@code byte[]} using native endian order.
*
* <p>Arguments other than arrays are not supported. The array component must be primitive,
* the wrapper class is not allowed (e.g. {@code int[]} is ok, but {@code Integer[]} is not.</p>
*
* @param array array of primitives
* @return array converted into byte array using native endian order
*
* @throws IllegalArgumentException if {@code array} was not an array of primitives
*/
public static <T> byte[] toByteArray(T array) {
@SuppressWarnings("unchecked")
Class<T> klass = (Class<T>) array.getClass();
if (!klass.isArray()) {
throw new IllegalArgumentException("array class must be an array");
}
Class<?> componentClass = klass.getComponentType();
if (!componentClass.isPrimitive()) {
throw new IllegalArgumentException("array's component must be a primitive");
}
int sizeInBits;
if (klass == int.class) {
sizeInBits = Integer.SIZE;
} else if (klass == float.class) {
sizeInBits = Float.SIZE;
} else if (klass == double.class) {
sizeInBits = Double.SIZE;
} else if (klass == short.class) {
sizeInBits = Short.SIZE;
} else if (klass == char.class) {
sizeInBits = Character.SIZE;
} else if (klass == long.class) {
sizeInBits = Long.SIZE;
} else if (klass == byte.class) {
sizeInBits = Byte.SIZE;
} else {
throw new AssertionError();
}
return toByteArray(array, sizeInBits);
}
/**
* Convert a variadic list of {@code Number}s into a byte array using native endian order.
*
* <p>Each {@link Number} must be an instance of a primitive wrapper class
* (e.g. {@link Integer} is OK, since it wraps {@code int}, but {@code BigInteger} is not.</p>
*
* @param numbers variadic list of numeric values
* @return array converted into byte array using native endian order
*
* @throws IllegalArgumentException
* if {@code numbers} contained a class that wasn't a primitive wrapper
*/
public static byte[] toByteArray(Number... numbers) {
if (numbers.length == 0) {
throw new IllegalArgumentException("too few numbers");
}
if (VERBOSE) Log.v(TAG, "toByteArray - input: " + Arrays.toString(numbers));
// Have a large enough capacity to fit in every number as a double
ByteBuffer byteBuffer = ByteBuffer.allocate(numbers.length * (Double.SIZE / Byte.SIZE))
.order(ByteOrder.nativeOrder());
for (int i = 0; i < numbers.length; ++i) {
Number value = numbers[i];
Class<? extends Number> klass = value.getClass();
if (VERBOSE) Log.v(TAG, "toByteArray - number " + i + ", class " + klass);
if (klass == Integer.class) {
byteBuffer.putInt((Integer)value);
} else if (klass == Float.class) {
byteBuffer.putFloat((Float)value);
} else if (klass == Double.class) {
byteBuffer.putDouble((Double)value);
} else if (klass == Short.class) {
byteBuffer.putShort((Short)value);
} else if (klass == Long.class) {
byteBuffer.putLong((Long)value);
} else if (klass == Byte.class) {
byteBuffer.put((Byte)value);
} else {
throw new IllegalArgumentException(
"number class invalid; must be wrapper around primitive class");
}
}
if (VERBOSE) Log.v(TAG, "toByteArray - end of loop");
// Each number written is at least 1 byte, so the position should be at least length
if (numbers.length != 0 && byteBuffer.position() < numbers.length) {
throw new AssertionError(String.format(
"Had %d numbers, but byte buffer position was only %d",
numbers.length, byteBuffer.position()));
}
byteBuffer.flip();
byte[] bytes = new byte[byteBuffer.limit()];
byteBuffer.get(bytes);
if (VERBOSE) Log.v(TAG, "toByteArray - output: " + Arrays.toString(bytes));
return bytes;
}
private static <T> byte[] toByteArray(T array, int sizeOfTBits) {
@SuppressWarnings("unchecked")
Class<T> klass = (Class<T>) array.getClass();
if (!klass.isArray()) {
throw new IllegalArgumentException("array class must be an array");
}
int sizeOfT = sizeOfTBits / Byte.SIZE;
int byteLength = Array.getLength(array) * sizeOfT;
if (klass == byte[].class) {
// Always return a copy
return Arrays.copyOf((byte[])array, byteLength);
}
ByteBuffer byteBuffer = ByteBuffer.allocate(byteLength).order(ByteOrder.nativeOrder());
if (klass == int[].class) {
byteBuffer.asIntBuffer().put((int[])array);
} else if (klass == float[].class) {
byteBuffer.asFloatBuffer().put((float[])array);
} else if (klass == double[].class) {
byteBuffer.asDoubleBuffer().put((double[])array);
} else if (klass == short[].class) {
byteBuffer.asShortBuffer().put((short[])array);
} else if (klass == char[].class) {
byteBuffer.asCharBuffer().put((char[])array);
} else if (klass == long[].class) {
byteBuffer.asLongBuffer().put((long[])array);
} else {
throw new IllegalArgumentException("array class invalid; must be a primitive array");
}
return byteBuffer.array();
}
private ByteArrayHelpers() {
throw new AssertionError();
}
}

451
media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/unit/CameraMetadataTest.java
View File

@@ -16,18 +16,30 @@
package com.android.mediaframeworktest.unit;
import android.os.Parcel;
import android.test.suitebuilder.annotation.SmallTest;
import android.util.Range;
import android.util.SizeF;
import android.graphics.ImageFormat;
import android.graphics.Point;
import android.graphics.PointF;
import android.graphics.Rect;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CaptureResult;
import android.hardware.camera2.ColorSpaceTransform;
import android.hardware.camera2.Face;
import android.hardware.camera2.MeteringRectangle;
import android.hardware.camera2.Rational;
import android.hardware.camera2.ReprocessFormatsMap;
import android.hardware.camera2.RggbChannelVector;
import android.hardware.camera2.Size;
import android.hardware.camera2.StreamConfiguration;
import android.hardware.camera2.StreamConfigurationDuration;
import android.hardware.camera2.impl.CameraMetadataNative;
import android.hardware.camera2.marshal.impl.MarshalQueryableEnum;
import android.hardware.camera2.utils.TypeReference;
import static android.hardware.camera2.impl.CameraMetadataNative.*;
import static com.android.mediaframeworktest.unit.ByteArrayHelpers.*;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
@@ -43,7 +55,6 @@ import java.nio.ByteOrder;
public class CameraMetadataTest extends junit.framework.TestCase {
CameraMetadataNative mMetadata;
Parcel mParcel;
// Sections
static final int ANDROID_COLOR_CORRECTION = 0;
@@ -64,15 +75,11 @@ public class CameraMetadataTest extends junit.framework.TestCase {
@Override
public void setUp() {
mMetadata = new CameraMetadataNative();
mParcel = Parcel.obtain();
}
@Override
public void tearDown() throws Exception {
mMetadata = null;
mParcel.recycle();
mParcel = null;
}
@SmallTest
@@ -130,10 +137,14 @@ public class CameraMetadataTest extends junit.framework.TestCase {
@SmallTest
public void testGetTypeFromTag() {
assertEquals(TYPE_BYTE, CameraMetadataNative.getNativeType(ANDROID_COLOR_CORRECTION_MODE));
assertEquals(TYPE_RATIONAL, CameraMetadataNative.getNativeType(ANDROID_COLOR_CORRECTION_TRANSFORM));
assertEquals(TYPE_FLOAT, CameraMetadataNative.getNativeType(ANDROID_COLOR_CORRECTION_GAINS));
assertEquals(TYPE_BYTE, CameraMetadataNative.getNativeType(ANDROID_CONTROL_AE_ANTIBANDING_MODE));
assertEquals(TYPE_BYTE,
CameraMetadataNative.getNativeType(ANDROID_COLOR_CORRECTION_MODE));
assertEquals(TYPE_RATIONAL,
CameraMetadataNative.getNativeType(ANDROID_COLOR_CORRECTION_TRANSFORM));
assertEquals(TYPE_FLOAT,
CameraMetadataNative.getNativeType(ANDROID_COLOR_CORRECTION_GAINS));
assertEquals(TYPE_BYTE,
CameraMetadataNative.getNativeType(ANDROID_CONTROL_AE_ANTIBANDING_MODE));
assertEquals(TYPE_INT32,
CameraMetadataNative.getNativeType(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION));
@@ -215,35 +226,163 @@ public class CameraMetadataTest extends junit.framework.TestCase {
assertEquals(1, mMetadata.getEntryCount());
}
/**
* Format an array into a string with the {@code badIndex} highlighted with {@code **}.
*
* <p>Numbers are printed as hexadecimal values.</p>
*
* <p>Example: {@code "[hello, **world**]"} for a {@code string[]},
* or a {@code "[**0xFF**, 0xFF]"} for a {@code int[]}.</p>
*/
private static <T> String formatArray(T array, int badIndex) {
StringBuilder builder = new StringBuilder();
builder.append("[");
int len = Array.getLength(array);
for (int i = 0; i < len; ++i) {
Object elem = Array.get(array, i);
if (i == badIndex) {
builder.append("**");
}
if (elem instanceof Number) {
builder.append(String.format("%x", elem));
} else {
builder.append(elem);
}
if (i == badIndex) {
builder.append("**");
}
if (i != len - 1) {
builder.append(", ");
}
}
builder.append("]");
return builder.toString();
}
private static <T> void assertArrayEquals(T expected, T actual) {
assertEquals(Array.getLength(expected), Array.getLength(actual));
if (!expected.getClass().isArray() || !actual.getClass().isArray()) {
throw new IllegalArgumentException("expected, actual must both be arrays");
}
assertEquals("Array lengths must be equal",
Array.getLength(expected), Array.getLength(actual));
int len = Array.getLength(expected);
for (int i = 0; i < len; ++i) {
assertEquals(Array.get(expected, i), Array.get(actual, i));
Object expectedElement = Array.get(expected, i);
Object actualElement = Array.get(actual, i);
if (!expectedElement.equals(actualElement)) {
fail(String.format(
"element %d in array was not equal (expected %s, actual %s). "
+ "Arrays were: (expected %s, actual %s).",
i, expectedElement, actualElement,
formatArray(expected, i),
formatArray(actual, i)));
}
}
}
private <T> void checkKeyGetAndSet(String keyStr, Class<T> type, T value) {
assertFalse("Use checkKeyGetAndSetArray to compare array Keys", type.isArray());
Key<T> key = new Key<T>(keyStr, type);
private <T> void checkKeyGetAndSet(String keyStr, TypeReference<T> typeToken, T expected,
boolean reuse) {
Key<T> key = new Key<T>(keyStr, typeToken);
assertNull(mMetadata.get(key));
mMetadata.set(key, null);
assertNull(mMetadata.get(key));
mMetadata.set(key, value);
mMetadata.set(key, expected);
T actual = mMetadata.get(key);
assertEquals(value, actual);
if (typeToken.getRawType().isArray()) {
assertArrayEquals(expected, actual);
} else {
assertEquals(expected, actual);
}
if (reuse) {
// reset the key incase we want to use it again
mMetadata.set(key, null);
}
}
private <T> void checkKeyGetAndSetArray(String keyStr, Class<T> type, T value) {
assertTrue(type.isArray());
private <T> void checkKeyGetAndSet(String keyStr, TypeReference<T> typeToken, T expected) {
checkKeyGetAndSet(keyStr, typeToken, expected, /*reuse*/false);
}
Key<T> key = new Key<T>(keyStr, type);
private <T> void checkKeyGetAndSet(String keyStr, Class<T> type, T expected) {
checkKeyGetAndSet(keyStr, TypeReference.createSpecializedTypeReference(type), expected);
}
/**
* Ensure that the data survives a marshal/unmarshal round-trip;
* it must also be equal to the {@code expectedNative} byte array.
*
* <p>As a side-effect, the metadata value corresponding to the key is now set to
* {@code expected}.</p>
*
* @return key created with {@code keyName} and {@code T}
*/
private <T> Key<T> checkKeyMarshal(String keyName, TypeReference<T> typeReference,
T expected, byte[] expectedNative) {
Key<T> key = new Key<T>(keyName, typeReference);
mMetadata.set(key, null);
assertNull(mMetadata.get(key));
mMetadata.set(key, value);
assertArrayEquals(value, mMetadata.get(key));
// Write managed value -> make sure native bytes are what we expect
mMetadata.set(key, expected);
byte[] actualValues = mMetadata.readValues(key.getTag());
assertArrayEquals(expectedNative, actualValues);
// Write managed value -> make sure read-out managed value is what we expect
T actual = mMetadata.get(key);
if (typeReference.getRawType().isArray()) {
assertArrayEquals(expected, actual);
} else {
assertEquals(expected, actual);
}
// Write native bytes -> make sure read-out managed value is what we expect
mMetadata.writeValues(key.getTag(), expectedNative);
actual = mMetadata.get(key);
if (typeReference.getRawType().isArray()) {
assertArrayEquals(expected, actual);
} else {
assertEquals(expected, actual);
}
return key;
}
/**
* Ensure that the data survives a marshal/unmarshal round-trip;
* it must also be equal to the {@code expectedNative} byte array.
*
* <p>As a side-effect,
* the metadata value corresponding to the key is now set to {@code expected}.</p>
*
* @return key created with {@code keyName} and {@code T}
*/
private <T> Key<T> checkKeyMarshal(String keyName, T expected, byte[] expectedNative) {
@SuppressWarnings("unchecked")
Class<T> expectedClass = (Class<T>) expected.getClass();
return checkKeyMarshal(keyName,
TypeReference.createSpecializedTypeReference(expectedClass),
expected,
expectedNative);
}
@SmallTest
@@ -280,36 +419,36 @@ public class CameraMetadataTest extends junit.framework.TestCase {
@SmallTest
public void testReadWritePrimitiveArray() {
// int32 (n)
checkKeyGetAndSetArray("android.sensor.info.sensitivityRange", int[].class,
checkKeyGetAndSet("android.sensor.info.sensitivityRange", int[].class,
new int[] {
0xC0FFEE, 0xDEADF00D
});
// byte (n)
checkKeyGetAndSetArray("android.statistics.faceScores", byte[].class, new byte[] {
checkKeyGetAndSet("android.statistics.faceScores", byte[].class, new byte[] {
1, 2, 3, 4
});
// int64 (n)
checkKeyGetAndSetArray("android.scaler.availableProcessedMinDurations", long[].class,
checkKeyGetAndSet("android.scaler.availableProcessedMinDurations", long[].class,
new long[] {
0xABCD12345678FFFFL, 0x1234ABCD5678FFFFL, 0xFFFF12345678ABCDL
});
// float (n)
checkKeyGetAndSetArray("android.lens.info.availableApertures", float[].class,
checkKeyGetAndSet("android.lens.info.availableApertures", float[].class,
new float[] {
Float.MAX_VALUE, Float.MIN_NORMAL, Float.MIN_VALUE
});
// double (n) -- in particular double x 3
checkKeyGetAndSetArray("android.jpeg.gpsCoordinates", double[].class,
checkKeyGetAndSet("android.jpeg.gpsCoordinates", double[].class,
new double[] {
Double.MAX_VALUE, Double.MIN_NORMAL, Double.MIN_VALUE
});
// rational (n) -- in particular rational x 9
checkKeyGetAndSetArray("android.sensor.calibrationTransform1", Rational[].class,
checkKeyGetAndSet("android.sensor.calibrationTransform1", Rational[].class,
new Rational[] {
new Rational(1, 2), new Rational(3, 4), new Rational(5, 6),
new Rational(7, 8), new Rational(9, 10), new Rational(10, 11),
@@ -321,13 +460,12 @@ public class CameraMetadataTest extends junit.framework.TestCase {
*/
// bool (n) -- with TYPE_BYTE
checkKeyGetAndSetArray("android.control.aeLock", boolean[].class, new boolean[] {
checkKeyGetAndSet("android.control.aeLock", boolean[].class, new boolean[] {
true, false, true
});
// integer (n) -- with TYPE_BYTE
checkKeyGetAndSetArray("android.control.aeAvailableModes", int[].class, new int[] {
checkKeyGetAndSet("android.control.aeAvailableModes", int[].class, new int[] {
1, 2, 3, 4
});
}
@@ -345,7 +483,6 @@ public class CameraMetadataTest extends junit.framework.TestCase {
AUTO
}
// TODO: special values for the enum.
private enum AvailableFormat {
RAW_SENSOR,
YV12,
@@ -366,7 +503,7 @@ public class CameraMetadataTest extends junit.framework.TestCase {
AeAntibandingMode.AUTO);
// byte (n)
checkKeyGetAndSetArray("android.control.aeAvailableAntibandingModes",
checkKeyGetAndSet("android.control.aeAvailableAntibandingModes",
AeAntibandingMode[].class, new AeAntibandingMode[] {
AeAntibandingMode.OFF, AeAntibandingMode._50HZ, AeAntibandingMode._60HZ,
AeAntibandingMode.AUTO
@@ -376,7 +513,7 @@ public class CameraMetadataTest extends junit.framework.TestCase {
* Stranger cases that don't use byte enums
*/
// int (n)
checkKeyGetAndSetArray("android.scaler.availableFormats", AvailableFormat[].class,
checkKeyGetAndSet("android.scaler.availableFormats", AvailableFormat[].class,
new AvailableFormat[] {
AvailableFormat.RAW_SENSOR,
AvailableFormat.YV12,
@@ -389,7 +526,7 @@ public class CameraMetadataTest extends junit.framework.TestCase {
@SmallTest
public void testReadWriteEnumWithCustomValues() {
CameraMetadataNative.registerEnumValues(AeAntibandingMode.class, new int[] {
MarshalQueryableEnum.registerEnumValues(AeAntibandingMode.class, new int[] {
0,
10,
20,
@@ -401,15 +538,12 @@ public class CameraMetadataTest extends junit.framework.TestCase {
AeAntibandingMode.AUTO);
// byte (n)
checkKeyGetAndSetArray("android.control.aeAvailableAntibandingModes",
checkKeyGetAndSet("android.control.aeAvailableAntibandingModes",
AeAntibandingMode[].class, new AeAntibandingMode[] {
AeAntibandingMode.OFF, AeAntibandingMode._50HZ, AeAntibandingMode._60HZ,
AeAntibandingMode.AUTO
});
Key<AeAntibandingMode[]> aeAntibandingModeKey =
new Key<AeAntibandingMode[]>("android.control.aeAvailableAntibandingModes",
AeAntibandingMode[].class);
byte[] aeAntibandingModeValues = mMetadata.readValues(CameraMetadataNative
.getTag("android.control.aeAvailableAntibandingModes"));
byte[] expectedValues = new byte[] { 0, 10, 20, 30 };
@@ -420,7 +554,7 @@ public class CameraMetadataTest extends junit.framework.TestCase {
* Stranger cases that don't use byte enums
*/
// int (n)
CameraMetadataNative.registerEnumValues(AvailableFormat.class, new int[] {
MarshalQueryableEnum.registerEnumValues(AvailableFormat.class, new int[] {
0x20,
0x32315659,
0x11,
@@ -429,7 +563,7 @@ public class CameraMetadataTest extends junit.framework.TestCase {
0x21,
});
checkKeyGetAndSetArray("android.scaler.availableFormats", AvailableFormat[].class,
checkKeyGetAndSet("android.scaler.availableFormats", AvailableFormat[].class,
new AvailableFormat[] {
AvailableFormat.RAW_SENSOR,
AvailableFormat.YV12,
@@ -466,7 +600,7 @@ public class CameraMetadataTest extends junit.framework.TestCase {
checkKeyGetAndSet("android.jpeg.thumbnailSize", Size.class, new Size(123, 456));
// int32 x 2 x n
checkKeyGetAndSetArray("android.scaler.availableJpegSizes", Size[].class, new Size[] {
checkKeyGetAndSet("android.scaler.availableJpegSizes", Size[].class, new Size[] {
new Size(123, 456),
new Size(0xDEAD, 0xF00D),
new Size(0xF00, 0xB00)
@@ -474,16 +608,217 @@ public class CameraMetadataTest extends junit.framework.TestCase {
}
@SmallTest
public void testReadWriteRectangle() {
public void testReadWriteRggbChannelVector() {
// int32 x n
checkKeyGetAndSet("android.scaler.cropRegion", Rect.class, new Rect(10, 11, 1280, 1024));
checkKeyMarshal("android.colorCorrection.gains",
new RggbChannelVector(1.0f, 2.1f, 3.2f, 4.5f),
toByteArray(1.0f, 2.1f, 3.2f, 4.5f));
// int32 x 2 x n [pretend; actual is not array]
checkKeyMarshal("android.colorCorrection.gains",
new RggbChannelVector[] {
new RggbChannelVector(1.0f, 2.0f, 3.0f, 4.0f),
new RggbChannelVector(9.0f, 8.0f, 7.0f, 6.0f),
new RggbChannelVector(1.3f, 5.5f, 2.4f, 6.7f),
}, toByteArray(
1.0f, 2.0f, 3.0f, 4.0f,
9.0f, 8.0f, 7.0f, 6.0f,
1.3f, 5.5f, 2.4f, 6.7f
));
}
@SmallTest
public void testReadWriteSizeF() {
// int32 x n
checkKeyMarshal("android.sensor.info.physicalSize",
new SizeF(123f, 456f),
toByteArray(123f, 456f));
// int32 x 2 x n
checkKeyGetAndSetArray("android.statistics.faceRectangles", Rect[].class, new Rect[] {
checkKeyMarshal("android.sensor.info.physicalSize",
new SizeF[] {
new SizeF(123f, 456f),
new SizeF(1.234f, 4.567f),
new SizeF(999.0f, 555.0f)
},
toByteArray(
123f, 456f,
1.234f, 4.567f,
999.0f, 555.0f)
);
}
@SmallTest
public void testReadWriteRectangle() {
// int32 x n
checkKeyMarshal("android.scaler.cropRegion",
// x1, y1, x2, y2
new Rect(10, 11, 1280, 1024),
// x, y, width, height
toByteArray(10, 11, 1280 - 10, 1024 - 11));
// int32 x 2 x n [actually not array, but we pretend it is]
checkKeyMarshal("android.scaler.cropRegion", new Rect[] {
new Rect(110, 111, 11280, 11024),
new Rect(210, 111, 21280, 21024),
new Rect(310, 111, 31280, 31024)
});
}, toByteArray(
110, 111, 11280 - 110, 11024 - 111,
210, 111, 21280 - 210, 21024 - 111,
310, 111, 31280 - 310, 31024 - 111
));
}
@SmallTest
public void testReadWriteMeteringRectangle() {
// int32 x 5 x area_count [but we pretend it's a single element]
checkKeyMarshal("android.control.aeRegions",
new MeteringRectangle(/*x*/1, /*y*/2, /*width*/100, /*height*/200, /*weight*/5),
/* xmin, ymin, xmax, ymax, weight */
toByteArray(1, 2, 1 + 100, 2 + 200, 5));
// int32 x 5 x area_count
checkKeyMarshal("android.control.afRegions",
new MeteringRectangle[] {
new MeteringRectangle(/*x*/5, /*y*/6, /*width*/123, /*height*/456, /*weight*/7),
new MeteringRectangle(/*x*/7, /*y*/8, /*width*/456, /*height*/999, /*weight*/6),
new MeteringRectangle(/*x*/1, /*y*/2, /*width*/100, /*height*/200, /*weight*/5)
},
toByteArray(
5, 6, 5 + 123, 6 + 456, 7,
7, 8, 7 + 456, 8 + 999, 6,
1, 2, 1 + 100, 2 + 200, 5
));
}
@SmallTest
public void testReadWriteColorSpaceTransform() {
// rational x 3 x 3
checkKeyMarshal("android.colorCorrection.transform",
new ColorSpaceTransform(new Rational[] {
new Rational(1, 2), new Rational(3, 4), new Rational(5, 6),
new Rational(7, 8), new Rational(8, 9), new Rational(10, 11),
new Rational(1, 5), new Rational(2, 8), new Rational(3, 9),
}),
toByteArray(
1, 2, 3, 4, 5, 6,
7, 8, 8, 9, 10, 11,
1, 5, 2, 8, 3, 9));
}
@SmallTest
public void testReadWritePoint() {
// int32 x 2 [actually 'x n' but pretend it's a single value for now]
checkKeyMarshal("android.statistics.hotPixelMap",
new Point(1, 2),
toByteArray(1, 2));
// int32 x 2 x samples
checkKeyMarshal("android.statistics.hotPixelMap",
new Point[] {
new Point(1, 2),
new Point(3, 4),
new Point(5, 6),
new Point(7, 8),
},
toByteArray(
1, 2,
3, 4,
5, 6,
7, 8)
);
}
@SmallTest
public void testReadWritePointF() {
// float x 2 [actually 'x samples' but pretend it's a single value for now]
checkKeyMarshal(
"android.sensor.profileToneCurve",
new PointF(1.0f, 2.0f),
toByteArray(1.0f, 2.0f));
// float x 2 x samples
checkKeyMarshal("android.sensor.profileToneCurve",
new PointF[] {
new PointF(1.0f, 2.0f),
new PointF(3.0f, 4.0f),
new PointF(5.0f, 6.0f),
new PointF(7.0f, 8.0f),
},
toByteArray(
1.0f, 2.0f,
3.0f, 4.0f,
5.0f, 6.0f,
7.0f, 8.0f));
}
@SmallTest
public void testReadWriteRange() {
// int32 x 2
checkKeyMarshal("android.control.aeTargetFpsRange",
new TypeReference<Range<Integer>>() {{ }},
Range.create(123, 456),
toByteArray(123, 456));
// int64 x 2
checkKeyMarshal("android.sensor.info.exposureTimeRange",
new TypeReference<Range<Long>>() {{ }},
Range.create(123L, 456L),
toByteArray(123L, 456L));
}
@SmallTest
public void testReadWriteStreamConfiguration() {
// int32 x 4 x n
checkKeyMarshal("android.scaler.availableStreamConfigurations",
new StreamConfiguration[] {
new StreamConfiguration(ImageFormat.YUV_420_888, 640, 480, /*input*/false),
new StreamConfiguration(ImageFormat.RGB_565, 320, 240, /*input*/true),
},
toByteArray(
ImageFormat.YUV_420_888, 640, 480, /*input*/0,
ImageFormat.RGB_565, 320, 240, /*input*/1)
);
}
@SmallTest
public void testReadWriteStreamConfigurationDuration() {
// Avoid sign extending ints when converting to a long
final long MASK_UNSIGNED_INT = 0x00000000ffffffffL;
// int64 x 4 x n
checkKeyMarshal("android.scaler.availableMinFrameDurations",
new StreamConfigurationDuration[] {
new StreamConfigurationDuration(
ImageFormat.YUV_420_888, 640, 480, /*duration*/123L),
new StreamConfigurationDuration(
ImageFormat.RGB_565, 320, 240, /*duration*/345L),
},
toByteArray(
ImageFormat.YUV_420_888 & MASK_UNSIGNED_INT, 640L, 480L, /*duration*/123L,
ImageFormat.RGB_565 & MASK_UNSIGNED_INT, 320L, 240L, /*duration*/345L)
);
}
@SmallTest
public void testReadWriteReprocessFormatsMap() {
final int RAW_OPAQUE = 0x24;
final int RAW16 = ImageFormat.RAW_SENSOR;
final int YUV_420_888 = ImageFormat.YUV_420_888;
final int BLOB = 0x21;
int[] contents = new int[] {
RAW_OPAQUE, 3, RAW16, YUV_420_888, BLOB,
RAW16, 2, YUV_420_888, BLOB,
};
// int32 x n
checkKeyMarshal("android.scaler.availableInputOutputFormatsMap",
new ReprocessFormatsMap(contents),
toByteArray(contents)
);
}
@SmallTest
@@ -525,10 +860,6 @@ public class CameraMetadataTest extends junit.framework.TestCase {
assertArrayEquals(gpsBytes, actualBytes2);
}
<T> void compareGeneric(T expected, T actual) {
assertEquals(expected, actual);
}
@SmallTest
public void testReadWriteOverride() {
//
@@ -691,7 +1022,7 @@ public class CameraMetadataTest extends junit.framework.TestCase {
*/
private <T> void validateArrayMetadataReadWriteOverride(Key<T> key, T writeValues,
T readValues, int tag) {
Class<T> type = key.getType();
Class<?> type = writeValues.getClass();
if (!type.isArray()) {
throw new IllegalArgumentException("This function expects an key with array type");
} else if (type != int[].class && type != long[].class) {
@@ -737,4 +1068,20 @@ public class CameraMetadataTest extends junit.framework.TestCase {
assertNotNull(key.getName() + " result shouldn't be null", result);
assertArrayEquals(writeValues, result);
}
// TODO: move somewhere else
@SmallTest
public void testToByteArray() {
assertArrayEquals(new byte[] { 5, 0, 0, 0, 6, 0, 0, 0 },
toByteArray(5, 6));
assertArrayEquals(new byte[] { 5, 0, 6, 0, },
toByteArray((short)5, (short)6));
assertArrayEquals(new byte[] { (byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF,
(byte)0xFF, (byte)0xFF, (byte)0xFF, (byte)0xFF,},
toByteArray(~0, ~0));
assertArrayEquals(new byte[] { (byte)0xAB, (byte)0xFF, 0, 0,
0x0D, (byte)0xF0, (byte)0xAD, (byte)0xDE },
toByteArray(0xFFAB, 0xDEADF00D));
}
}

223
media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/unit/CameraUtilsTypeReferenceTest.java Normal file
View File

@@ -0,0 +1,223 @@
/*
* Copyright (C) 2014 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 com.android.mediaframeworktest.unit;
import static android.hardware.camera2.utils.TypeReference.*;
import android.hardware.camera2.utils.TypeReference;
import android.test.suitebuilder.annotation.SmallTest;
import android.util.Log;
import java.lang.reflect.Type;
import java.util.List;
public class CameraUtilsTypeReferenceTest extends junit.framework.TestCase {
private static final String TAG = CameraUtilsTypeReferenceTest.class.getSimpleName();
private static final boolean VERBOSE = false;
private class RegularClass {}
private class SubClass extends RegularClass {}
private class GenericClass<T> {}
private class SubGenericClass<T> extends GenericClass<T> {}
private class SpecificClass extends GenericClass<Integer> {}
private interface RegularInterface {}
private interface GenericInterface<T> {}
private interface GenericInterface2<T> {}
private class ImplementsRegularInterface implements RegularInterface {}
private class ImplementsGenericInterface<T> implements GenericInterface<T> {}
private class Implements2GenericInterface<T>
implements GenericInterface<Integer>, GenericInterface2<T> {}
private class GenericOuterClass<T> {
class GenericInnerClass {
@SuppressWarnings("unused")
T field;
}
}
private static void assertContainsTypeVariable(Type type) {
assertTrue(type.toString() + " was expected to have a type variable, but it didn't",
containsTypeVariable(type));
}
private static void assertLacksTypeVariable(Type type) {
assertFalse(type.toString() + " was expected to *not* have a type variable, but it did",
containsTypeVariable(type));
}
/*
* Only test classes and interfaces. Other types are not tested (e.g. fields, methods, etc).
*/
@SmallTest
public void testLacksTypeVariables() {
assertLacksTypeVariable(RegularClass.class);
assertLacksTypeVariable(SubClass.class);
assertLacksTypeVariable(SpecificClass.class);
assertLacksTypeVariable(RegularInterface.class);
assertLacksTypeVariable(ImplementsRegularInterface.class);
}
@SmallTest
public void testContainsTypeVariables() {
assertContainsTypeVariable(GenericClass.class);
assertContainsTypeVariable(SubGenericClass.class);
assertContainsTypeVariable(GenericInterface.class);
assertContainsTypeVariable(ImplementsGenericInterface.class);
assertContainsTypeVariable(Implements2GenericInterface.class);
assertContainsTypeVariable(GenericOuterClass.class);
assertContainsTypeVariable(GenericOuterClass.GenericInnerClass.class);
}
/**
* This should always throw an IllegalArgumentException since the
* type reference to {@code T} will contain a type variable (also {@code T}).
*
* @throws IllegalArgumentException unconditionally
*/
private static <T> TypeReference<T> createTypeRefWithTypeVar() {
return new TypeReference<T>() {{ }};
}
@SmallTest
public void testTypeReferences() {
TypeReference<Integer> typeRefInt = new TypeReference<Integer>() {{ }};
TypeReference<Integer> typeRefInt2 = new TypeReference<Integer>() {{ }};
assertEquals(typeRefInt, typeRefInt2);
assertEquals("The type ref's captured type should be the Integer class",
Integer.class, typeRefInt.getType());
TypeReference<Float> typeRefFloat = new TypeReference<Float>() {{ }};
assertFalse("Integer/Float type references must not be equal",
typeRefInt.equals(typeRefFloat));
assertEquals("The type ref's captured type should be the Float class",
Float.class, typeRefFloat.getType());
try {
TypeReference<Integer> typeRefTypeVar = createTypeRefWithTypeVar();
fail("Expected a type reference with type variables to fail");
// Unreachable. Make the warning about an unused variable go away.
assertFalse(typeRefTypeVar.equals(typeRefInt));
} catch (IllegalArgumentException e) {
// OK. Expected behavior
}
}
// Compare the raw type against rawClass
private static <T> void assertRawTypeEquals(TypeReference<T> typeRef, Class<?> rawClass) {
assertEquals("Expected the raw type from " + typeRef + " to match the class " + rawClass,
rawClass, typeRef.getRawType());
}
// Compare the normal type against the klass
private static <T> void assertTypeReferenceEquals(TypeReference<T> typeRef, Class<?> klass) {
assertEquals("Expected the type from " + typeRef + " to match the class " + klass,
klass, typeRef.getType());
}
@SmallTest
public void testRawTypes() {
TypeReference<Integer> intToken = new TypeReference<Integer>() {{ }};
assertRawTypeEquals(intToken, Integer.class);
TypeReference<List<Integer>> listToken = new TypeReference<List<Integer>>() {{ }};
assertRawTypeEquals(listToken, List.class);
TypeReference<List<List<Integer>>> listListToken =
new TypeReference<List<List<Integer>>>() {{ }};
assertRawTypeEquals(listListToken, List.class);
TypeReference<int[]> intArrayToken = new TypeReference<int[]>() {{ }};
assertRawTypeEquals(intArrayToken, int[].class);
TypeReference<Integer[]> integerArrayToken = new TypeReference<Integer[]>() {{ }};
assertRawTypeEquals(integerArrayToken, Integer[].class);
TypeReference<List<Integer>[]> listArrayToken = new TypeReference<List<Integer>[]>() {{ }};
assertRawTypeEquals(listArrayToken, List[].class);
}
private class IntTokenOne extends TypeReference<Integer> {}
private class IntTokenTwo extends TypeReference<Integer> {}
private class IntArrayToken1 extends TypeReference<Integer[]> {}
private class IntArrayToken2 extends TypeReference<Integer[]> {}
private class IntListToken1 extends TypeReference<List<Integer>> {}
private class IntListToken2 extends TypeReference<List<Integer>> {}
private class IntListArrayToken1 extends TypeReference<List<Integer>[]> {}
private class IntListArrayToken2 extends TypeReference<List<Integer>[]> {}
// FIXME: Equality will fail: b/14590652
@SmallTest
public void testEquals() {
// Not an array. component type should be null.
TypeReference<Integer> intToken = new TypeReference<Integer>() {{ }};
assertEquals(intToken, intToken);
assertEquals(intToken, new TypeReference<Integer>() {{ }});
assertEquals(intToken, new IntTokenOne());
assertEquals(intToken, new IntTokenTwo());
assertEquals(new IntTokenOne(), new IntTokenTwo());
assertEquals(new IntArrayToken1(), new IntArrayToken2());
assertEquals(new IntListToken1(), new IntListToken2());
assertEquals(new IntListArrayToken1(), new IntListArrayToken2());
}
@SmallTest
public void testComponentType() {
// Not an array. component type should be null.
TypeReference<Integer> intToken = new TypeReference<Integer>() {{ }};
assertNull(intToken.getComponentType());
TypeReference<List<Integer>> listToken = new TypeReference<List<Integer>>() {{ }};
assertNull(listToken.getComponentType());
TypeReference<List<List<Integer>>> listListToken =
new TypeReference<List<List<Integer>>>() {{ }};
assertNull(listListToken.getComponentType());
// Check arrays. Component types should be what we expect.
TypeReference<int[]> intArrayToken = new TypeReference<int[]>() {{ }};
assertTypeReferenceEquals(intArrayToken.getComponentType(), int.class);
TypeReference<Integer[]> integerArrayToken = new TypeReference<Integer[]>() {{ }};
assertTypeReferenceEquals(integerArrayToken.getComponentType(), Integer.class);
assertEquals(new IntArrayToken1().getComponentType(),
new IntArrayToken2().getComponentType());
assertEquals(new IntListArrayToken1().getComponentType(),
new IntListArrayToken2().getComponentType());
// FIXME: Equality will fail: b/14590652
TypeReference<List<Integer>[]> listArrayToken = new TypeReference<List<Integer>[]>() {{ }};
assertEquals(listToken, listArrayToken.getComponentType());
}
}