Home | History | Annotate | Download | only in deviceinfo
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.cts.deviceinfo;
     17 
     18 import android.content.Context;
     19 import android.graphics.Rect;
     20 import android.hardware.Camera;
     21 import android.hardware.camera2.CameraAccessException;
     22 import android.hardware.camera2.CameraCharacteristics;
     23 import android.hardware.camera2.CameraManager;
     24 import android.hardware.camera2.params.BlackLevelPattern;
     25 import android.hardware.camera2.params.ColorSpaceTransform;
     26 import android.hardware.camera2.params.StreamConfigurationMap;
     27 import android.media.CamcorderProfile;
     28 import android.os.Build;
     29 import android.util.Log;
     30 import android.util.Rational;
     31 import android.util.Size;
     32 import android.util.SizeF;
     33 import android.util.Range;
     34 
     35 import com.android.compatibility.common.deviceinfo.DeviceInfo;
     36 import com.android.compatibility.common.util.DeviceInfoStore;
     37 
     38 import java.lang.reflect.Array;
     39 import java.lang.reflect.Field;
     40 import java.lang.reflect.GenericArrayType;
     41 import java.lang.reflect.Modifier;
     42 import java.lang.reflect.ParameterizedType;
     43 import java.lang.reflect.Type;
     44 import java.util.HashSet;
     45 import java.util.List;
     46 
     47 /**
     48  * Camera information collector.
     49  */
     50 public final class CameraDeviceInfo extends DeviceInfo {
     51     private static final String TAG = "CameraDeviceInfo";
     52 
     53     private final static class CameraCharacteristicsStorer {
     54         private CameraManager mCameraManager;
     55         private DeviceInfoStore mStore;
     56 
     57         public CameraCharacteristicsStorer(CameraManager cameraManager, DeviceInfoStore store) {
     58             if (cameraManager == null || store == null) {
     59                 throw new IllegalArgumentException("can not create an CameraMetadataGetter object"
     60                         + " with null CameraManager or null DeviceInfoStore");
     61             }
     62 
     63             mCameraManager = cameraManager;
     64             mStore = store;
     65         }
     66 
     67         public void storeCameraInfo(String cameraId) throws Exception {
     68             try {
     69                 CameraCharacteristics chars = mCameraManager.getCameraCharacteristics(cameraId);
     70                 mStore.startGroup(); // per camera chars
     71                 mStore.addResult("cameraId", cameraId);
     72                 storeCameraChars(chars);
     73                 mStore.endGroup(); // per camera chars
     74             } catch (CameraAccessException e) {
     75                 Log.e(TAG,
     76                         "Unable to get camera camera static info, skip this camera, error: "
     77                                 + e.getMessage());
     78             }
     79             return;
     80         }
     81 
     82         private void storeRational(
     83                 Rational rat, String protoName) throws Exception {
     84             if (protoName == null) {
     85                 mStore.startGroup();
     86             } else {
     87                 mStore.startGroup(protoName);
     88             }
     89             mStore.addResult("numerator", rat.getNumerator());
     90             mStore.addResult("denominator", rat.getDenominator());
     91             mStore.endGroup();
     92         }
     93 
     94         private void storeSize(
     95                 Size size, String protoName) throws Exception {
     96             if (protoName == null) {
     97                 mStore.startGroup();
     98             } else {
     99                 mStore.startGroup(protoName);
    100             }
    101             mStore.addResult("width", size.getWidth());
    102             mStore.addResult("height", size.getHeight());
    103             mStore.endGroup();
    104         }
    105 
    106         private void storeSizeF(
    107                 SizeF size, String protoName) throws Exception {
    108             if (protoName == null) {
    109                 mStore.startGroup();
    110             } else {
    111                 mStore.startGroup(protoName);
    112             }
    113             mStore.addResult("width", size.getWidth());
    114             mStore.addResult("height", size.getHeight());
    115             mStore.endGroup();
    116         }
    117 
    118         private void storeRect(
    119                 Rect rect, String protoName) throws Exception {
    120             if (protoName == null) {
    121                 mStore.startGroup();
    122             } else {
    123                 mStore.startGroup(protoName);
    124             }
    125             mStore.addResult("left", rect.left);
    126             mStore.addResult("right", rect.right);
    127             mStore.addResult("top", rect.top);
    128             mStore.addResult("bottom", rect.bottom);
    129             mStore.endGroup();
    130         }
    131 
    132         private void storeStreamConfigurationMap(
    133                 StreamConfigurationMap map, String protoName) throws Exception {
    134             if (protoName == null) {
    135                 mStore.startGroup();
    136             } else {
    137                 mStore.startGroup(protoName);
    138             }
    139 
    140             int fmts[] = map.getOutputFormats();
    141             if (fmts != null) {
    142                 mStore.startArray("availableStreamConfigurations");
    143                 for (int fi = 0; fi < Array.getLength(fmts); fi++) {
    144                     Size sizes[] = map.getOutputSizes(fmts[fi]);
    145                     if (sizes != null) {
    146                         for (int si = 0; si < Array.getLength(sizes); si++) {
    147                             mStore.startGroup();
    148                             mStore.addResult("format", fmts[fi]);
    149                             mStore.addResult("width", sizes[si].getWidth());
    150                             mStore.addResult("height", sizes[si].getHeight());
    151                             mStore.addResult("input", false);
    152                             mStore.addResult("minFrameDuration",
    153                                             map.getOutputMinFrameDuration(fmts[fi], sizes[si]));
    154                             mStore.endGroup();
    155                         }
    156                     }
    157                 }
    158                 mStore.endArray();
    159             }
    160             mStore.endGroup();
    161         }
    162 
    163         private void storeRangeInt(
    164                 Range<Integer> range, String protoName) throws Exception {
    165             if (protoName == null) {
    166                 mStore.startGroup();
    167             } else {
    168                 mStore.startGroup(protoName);
    169             }
    170             mStore.addResult("lower", range.getLower());
    171             mStore.addResult("upper", range.getUpper());
    172             mStore.endGroup();
    173         }
    174 
    175         private void storeRangeLong(
    176                 Range<Long> range, String protoName) throws Exception {
    177             if (protoName == null) {
    178                 mStore.startGroup();
    179             } else {
    180                 mStore.startGroup(protoName);
    181             }
    182             mStore.addResult("lower", range.getLower());
    183             mStore.addResult("upper", range.getUpper());
    184             mStore.endGroup();
    185         }
    186 
    187         private void storeColorSpaceTransform(
    188                 ColorSpaceTransform xform, String protoName) throws Exception {
    189             if (protoName == null) {
    190                 mStore.startGroup();
    191             } else {
    192                 mStore.startGroup(protoName);
    193             }
    194 
    195             mStore.startArray("elements");
    196             for (int row = 0; row < 3; row++) {
    197                 for (int col = 0; col < 3; col++) {
    198                     storeRational((Rational) xform.getElement(col, row), null);
    199                 }
    200             }
    201             mStore.endArray();
    202             mStore.endGroup();
    203         }
    204 
    205         private void storeBlackLevelPattern(
    206                 BlackLevelPattern pat, String protoName) throws Exception {
    207             if (protoName == null) {
    208                 mStore.startGroup();
    209             } else {
    210                 mStore.startGroup(protoName);
    211             }
    212             int patVals[] = new int[4];
    213             pat.copyTo(patVals, 0);
    214             mStore.addArrayResult("black_level_pattern", patVals);
    215             mStore.endGroup();
    216         }
    217 
    218         private static String getKeyName(Object keyObj) {
    219             return ((CameraCharacteristics.Key) keyObj).getName();
    220         }
    221 
    222         private static Object getKeyValue(CameraCharacteristics chars, Object keyObj) {
    223             return chars.get((CameraCharacteristics.Key) keyObj);
    224         }
    225 
    226         private void storeEntry(Type keyType, Object keyObj,
    227                 CameraCharacteristics chars) throws Exception {
    228             String keyName = getKeyName(keyObj);
    229             String protoName = keyName.replace('.', '_');
    230             Object keyValue = getKeyValue(chars, keyObj);
    231             if (keyValue == null) {
    232                 return;
    233             }
    234 
    235             if (keyType == int.class || keyType == Integer.class) {
    236                 mStore.addResult(protoName, (int) keyValue);
    237                 return;
    238             } else if (keyType == float.class || keyType == Float.class) {
    239                 mStore.addResult(protoName, (float) keyValue);
    240                 return;
    241             } else if (keyType == long.class || keyType == Long.class) {
    242                 mStore.addResult(protoName, (long) keyValue);
    243                 return;
    244             } else if (keyType == double.class || keyType == Double.class) {
    245                 mStore.addResult(protoName, (double) keyValue);
    246                 return;
    247             } else if (keyType == boolean.class || keyType == Boolean.class) {
    248                 mStore.addResult(protoName, (boolean) keyValue);
    249                 return;
    250             } else if (keyType == byte.class || keyType == Byte.class) {
    251                 // Infostore does not support byte, convert to int32 and save
    252                 int intValue = (int) ((byte) keyValue);
    253                 mStore.addResult(protoName, intValue);
    254                 return;
    255             } else if (keyType == Rational.class) {
    256                 storeRational((Rational) keyValue, protoName);
    257                 return;
    258             } else if (keyType == Size.class) {
    259                 storeSize((Size) keyValue, protoName);
    260                 return;
    261             } else if (keyType == SizeF.class) {
    262                 storeSizeF((SizeF) keyValue, protoName);
    263                 return;
    264             } else if (keyType == Rect.class) {
    265                 storeRect((Rect) keyValue, protoName);
    266                 return;
    267             } else if (keyType == StreamConfigurationMap.class) {
    268                 storeStreamConfigurationMap(
    269                         (StreamConfigurationMap) keyValue, protoName);
    270                 return;
    271             } else if (keyType instanceof ParameterizedType &&
    272                     ((ParameterizedType) keyType).getRawType() == Range.class &&
    273                     ((ParameterizedType) keyType).getActualTypeArguments()[0] == Integer.class) {
    274                 storeRangeInt((Range<Integer>) keyValue, protoName);
    275                 return;
    276             } else if (keyType instanceof ParameterizedType &&
    277                     ((ParameterizedType) keyType).getRawType() == Range.class &&
    278                     ((ParameterizedType) keyType).getActualTypeArguments()[0] == Long.class) {
    279                 storeRangeLong((Range<Long>) keyValue, protoName);
    280                 return;
    281             } else if (keyType == ColorSpaceTransform.class) {
    282                 storeColorSpaceTransform((ColorSpaceTransform) keyValue, protoName);
    283                 return;
    284             } else if (keyType == BlackLevelPattern.class) {
    285                 storeBlackLevelPattern((BlackLevelPattern) keyValue, protoName);
    286                 return;
    287             } else {
    288                 Log.w(TAG, "Storing unsupported key type: " + keyType +
    289                         " for keyName: " + keyName);
    290                 return;
    291             }
    292         }
    293 
    294         private void storeArrayEntry(Type keyType, Object keyObj,
    295                 CameraCharacteristics chars) throws Exception {
    296             String keyName = getKeyName(keyObj);
    297             String protoName = keyName.replace('.', '_');
    298             Object keyValue = getKeyValue(chars, keyObj);
    299             if (keyValue == null) {
    300                 return;
    301             }
    302 
    303             int arrayLen = Array.getLength(keyValue);
    304             if (arrayLen == 0) {
    305                 return;
    306             }
    307             Type elmtType = ((GenericArrayType) keyType).getGenericComponentType();
    308 
    309             if (elmtType == int.class) {
    310                 mStore.addArrayResult(protoName, (int[]) keyValue);
    311                 return;
    312             } else if (elmtType == float.class) {
    313                 mStore.addArrayResult(protoName, (float[]) keyValue);
    314                 return;
    315             } else if (elmtType == long.class) {
    316                 mStore.addArrayResult(protoName, (long[]) keyValue);
    317                 return;
    318             } else if (elmtType == double.class) {
    319                 mStore.addArrayResult(protoName, (double[]) keyValue);
    320                 return;
    321             } else if (elmtType == boolean.class) {
    322                 mStore.addArrayResult(protoName, (boolean[]) keyValue);
    323                 return;
    324             } else if (elmtType == byte.class) {
    325                 // Infostore does not support byte, convert to int32 and save
    326                 int[] intValues = new int[arrayLen];
    327                 for (int i = 0; i < arrayLen; i++) {
    328                     intValues[i] = (int) ((byte) Array.get(keyValue, i));
    329                 }
    330                 mStore.addArrayResult(protoName, intValues);
    331                 return;
    332             } else if (elmtType == Rational.class) {
    333                 mStore.startArray(protoName);
    334                 for (int i = 0; i < arrayLen; i++) {
    335                     storeRational((Rational) Array.get(keyValue, i), null);
    336                 }
    337                 mStore.endArray();
    338                 return;
    339             } else if (elmtType == Size.class) {
    340                 mStore.startArray(protoName);
    341                 for (int i = 0; i < arrayLen; i++) {
    342                     storeSize((Size) Array.get(keyValue, i), null);
    343                 }
    344                 mStore.endArray();
    345                 return;
    346             } else if (elmtType == Rect.class) {
    347                 mStore.startArray(protoName);
    348                 for (int i = 0; i < arrayLen; i++) {
    349                     storeRect((Rect) Array.get(keyValue, i), null);
    350                 }
    351                 mStore.endArray();
    352                 return;
    353             } else if (elmtType instanceof ParameterizedType &&
    354                     ((ParameterizedType) elmtType).getRawType() == Range.class &&
    355                     ((ParameterizedType) elmtType).getActualTypeArguments()[0] == Integer.class) {
    356                 mStore.startArray(protoName);
    357                 for (int i = 0; i < arrayLen; i++) {
    358                     storeRangeInt((Range<Integer>) Array.get(keyValue, i), null);
    359                 }
    360                 mStore.endArray();
    361                 return;
    362             } else if (elmtType == BlackLevelPattern.class) {
    363                 mStore.startArray(protoName);
    364                 for (int i = 0; i < arrayLen; i++) {
    365                     storeBlackLevelPattern((BlackLevelPattern) Array.get(keyValue, i), null);
    366                 }
    367                 mStore.endArray();
    368                 return;
    369             } else {
    370                 Log.w(TAG, "Storing unsupported array type: " + elmtType +
    371                         " for keyName: " + keyName);
    372                 return;
    373             }
    374         }
    375 
    376         private void storeCameraChars(
    377                 CameraCharacteristics chars) throws Exception {
    378             HashSet<String> charsKeyNames = getAllCharacteristicsKeyNames();
    379             Field[] allFields = chars.getClass().getDeclaredFields();
    380             for (Field field : allFields) {
    381                 if (Modifier.isPublic(field.getModifiers()) &&
    382                         Modifier.isStatic(field.getModifiers()) &&
    383                         field.getType() == CameraCharacteristics.Key.class &&
    384                         field.getGenericType() instanceof ParameterizedType) {
    385                     ParameterizedType paramType = (ParameterizedType) field.getGenericType();
    386                     Type[] argTypes = paramType.getActualTypeArguments();
    387                     if (argTypes.length > 0) {
    388                         try {
    389                             Type keyType = argTypes[0];
    390                             Object keyObj = field.get(chars);
    391                             String keyName = getKeyName(keyObj);
    392                             if (charsKeyNames.contains(keyName)) {
    393                                 if (keyType instanceof GenericArrayType) {
    394                                     storeArrayEntry(keyType, keyObj, chars);
    395                                 } else {
    396                                     storeEntry(keyType, keyObj, chars);
    397                                 }
    398                             }
    399                         } catch (IllegalAccessException e) {
    400                             throw new IllegalStateException(
    401                                     "Access error for field: " + field + ": ", e);
    402                         }
    403                     }
    404                 }
    405             }
    406         }
    407     }
    408 
    409 
    410     @Override
    411     protected void collectDeviceInfo(DeviceInfoStore store) throws Exception {
    412         store.addResult("profile_480p", CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_480P));
    413         store.addResult("profile_720p", CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_720P));
    414         store.addResult("profile_1080p", CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_1080P));
    415         store.addResult("profile_cif", CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_CIF));
    416         store.addResult("profile_qcif", CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_QCIF));
    417         store.addResult("profile_qvga", CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_QVGA));
    418 
    419         CameraManager cameraManager = (CameraManager)
    420                 getContext().getSystemService(Context.CAMERA_SERVICE);
    421         try {
    422             String[] cameraIdList = cameraManager.getCameraIdList();
    423             store.addResult("num_of_camera", cameraIdList.length);
    424             if (cameraIdList.length > 0) {
    425                 CameraCharacteristicsStorer charsStorer =
    426                         new CameraCharacteristicsStorer(cameraManager, store);
    427                 store.startArray("per_camera_info");
    428                 for (int i = 0; i < cameraIdList.length; i++) {
    429                     charsStorer.storeCameraInfo(cameraIdList[i]);
    430                 }
    431                 store.endArray(); // per_camera_info
    432             }
    433         } catch (CameraAccessException e) {
    434             Log.e(TAG,
    435                     "Unable to get camera camera ID list, error: "
    436                             + e.getMessage());
    437         }
    438     }
    439 
    440     /*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
    441      * The key entries below this point are generated from metadata
    442      * definitions in /system/media/camera/docs. Do not modify by hand or
    443      * modify the comment blocks at the start or end.
    444      *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~*/
    445 
    446     private static HashSet<String> getAllCharacteristicsKeyNames() {
    447         HashSet<String> charsKeyNames = new HashSet<String>();
    448         charsKeyNames.add(CameraCharacteristics.COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES.getName());
    449         charsKeyNames.add(CameraCharacteristics.CONTROL_AE_AVAILABLE_ANTIBANDING_MODES.getName());
    450         charsKeyNames.add(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES.getName());
    451         charsKeyNames.add(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES.getName());
    452         charsKeyNames.add(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE.getName());
    453         charsKeyNames.add(CameraCharacteristics.CONTROL_AE_COMPENSATION_STEP.getName());
    454         charsKeyNames.add(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES.getName());
    455         charsKeyNames.add(CameraCharacteristics.CONTROL_AVAILABLE_EFFECTS.getName());
    456         charsKeyNames.add(CameraCharacteristics.CONTROL_AVAILABLE_SCENE_MODES.getName());
    457         charsKeyNames.add(CameraCharacteristics.CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES.getName());
    458         charsKeyNames.add(CameraCharacteristics.CONTROL_AWB_AVAILABLE_MODES.getName());
    459         charsKeyNames.add(CameraCharacteristics.CONTROL_MAX_REGIONS_AE.getName());
    460         charsKeyNames.add(CameraCharacteristics.CONTROL_MAX_REGIONS_AWB.getName());
    461         charsKeyNames.add(CameraCharacteristics.CONTROL_MAX_REGIONS_AF.getName());
    462         charsKeyNames.add(CameraCharacteristics.CONTROL_AE_LOCK_AVAILABLE.getName());
    463         charsKeyNames.add(CameraCharacteristics.CONTROL_AWB_LOCK_AVAILABLE.getName());
    464         charsKeyNames.add(CameraCharacteristics.CONTROL_AVAILABLE_MODES.getName());
    465         charsKeyNames.add(CameraCharacteristics.CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE.getName());
    466         charsKeyNames.add(CameraCharacteristics.EDGE_AVAILABLE_EDGE_MODES.getName());
    467         charsKeyNames.add(CameraCharacteristics.FLASH_INFO_AVAILABLE.getName());
    468         charsKeyNames.add(CameraCharacteristics.HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES.getName());
    469         charsKeyNames.add(CameraCharacteristics.JPEG_AVAILABLE_THUMBNAIL_SIZES.getName());
    470         charsKeyNames.add(CameraCharacteristics.LENS_FACING.getName());
    471         charsKeyNames.add(CameraCharacteristics.LENS_POSE_REFERENCE.getName());
    472         charsKeyNames.add(CameraCharacteristics.LENS_INFO_AVAILABLE_APERTURES.getName());
    473         charsKeyNames.add(CameraCharacteristics.LENS_INFO_AVAILABLE_FILTER_DENSITIES.getName());
    474         charsKeyNames.add(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS.getName());
    475         charsKeyNames.add(CameraCharacteristics.LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION.getName());
    476         charsKeyNames.add(CameraCharacteristics.LENS_INFO_HYPERFOCAL_DISTANCE.getName());
    477         charsKeyNames.add(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE.getName());
    478         charsKeyNames.add(CameraCharacteristics.LENS_INFO_FOCUS_DISTANCE_CALIBRATION.getName());
    479         charsKeyNames.add(CameraCharacteristics.NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES.getName());
    480         charsKeyNames.add(CameraCharacteristics.REQUEST_MAX_NUM_OUTPUT_RAW.getName());
    481         charsKeyNames.add(CameraCharacteristics.REQUEST_MAX_NUM_OUTPUT_PROC.getName());
    482         charsKeyNames.add(CameraCharacteristics.REQUEST_MAX_NUM_OUTPUT_PROC_STALLING.getName());
    483         charsKeyNames.add(CameraCharacteristics.REQUEST_MAX_NUM_INPUT_STREAMS.getName());
    484         charsKeyNames.add(CameraCharacteristics.REQUEST_PIPELINE_MAX_DEPTH.getName());
    485         charsKeyNames.add(CameraCharacteristics.REQUEST_PARTIAL_RESULT_COUNT.getName());
    486         charsKeyNames.add(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES.getName());
    487         charsKeyNames.add(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM.getName());
    488         charsKeyNames.add(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP.getName());
    489         charsKeyNames.add(CameraCharacteristics.SCALER_CROPPING_TYPE.getName());
    490         charsKeyNames.add(CameraCharacteristics.SCALER_MANDATORY_STREAM_COMBINATIONS.getName());
    491         charsKeyNames.add(CameraCharacteristics.SENSOR_REFERENCE_ILLUMINANT1.getName());
    492         charsKeyNames.add(CameraCharacteristics.SENSOR_REFERENCE_ILLUMINANT2.getName());
    493         charsKeyNames.add(CameraCharacteristics.SENSOR_CALIBRATION_TRANSFORM1.getName());
    494         charsKeyNames.add(CameraCharacteristics.SENSOR_CALIBRATION_TRANSFORM2.getName());
    495         charsKeyNames.add(CameraCharacteristics.SENSOR_COLOR_TRANSFORM1.getName());
    496         charsKeyNames.add(CameraCharacteristics.SENSOR_COLOR_TRANSFORM2.getName());
    497         charsKeyNames.add(CameraCharacteristics.SENSOR_FORWARD_MATRIX1.getName());
    498         charsKeyNames.add(CameraCharacteristics.SENSOR_FORWARD_MATRIX2.getName());
    499         charsKeyNames.add(CameraCharacteristics.SENSOR_BLACK_LEVEL_PATTERN.getName());
    500         charsKeyNames.add(CameraCharacteristics.SENSOR_MAX_ANALOG_SENSITIVITY.getName());
    501         charsKeyNames.add(CameraCharacteristics.SENSOR_ORIENTATION.getName());
    502         charsKeyNames.add(CameraCharacteristics.SENSOR_AVAILABLE_TEST_PATTERN_MODES.getName());
    503         charsKeyNames.add(CameraCharacteristics.SENSOR_OPTICAL_BLACK_REGIONS.getName());
    504         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE.getName());
    505         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_SENSITIVITY_RANGE.getName());
    506         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_COLOR_FILTER_ARRANGEMENT.getName());
    507         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_EXPOSURE_TIME_RANGE.getName());
    508         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_MAX_FRAME_DURATION.getName());
    509         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE.getName());
    510         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE.getName());
    511         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_WHITE_LEVEL.getName());
    512         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_TIMESTAMP_SOURCE.getName());
    513         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_LENS_SHADING_APPLIED.getName());
    514         charsKeyNames.add(CameraCharacteristics.SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE.getName());
    515         charsKeyNames.add(CameraCharacteristics.SHADING_AVAILABLE_MODES.getName());
    516         charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES.getName());
    517         charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_MAX_FACE_COUNT.getName());
    518         charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES.getName());
    519         charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES.getName());
    520         charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_AVAILABLE_OIS_DATA_MODES.getName());
    521         charsKeyNames.add(CameraCharacteristics.TONEMAP_MAX_CURVE_POINTS.getName());
    522         charsKeyNames.add(CameraCharacteristics.TONEMAP_AVAILABLE_TONE_MAP_MODES.getName());
    523         charsKeyNames.add(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL.getName());
    524         charsKeyNames.add(CameraCharacteristics.INFO_VERSION.getName());
    525         charsKeyNames.add(CameraCharacteristics.SYNC_MAX_LATENCY.getName());
    526         charsKeyNames.add(CameraCharacteristics.REPROCESS_MAX_CAPTURE_STALL.getName());
    527         charsKeyNames.add(CameraCharacteristics.DEPTH_DEPTH_IS_EXCLUSIVE.getName());
    528         charsKeyNames.add(CameraCharacteristics.LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE.getName());
    529         charsKeyNames.add(CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES.getName());
    530 
    531         return charsKeyNames;
    532     }
    533 
    534     /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
    535      * End generated code
    536      *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/
    537 }
    538