| /* |
| * 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 com.android.camera2.its; |
| |
| import android.graphics.Point; |
| import android.graphics.Rect; |
| import android.hardware.camera2.CameraCharacteristics; |
| import android.hardware.camera2.CameraDevice; |
| import android.hardware.camera2.CameraMetadata; |
| import android.hardware.camera2.CaptureResult; |
| import android.hardware.camera2.CaptureRequest; |
| import android.hardware.camera2.TotalCaptureResult; |
| import android.hardware.camera2.params.BlackLevelPattern; |
| import android.hardware.camera2.params.ColorSpaceTransform; |
| import android.hardware.camera2.params.Face; |
| import android.hardware.camera2.params.LensShadingMap; |
| import android.hardware.camera2.params.MeteringRectangle; |
| import android.hardware.camera2.params.RggbChannelVector; |
| import android.hardware.camera2.params.StreamConfigurationMap; |
| import android.hardware.camera2.params.TonemapCurve; |
| import android.location.Location; |
| import android.util.Log; |
| import android.util.Pair; |
| import android.util.Rational; |
| import android.util.Size; |
| import android.util.SizeF; |
| import android.util.Range; |
| |
| import org.json.JSONArray; |
| import org.json.JSONObject; |
| |
| import java.lang.reflect.Array; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.GenericArrayType; |
| import java.lang.reflect.Modifier; |
| import java.lang.reflect.ParameterizedType; |
| import java.lang.reflect.Type; |
| import java.util.Arrays; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| /** |
| * Class to deal with serializing and deserializing between JSON and Camera2 objects. |
| */ |
| public class ItsSerializer { |
| public static final String TAG = ItsSerializer.class.getSimpleName(); |
| |
| private static class MetadataEntry { |
| public MetadataEntry(String k, Object v) { |
| key = k; |
| value = v; |
| } |
| public String key; |
| public Object value; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeRational(Rational rat) throws org.json.JSONException { |
| JSONObject ratObj = new JSONObject(); |
| ratObj.put("numerator", rat.getNumerator()); |
| ratObj.put("denominator", rat.getDenominator()); |
| return ratObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeSize(Size size) throws org.json.JSONException { |
| JSONObject sizeObj = new JSONObject(); |
| sizeObj.put("width", size.getWidth()); |
| sizeObj.put("height", size.getHeight()); |
| return sizeObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeSizeF(SizeF size) throws org.json.JSONException { |
| JSONObject sizeObj = new JSONObject(); |
| sizeObj.put("width", size.getWidth()); |
| sizeObj.put("height", size.getHeight()); |
| return sizeObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeRect(Rect rect) throws org.json.JSONException { |
| JSONObject rectObj = new JSONObject(); |
| rectObj.put("left", rect.left); |
| rectObj.put("right", rect.right); |
| rectObj.put("top", rect.top); |
| rectObj.put("bottom", rect.bottom); |
| return rectObj; |
| } |
| |
| private static Object serializePoint(Point point) throws org.json.JSONException { |
| JSONObject pointObj = new JSONObject(); |
| pointObj.put("x", point.x); |
| pointObj.put("y", point.y); |
| return pointObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeFace(Face face) |
| throws org.json.JSONException { |
| JSONObject faceObj = new JSONObject(); |
| faceObj.put("bounds", serializeRect(face.getBounds())); |
| faceObj.put("score", face.getScore()); |
| faceObj.put("id", face.getId()); |
| faceObj.put("leftEye", serializePoint(face.getLeftEyePosition())); |
| faceObj.put("rightEye", serializePoint(face.getRightEyePosition())); |
| faceObj.put("mouth", serializePoint(face.getMouthPosition())); |
| return faceObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeStreamConfigurationMap( |
| StreamConfigurationMap map) |
| throws org.json.JSONException { |
| // TODO: Serialize the rest of the StreamConfigurationMap fields. |
| JSONObject mapObj = new JSONObject(); |
| JSONArray cfgArray = new JSONArray(); |
| int fmts[] = map.getOutputFormats(); |
| if (fmts != null) { |
| for (int fi = 0; fi < Array.getLength(fmts); fi++) { |
| Size sizes[] = map.getOutputSizes(fmts[fi]); |
| if (sizes != null) { |
| for (int si = 0; si < Array.getLength(sizes); si++) { |
| JSONObject obj = new JSONObject(); |
| obj.put("format", fmts[fi]); |
| obj.put("width",sizes[si].getWidth()); |
| obj.put("height", sizes[si].getHeight()); |
| obj.put("input", false); |
| obj.put("minFrameDuration", |
| map.getOutputMinFrameDuration(fmts[fi],sizes[si])); |
| cfgArray.put(obj); |
| } |
| } |
| } |
| } |
| mapObj.put("availableStreamConfigurations", cfgArray); |
| return mapObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeMeteringRectangle(MeteringRectangle rect) |
| throws org.json.JSONException { |
| JSONObject rectObj = new JSONObject(); |
| rectObj.put("x", rect.getX()); |
| rectObj.put("y", rect.getY()); |
| rectObj.put("width", rect.getWidth()); |
| rectObj.put("height", rect.getHeight()); |
| rectObj.put("weight", rect.getMeteringWeight()); |
| return rectObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializePair(Pair pair) |
| throws org.json.JSONException { |
| JSONArray pairObj = new JSONArray(); |
| pairObj.put(pair.first); |
| pairObj.put(pair.second); |
| return pairObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeRange(Range range) |
| throws org.json.JSONException { |
| JSONArray rangeObj = new JSONArray(); |
| rangeObj.put(range.getLower()); |
| rangeObj.put(range.getUpper()); |
| return rangeObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeColorSpaceTransform(ColorSpaceTransform xform) |
| throws org.json.JSONException { |
| JSONArray xformObj = new JSONArray(); |
| for (int row = 0; row < 3; row++) { |
| for (int col = 0; col < 3; col++) { |
| xformObj.put(serializeRational(xform.getElement(col,row))); |
| } |
| } |
| return xformObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeTonemapCurve(TonemapCurve curve) |
| throws org.json.JSONException { |
| JSONObject curveObj = new JSONObject(); |
| String names[] = {"red", "green", "blue"}; |
| for (int ch = 0; ch < 3; ch++) { |
| JSONArray curveArr = new JSONArray(); |
| int len = curve.getPointCount(ch); |
| for (int i = 0; i < len; i++) { |
| curveArr.put(curve.getPoint(ch,i).x); |
| curveArr.put(curve.getPoint(ch,i).y); |
| } |
| curveObj.put(names[ch], curveArr); |
| } |
| return curveObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeRggbChannelVector(RggbChannelVector vec) |
| throws org.json.JSONException { |
| JSONArray vecObj = new JSONArray(); |
| vecObj.put(vec.getRed()); |
| vecObj.put(vec.getGreenEven()); |
| vecObj.put(vec.getGreenOdd()); |
| vecObj.put(vec.getBlue()); |
| return vecObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeBlackLevelPattern(BlackLevelPattern pat) |
| throws org.json.JSONException { |
| int patVals[] = new int[4]; |
| pat.copyTo(patVals, 0); |
| JSONArray patObj = new JSONArray(); |
| patObj.put(patVals[0]); |
| patObj.put(patVals[1]); |
| patObj.put(patVals[2]); |
| patObj.put(patVals[3]); |
| return patObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeLocation(Location loc) |
| throws org.json.JSONException { |
| return loc.toString(); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static Object serializeLensShadingMap(LensShadingMap map) |
| throws org.json.JSONException { |
| JSONArray mapObj = new JSONArray(); |
| for (int row = 0; row < map.getRowCount(); row++) { |
| for (int col = 0; col < map.getColumnCount(); col++) { |
| for (int ch = 0; ch < 4; ch++) { |
| mapObj.put(map.getGainFactor(ch, col, row)); |
| } |
| } |
| } |
| return mapObj; |
| } |
| |
| private static String getKeyName(Object keyObj) throws ItsException { |
| if (keyObj.getClass() == CaptureResult.Key.class |
| || keyObj.getClass() == TotalCaptureResult.class) { |
| return ((CaptureResult.Key)keyObj).getName(); |
| } else if (keyObj.getClass() == CaptureRequest.Key.class) { |
| return ((CaptureRequest.Key)keyObj).getName(); |
| } else if (keyObj.getClass() == CameraCharacteristics.Key.class) { |
| return ((CameraCharacteristics.Key)keyObj).getName(); |
| } |
| throw new ItsException("Invalid key object"); |
| } |
| |
| private static Object getKeyValue(CameraMetadata md, Object keyObj) throws ItsException { |
| if (md.getClass() == CaptureResult.class || md.getClass() == TotalCaptureResult.class) { |
| return ((CaptureResult)md).get((CaptureResult.Key)keyObj); |
| } else if (md.getClass() == CaptureRequest.class) { |
| return ((CaptureRequest)md).get((CaptureRequest.Key)keyObj); |
| } else if (md.getClass() == CameraCharacteristics.class) { |
| return ((CameraCharacteristics)md).get((CameraCharacteristics.Key)keyObj); |
| } |
| throw new ItsException("Invalid key object"); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static MetadataEntry serializeEntry(Type keyType, Object keyObj, CameraMetadata md) |
| throws ItsException { |
| String keyName = getKeyName(keyObj); |
| |
| try { |
| Object keyValue = getKeyValue(md, keyObj); |
| if (keyValue == null) { |
| return new MetadataEntry(keyName, JSONObject.NULL); |
| } else if (keyType == Float.class) { |
| // The JSON serializer doesn't handle floating point NaN or Inf. |
| if (((Float)keyValue).isInfinite() || ((Float)keyValue).isNaN()) { |
| Logt.w(TAG, "Inf/NaN floating point value serialized: " + keyName); |
| return null; |
| } |
| return new MetadataEntry(keyName, keyValue); |
| } else if (keyType == Integer.class || keyType == Long.class || keyType == Byte.class || |
| keyType == Boolean.class || keyType == String.class) { |
| return new MetadataEntry(keyName, keyValue); |
| } else if (keyType == Rational.class) { |
| return new MetadataEntry(keyName, serializeRational((Rational)keyValue)); |
| } else if (keyType == Size.class) { |
| return new MetadataEntry(keyName, serializeSize((Size)keyValue)); |
| } else if (keyType == SizeF.class) { |
| return new MetadataEntry(keyName, serializeSizeF((SizeF)keyValue)); |
| } else if (keyType == Rect.class) { |
| return new MetadataEntry(keyName, serializeRect((Rect)keyValue)); |
| } else if (keyType == Face.class) { |
| return new MetadataEntry(keyName, serializeFace((Face)keyValue)); |
| } else if (keyType == StreamConfigurationMap.class) { |
| return new MetadataEntry(keyName, |
| serializeStreamConfigurationMap((StreamConfigurationMap)keyValue)); |
| } else if (keyType instanceof ParameterizedType && |
| ((ParameterizedType)keyType).getRawType() == Range.class) { |
| return new MetadataEntry(keyName, serializeRange((Range)keyValue)); |
| } else if (keyType == ColorSpaceTransform.class) { |
| return new MetadataEntry(keyName, |
| serializeColorSpaceTransform((ColorSpaceTransform)keyValue)); |
| } else if (keyType == MeteringRectangle.class) { |
| return new MetadataEntry(keyName, |
| serializeMeteringRectangle((MeteringRectangle)keyValue)); |
| } else if (keyType == Location.class) { |
| return new MetadataEntry(keyName, |
| serializeLocation((Location)keyValue)); |
| } else if (keyType == RggbChannelVector.class) { |
| return new MetadataEntry(keyName, |
| serializeRggbChannelVector((RggbChannelVector)keyValue)); |
| } else if (keyType == BlackLevelPattern.class) { |
| return new MetadataEntry(keyName, |
| serializeBlackLevelPattern((BlackLevelPattern)keyValue)); |
| } else if (keyType == TonemapCurve.class) { |
| return new MetadataEntry(keyName, |
| serializeTonemapCurve((TonemapCurve)keyValue)); |
| } else if (keyType == Point.class) { |
| return new MetadataEntry(keyName, |
| serializePoint((Point)keyValue)); |
| } else if (keyType == LensShadingMap.class) { |
| return new MetadataEntry(keyName, |
| serializeLensShadingMap((LensShadingMap)keyValue)); |
| } else { |
| Logt.w(TAG, String.format("Serializing unsupported key type: " + keyType)); |
| return null; |
| } |
| } catch (org.json.JSONException e) { |
| throw new ItsException("JSON error for key: " + keyName + ": ", e); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static MetadataEntry serializeArrayEntry(Type keyType, Object keyObj, CameraMetadata md) |
| throws ItsException { |
| String keyName = getKeyName(keyObj); |
| try { |
| Object keyValue = getKeyValue(md, keyObj); |
| if (keyValue == null) { |
| return new MetadataEntry(keyName, JSONObject.NULL); |
| } |
| int arrayLen = Array.getLength(keyValue); |
| Type elmtType = ((GenericArrayType)keyType).getGenericComponentType(); |
| if (elmtType == int.class || elmtType == float.class || elmtType == byte.class || |
| elmtType == long.class || elmtType == double.class || elmtType == boolean.class) { |
| return new MetadataEntry(keyName, new JSONArray(keyValue)); |
| } else if (elmtType == Rational.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeRational((Rational)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == Size.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeSize((Size)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == Rect.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeRect((Rect)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == Face.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeFace((Face)Array.get(keyValue, i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == StreamConfigurationMap.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeStreamConfigurationMap( |
| (StreamConfigurationMap)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType instanceof ParameterizedType && |
| ((ParameterizedType)elmtType).getRawType() == Range.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeRange((Range)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType instanceof ParameterizedType && |
| ((ParameterizedType)elmtType).getRawType() == Pair.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializePair((Pair)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == MeteringRectangle.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeMeteringRectangle( |
| (MeteringRectangle)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == Location.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeLocation((Location)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == RggbChannelVector.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeRggbChannelVector( |
| (RggbChannelVector)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == BlackLevelPattern.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializeBlackLevelPattern( |
| (BlackLevelPattern)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else if (elmtType == Point.class) { |
| JSONArray jsonArray = new JSONArray(); |
| for (int i = 0; i < arrayLen; i++) { |
| jsonArray.put(serializePoint((Point)Array.get(keyValue,i))); |
| } |
| return new MetadataEntry(keyName, jsonArray); |
| } else { |
| Logt.w(TAG, String.format("Serializing unsupported array type: " + elmtType)); |
| return null; |
| } |
| } catch (org.json.JSONException e) { |
| throw new ItsException("JSON error for key: " + keyName + ": ", e); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| public static JSONObject serialize(CameraMetadata md) |
| throws ItsException { |
| JSONObject jsonObj = new JSONObject(); |
| Field[] allFields = md.getClass().getDeclaredFields(); |
| if (md.getClass() == TotalCaptureResult.class) { |
| allFields = CaptureResult.class.getDeclaredFields(); |
| } |
| for (Field field : allFields) { |
| if (Modifier.isPublic(field.getModifiers()) && |
| Modifier.isStatic(field.getModifiers()) && |
| (field.getType() == CaptureRequest.Key.class |
| || field.getType() == CaptureResult.Key.class |
| || field.getType() == TotalCaptureResult.Key.class |
| || field.getType() == CameraCharacteristics.Key.class) && |
| field.getGenericType() instanceof ParameterizedType) { |
| ParameterizedType paramType = (ParameterizedType)field.getGenericType(); |
| Type[] argTypes = paramType.getActualTypeArguments(); |
| if (argTypes.length > 0) { |
| try { |
| Type keyType = argTypes[0]; |
| Object keyObj = field.get(md); |
| MetadataEntry entry; |
| if (keyType instanceof GenericArrayType) { |
| entry = serializeArrayEntry(keyType, keyObj, md); |
| } else { |
| entry = serializeEntry(keyType, keyObj, md); |
| } |
| |
| // TODO: Figure this weird case out. |
| // There is a weird case where the entry is non-null but the toString |
| // of the entry is null, and if this happens, the null-ness spreads like |
| // a virus and makes the whole JSON object null from the top level down. |
| // Not sure if it's a bug in the library or I'm just not using it right. |
| // Workaround by checking for this case explicitly and not adding the |
| // value to the jsonObj when it is detected. |
| if (entry != null && entry.key != null && entry.value != null |
| && entry.value.toString() == null) { |
| Logt.w(TAG, "Error encountered serializing value for key: " + entry.key); |
| } else if (entry != null) { |
| jsonObj.put(entry.key, entry.value); |
| } else { |
| // Ignore. |
| } |
| } catch (IllegalAccessException e) { |
| throw new ItsException( |
| "Access error for field: " + field + ": ", e); |
| } catch (org.json.JSONException e) { |
| throw new ItsException( |
| "JSON error for field: " + field + ": ", e); |
| } |
| } |
| } |
| } |
| return jsonObj; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public static CaptureRequest.Builder deserialize(CaptureRequest.Builder mdDefault, |
| JSONObject jsonReq) throws ItsException { |
| try { |
| Logt.i(TAG, "Parsing JSON capture request ..."); |
| |
| // Iterate over the CaptureRequest reflected fields. |
| CaptureRequest.Builder md = mdDefault; |
| Field[] allFields = CaptureRequest.class.getDeclaredFields(); |
| for (Field field : allFields) { |
| if (Modifier.isPublic(field.getModifiers()) && |
| Modifier.isStatic(field.getModifiers()) && |
| field.getType() == CaptureRequest.Key.class && |
| field.getGenericType() instanceof ParameterizedType) { |
| ParameterizedType paramType = (ParameterizedType)field.getGenericType(); |
| Type[] argTypes = paramType.getActualTypeArguments(); |
| if (argTypes.length > 0) { |
| CaptureRequest.Key key = (CaptureRequest.Key)field.get(md); |
| String keyName = key.getName(); |
| Type keyType = argTypes[0]; |
| |
| // For each reflected CaptureRequest entry, look inside the JSON object |
| // to see if it is being set. If it is found, remove the key from the |
| // JSON object. After this process, there should be no keys left in the |
| // JSON (otherwise an invalid key was specified). |
| |
| if (jsonReq.has(keyName) && !jsonReq.isNull(keyName)) { |
| if (keyType instanceof GenericArrayType) { |
| Type elmtType = |
| ((GenericArrayType)keyType).getGenericComponentType(); |
| JSONArray ja = jsonReq.getJSONArray(keyName); |
| Object val[] = new Object[ja.length()]; |
| for (int i = 0; i < ja.length(); i++) { |
| if (elmtType == int.class) { |
| Array.set(val, i, ja.getInt(i)); |
| } else if (elmtType == byte.class) { |
| Array.set(val, i, (byte)ja.getInt(i)); |
| } else if (elmtType == float.class) { |
| Array.set(val, i, (float)ja.getDouble(i)); |
| } else if (elmtType == long.class) { |
| Array.set(val, i, ja.getLong(i)); |
| } else if (elmtType == double.class) { |
| Array.set(val, i, ja.getDouble(i)); |
| } else if (elmtType == boolean.class) { |
| Array.set(val, i, ja.getBoolean(i)); |
| } else if (elmtType == String.class) { |
| Array.set(val, i, ja.getString(i)); |
| } else if (elmtType == Size.class){ |
| JSONObject obj = ja.getJSONObject(i); |
| Array.set(val, i, new Size( |
| obj.getInt("width"), obj.getInt("height"))); |
| } else if (elmtType == Rect.class) { |
| JSONObject obj = ja.getJSONObject(i); |
| Array.set(val, i, new Rect( |
| obj.getInt("left"), obj.getInt("top"), |
| obj.getInt("bottom"), obj.getInt("right"))); |
| } else if (elmtType == Rational.class) { |
| JSONObject obj = ja.getJSONObject(i); |
| Array.set(val, i, new Rational( |
| obj.getInt("numerator"), |
| obj.getInt("denominator"))); |
| } else if (elmtType == RggbChannelVector.class) { |
| JSONArray arr = ja.getJSONArray(i); |
| Array.set(val, i, new RggbChannelVector( |
| (float)arr.getDouble(0), |
| (float)arr.getDouble(1), |
| (float)arr.getDouble(2), |
| (float)arr.getDouble(3))); |
| } else if (elmtType == ColorSpaceTransform.class) { |
| JSONArray arr = ja.getJSONArray(i); |
| Rational xform[] = new Rational[9]; |
| for (int j = 0; j < 9; j++) { |
| xform[j] = new Rational( |
| arr.getJSONObject(j).getInt("numerator"), |
| arr.getJSONObject(j).getInt("denominator")); |
| } |
| Array.set(val, i, new ColorSpaceTransform(xform)); |
| } else if (elmtType == MeteringRectangle.class) { |
| JSONObject obj = ja.getJSONObject(i); |
| Array.set(val, i, new MeteringRectangle( |
| obj.getInt("x"), |
| obj.getInt("y"), |
| obj.getInt("width"), |
| obj.getInt("height"), |
| obj.getInt("weight"))); |
| } else { |
| throw new ItsException( |
| "Failed to parse key from JSON: " + keyName); |
| } |
| } |
| if (val != null) { |
| Logt.i(TAG, "Set: "+keyName+" -> "+Arrays.toString(val)); |
| md.set(key, val); |
| jsonReq.remove(keyName); |
| } |
| } else { |
| Object val = null; |
| if (keyType == Integer.class) { |
| val = jsonReq.getInt(keyName); |
| } else if (keyType == Byte.class) { |
| val = (byte)jsonReq.getInt(keyName); |
| } else if (keyType == Double.class) { |
| val = jsonReq.getDouble(keyName); |
| } else if (keyType == Long.class) { |
| val = jsonReq.getLong(keyName); |
| } else if (keyType == Float.class) { |
| val = (float)jsonReq.getDouble(keyName); |
| } else if (keyType == Boolean.class) { |
| val = jsonReq.getBoolean(keyName); |
| } else if (keyType == String.class) { |
| val = jsonReq.getString(keyName); |
| } else if (keyType == Size.class) { |
| JSONObject obj = jsonReq.getJSONObject(keyName); |
| val = new Size( |
| obj.getInt("width"), obj.getInt("height")); |
| } else if (keyType == Rect.class) { |
| JSONObject obj = jsonReq.getJSONObject(keyName); |
| val = new Rect( |
| obj.getInt("left"), obj.getInt("top"), |
| obj.getInt("right"), obj.getInt("bottom")); |
| } else if (keyType == Rational.class) { |
| JSONObject obj = jsonReq.getJSONObject(keyName); |
| val = new Rational(obj.getInt("numerator"), |
| obj.getInt("denominator")); |
| } else if (keyType == RggbChannelVector.class) { |
| JSONObject obj = jsonReq.optJSONObject(keyName); |
| JSONArray arr = jsonReq.optJSONArray(keyName); |
| if (arr != null) { |
| val = new RggbChannelVector( |
| (float)arr.getDouble(0), |
| (float)arr.getDouble(1), |
| (float)arr.getDouble(2), |
| (float)arr.getDouble(3)); |
| } else if (obj != null) { |
| val = new RggbChannelVector( |
| (float)obj.getDouble("red"), |
| (float)obj.getDouble("greenEven"), |
| (float)obj.getDouble("greenOdd"), |
| (float)obj.getDouble("blue")); |
| } else { |
| throw new ItsException("Invalid RggbChannelVector object"); |
| } |
| } else if (keyType == ColorSpaceTransform.class) { |
| JSONArray arr = jsonReq.getJSONArray(keyName); |
| Rational a[] = new Rational[9]; |
| for (int i = 0; i < 9; i++) { |
| a[i] = new Rational( |
| arr.getJSONObject(i).getInt("numerator"), |
| arr.getJSONObject(i).getInt("denominator")); |
| } |
| val = new ColorSpaceTransform(a); |
| } else if (keyType instanceof ParameterizedType && |
| ((ParameterizedType)keyType).getRawType() == Range.class && |
| ((ParameterizedType)keyType).getActualTypeArguments().length == 1 && |
| ((ParameterizedType)keyType).getActualTypeArguments()[0] == Integer.class) { |
| JSONArray arr = jsonReq.getJSONArray(keyName); |
| val = new Range<Integer>(arr.getInt(0), arr.getInt(1)); |
| } else { |
| throw new ItsException( |
| "Failed to parse key from JSON: " + |
| keyName + ", " + keyType); |
| } |
| if (val != null) { |
| Logt.i(TAG, "Set: " + keyName + " -> " + val); |
| md.set(key ,val); |
| jsonReq.remove(keyName); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // Ensure that there were no invalid keys in the JSON request object. |
| if (jsonReq.length() != 0) { |
| throw new ItsException("Invalid JSON key(s): " + jsonReq.toString()); |
| } |
| |
| Logt.i(TAG, "Parsing JSON capture request completed"); |
| return md; |
| } catch (java.lang.IllegalAccessException e) { |
| throw new ItsException("Access error: ", e); |
| } catch (org.json.JSONException e) { |
| throw new ItsException("JSON error: ", e); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| public static List<CaptureRequest.Builder> deserializeRequestList( |
| CameraDevice device, JSONObject jsonObjTop) |
| throws ItsException { |
| try { |
| List<CaptureRequest.Builder> requests = null; |
| JSONArray jsonReqs = jsonObjTop.getJSONArray("captureRequests"); |
| requests = new LinkedList<CaptureRequest.Builder>(); |
| for (int i = 0; i < jsonReqs.length(); i++) { |
| CaptureRequest.Builder templateReq = device.createCaptureRequest( |
| CameraDevice.TEMPLATE_STILL_CAPTURE); |
| requests.add( |
| deserialize(templateReq, jsonReqs.getJSONObject(i))); |
| } |
| return requests; |
| } catch (org.json.JSONException e) { |
| throw new ItsException("JSON error: ", e); |
| } catch (android.hardware.camera2.CameraAccessException e) { |
| throw new ItsException("Access error: ", e); |
| } |
| } |
| } |