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 
CameraCharacteristicsStorer(CameraManager cameraManager, DeviceInfoStore store)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 
storeCameraInfo(String cameraId)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 
storeRational( Rational rat, String protoName)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 
storeSize( Size size, String protoName)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 
storeSizeF( SizeF size, String protoName)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 
storeRect( Rect rect, String protoName)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 
storeStreamConfigurationMap( StreamConfigurationMap map, String protoName)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 
storeRangeInt( Range<Integer> range, String protoName)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 
storeRangeLong( Range<Long> range, String protoName)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 
storeColorSpaceTransform( ColorSpaceTransform xform, String protoName)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 
storeBlackLevelPattern( BlackLevelPattern pat, String protoName)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 
getKeyName(Object keyObj)218         private static String getKeyName(Object keyObj) {
219             return ((CameraCharacteristics.Key) keyObj).getName();
220         }
221 
getKeyValue(CameraCharacteristics chars, Object keyObj)222         private static Object getKeyValue(CameraCharacteristics chars, Object keyObj) {
223             return chars.get((CameraCharacteristics.Key) keyObj);
224         }
225 
storeEntry(Type keyType, Object keyObj, CameraCharacteristics chars)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 
storeArrayEntry(Type keyType, Object keyObj, CameraCharacteristics chars)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 
storeCameraChars( CameraCharacteristics chars)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
collectDeviceInfo(DeviceInfoStore store)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 
getAllCharacteristicsKeyNames()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