// It is recommended that exceptions be captured in the 1.0.1 version. In the 1.0.2 and later versions, exceptions do not need to be captured, but the CameraKit instance is obtained.
if (!isGetInstance) {
   try {
       mCameraKit = CameraKit.getInstance(getApplicationContext());
   } catch (NoSuchMethodError e) {
       Log.w(TAG, "this version camerakit does not contain VersionInfoInterface");
   } finally {
       isGetInstance = true;
   }
}
// If a mobile phone does not support CameraKit, or the CameraKit SDK version is incompatible with the capability layer, the return result is empty.
if (mCameraKit == null) {
   return;
}
// Query the camera list of the mobile phone. Currently, only the rear camera supports the super night mode.
String[] cameraLists = mCameraKit.getCameraIdList();
// Query the modes supported by the current cameras.
int[] modes = mCameraKit.getSupportedModes(cameraLists[0]);
// Create a mode.
mCameraKit.createMode(cameraLists[0], mCurrentModeType, mModeStateCallback, mCameraKitHandler);

// Configure the preview surface.
modeConfigBuilder.addPreviewSurface(surface);
// Set photographing parameters.
modeConfigBuilder.addCaptureImage(mCaptureSize, ImageFormat.JPEG)
// Configure the action data listener.
modeConfigBuilder.setDataCallback(actionDataCallback, mCameraKitHandler);
// Configure the action status listener.
modeConfigBuilder.setStateCallback(actionStateCallback, mCameraKitHandler);
// Configure the mode.
mMode.configure();

mMode.startPreview();

// Query the functions supported by the mode.
List<CaptureRequest.Key<?>> parameters = mModeCharacteristics.getSupportedParameters();
// Set zoom.
int zoomSetResult = mMode.setZoom(level);

// In this example, the portrait mode is used by default, which simplifies the rotation angle setting logic.
mMode.setImageRotation(90);
// This example uses the default photo storage path.
mFile = new File(getExternalFilesDir(null), "pic.jpg");
// Take a photo. The photo is asynchronously called back through ActionDataCallback.onImageAvailable.
mMode.takePicture();

private final ModeStateCallback mModeStateCallback = new ModeStateCallback() {
   @Override
   public void onCreated(Mode mode) {
       // Configure the mode after the mode is created successfully.
   }
   @Override
   public void onConfigured(Mode mode) {
       // Start the preview after the mode is configured successfully.
   }
   // ...
};

private final ActionDataCallback = new ActionDataCallback() {
   @Override
   public void onImageAvailable(Mode mode, @Type int type, Image image) {
       // Store photos.
   }
};

private final ActionStateCallback = new ActionStateCallback() {
   @Override
   public void onPreview(Mode mode, int state, PreviewResult result) {
       // Preview starting callback.
   }
   @Override
   public void onTakePicture(Mode mode, int state, TakePictureResult result) {
       // Photographing action callback.
   }
};

mMode.release();

// Query the functions supported by the mode.
List<CaptureRequest.Key<?>> parameters = mModeCharacteristics.getSupportedParameters();
// If the sensitivity can be set
if ((parameters != null) && (parameters.contains(RequestKey.HW_SUPER_NIGHT_ISO))) {
   // Query the supported sensitivity range.
   List<Long> values = mModeCharacteristics.getParameterRange(RequestKey.HW_SUPER_NIGHT_ISO);
   // Set the first sensitivity parameter.
   mMode.setParameter(RequestKey.HW_SUPER_NIGHT_ISO, values.get(0));
}

mMode.stopPicture();

private final ActionStateCallback = new ActionStateCallback() {
   @Override
   public void onPreview(Mode mode, int state, PreviewResult result) {
       // Preview starting callback.
   }
   @Override
   public void onTakePicture(Mode mode, int state, TakePictureResult result) {
       // Photographing action callback.
       switch (state) {
           case TakePictureResult.State.CAPTURE_STARTED:
               Log.d(TAG, "onState: STATE_CAPTURE_STARTED");
               break;
           case TakePictureResult.State.CAPTURE_EXPOSURE_BEGIN:
               /* When the long-time exposure mode is enabled, use the result class to obtain the exposure time required for the super night mode.
                  After receiving the exposure time return using the callback, you can call stopPicture to stop the exposure before the exposure time ends. */
               break;
           case TakePictureResult.State.CAPTURE_EXPOSURE_END:
               // The long-time exposure ends. When the exposure ends at the specified time or in advance, this status is called back.
               break;
           case TakePictureResult.State.CAPTURE_COMPLETED:
               // Photographing is complete.
               break;
           default:
               break;
       }
   }
};

// Query the functions supported by the mode.
List<CaptureRequest.Key<?>> parameters = mModeCharacteristics.getSupportedParameters();
// If the ultra-wide angle function is supported,
if ((parameters != null) && (parameters.contains(RequestKey.HW_APERTURE))) {
   // Query the supported ultra-wide angle level range.
   List<Float> values = mModeCharacteristics.getParameterRange(RequestKey.HW_APERTURE);
   // Set the first ultra-wide angle parameter.
   mMode.setParameter(RequestKey.HW_APERTURE, vales.get(0));
}

// Configure the preview surface.
modeConfigBuilder.addPreviewSurface(surface);
// Configure the recording surface.
modeConfigBuilder.addVideoSurface(videoSurface);
// Set photographing parameters.
modeConfigBuilder.addCaptureImage(mCaptureSize, ImageFormat.JPEG)
// Configure the action data listener.
modeConfigBuilder.setDataCallback(actionDataCallback, mCameraKitHandler);
// Configure the action status listener.
modeConfigBuilder.setStateCallback(actionStateCallback, mCameraKitHandler);
// Configure the mode.
mMode.configure();

// Query the functions supported by the mode.
List<CaptureRequest.Key<?>> parameters = mModeCharacteristics.getSupportedParameters();
// If the AI movie feature is supported,
(parameters != null) && (parameters.contains(RequestKey.HW_AI_MOVIE))
// Query the supported range of the AI movie feature.
List<Byte> lists = modeCharacteristics.getParameterRange(RequestKey.HW_AI_MOVIE)
// Set the AI movie feature parameter.
mMode.setParameter(RequestKey.HW_AI_MOVIE, value)

// Start recording.
mMode.startRecording()
mMediaRecorder.start();
// Pause recording.
mMode.pauseRecording();
mMediaRecorder.pause();
// Resume recording.
mMode.resumeRecording();
mMediaRecorder.resume();
// Stop recording.
mMode.stopRecording();
mMediaRecorder.stop();

// Set the recording frame rate.
modeConfigBuilder.setVideoFps(recordFps);

// Start recording.
mMode.startRecording()
// Stop recording.
mMode.stopRecording()

// Start recording.
mMode.startRecording()
// Stop recording.
mMode.stopRecording()

// Obtain the motion detection area.
modeCharacteristics.getParameterRange(RequestKey.HW_SUPER_SLOW_CHECK_AREA)

// Start recording.
Mode.startRecording(file);

mMode.setParameter(RequestKey.HW_SUPER_SLOW_CHECK_AREA,rect);

// Action status callback.
class ModeActionStateCallback extends ActionStateCallback {
   @Override
   public void onRecording(Mode mode, int state, RecordingResult result) {
       switch (state) {
           // An IO error occurs.
           case RecordingResult.State.ERROR_FILE_IO:
           // An unknown error occurs.
           case RecordingResult.State.ERROR_UNKNOWN:
           //The bottom-layer initialization is not ready.
           case RecordingResult.State.ERROR_RECORDING_NOT_READY:
               break;
           // The bottom layer is ready.
           case RecordingResult.State.RECORDING_READY:
               break;
           // Recording is started. This parameter is returned only in automatic mode.
           case RecordingResult.State.RECORDING_STARTED:
               break;
           // Recording is stopped.
           case RecordingResult.State.RECORDING_STOPPED:
               break;
           // Recording is complete.
           case RecordingResult.State.RECORDING_COMPLETED:
               break;
           // The recorded file is saved.
           case RecordingResult.State.RECORDING_FILE_SAVED:
               break;
           default:
               break;
       }
   }
}

// Query the facial beautification functions supported by the mode.
modeCharacteristics.getSupportedBeauty(Metadata.BeautyType.HW_BEAUTY_SKIN_SMOOTH)
modeCharacteristics.getSupportedBeauty(Metadata.BeautyType.HW_BEAUTY_FACE_SLENDER)
modeCharacteristics.getSupportedBeauty(Metadata.BeautyType.HW_BEAUTY_SKIN_COLOR)
modeCharacteristics.getSupportedBeauty(Metadata.BeautyType.HW_BEAUTY_BODY_SHAPING)
// Configure the facial beautification functions.
mMode.setBeauty(Metadata.BeautyType.HW_BEAUTY_SKIN_SMOOTH, value)
mMode.setBeauty(Metadata.BeautyType.HW_BEAUTY_FACE_SLENDER, value)
mMode.setBeauty(Metadata.BeautyType.HW_BEAUTY_SKIN_COLOR, value)
mMode.setBeauty(Metadata.BeautyType.HW_BEAUTY_BODY_SHAPING, value

// Query the functions supported by the mode.
List<CaptureRequest.Key<?>> parameters = mModeCharacteristics.getSupportedParameters();
// Query the supported ISO range.
List<Integer> values = mModeCharacteristics.getParameterRange(RequestKey.HW_PRO_SENSOR_ISO_VALUE);
// Set the ISO value. The first value is used as an example.
mMode.setParameter(RequestKey.HW_ PRO_SENSOR_ISO_VALUE, values.get(0));

// Deliver the parameters.
mMode.setParameter();
// Start shooting.
mMode.takePicture()

modeConfigBuilder.addCaptureImage(captureSize,ImageFormat.RAW_SENSOR)

// Deliver the parameters.
mMode.setParameter();

// Start recording.
mMode.startRecording()
mMediaRecorder.start();
// Pause recording.
mMode.pauseRecording();
mMediaRecorder.pause();
// Resume recording.
mMode.resumeRecording();
mMediaRecorder.resume();
// Stop recording.
mMode.stopRecording();
mMediaRecorder.stop();

// Query whether the AI capability is supported. If true is returned, AI scenario identification is supported.
modeCharacteristics. getSupportedSceneDetection();
// Enable AI scene identification. You can disable it afterwards by setting the input parameter to false.
mMode. setSceneDetection (true);
// Identify the scene and perceive the identified scene based on the callback information.
class ModeActionStateCallback extends ActionStateCallback {
   @Override
   public void onSceneDetection(Mode mode, @SceneDetectionResult.State int state,
       @Nullable SceneDetectionResult result) {
       // Confirm the effect of the scene to be enabled. For example, the scene "flower" is identified here.
       // After the scene is enabled, the parameters are adjusted to make the flowers look brighter.
       mMode.setParameter(RequestKey.HW_SCENE_EFFECT_ENABLE, true);
   }
}
// Disable the scene effects. If the scene effect is enabled and then disabled, parameter adjustment will be canceled.
mMode.setParameter(RequestKey.HW_SCENE_EFFECT_ENABLE, false);

// Query whether burst shooting is supported. If true is returned, burst shooting is supported.
modeCharacteristics. isBurstSupported();
// Start burst shooting.
mMode. takePictureBurst();

mMode. takePictureBurst (filename);
// Stop burst shooting.
mMode.stopPicture();