1. Overview

Through this guide, you can have a basic understanding of Autel Mobile SDK through related functions/APIs, and learn how to develop the functions. Autel Mobile SDK provides services for communicating with various aircraft modules, which are the general module and the modules for missions, AIService, camera, flight control, flight parameter read and configuration, vision, and Airlink transmission. Remote controller functions and listening of the aircraft connection status are also covered.

2. Android Studio Project Configuration

Create an Android project and import an AAR package (copy the package to the libs directory of the project).

repositories {
    flatDir {
        dirs 'libs'
    }

}

Add the following code to build.gradle.

implementation(name: 'autel-sdk-release', ext: 'aar')

Add the following content to the AndroidManifest.xml file to apply for basic permissions.

<uses-permission android:name="android.permission.ACCESS\_COARSE\_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RECORD\_AUDIO" />
<uses-permission android:name="android.permission.WRITE\_EXTERNAL\_STORAGE" />
<uses-permission android:name="android.permission.READ\_EXTERNAL\_STORAGE" />
<uses-permission android:name="android.permission.ACCESS\_NETWORK\_STATE" />
<uses-permission android:name="android.permission.ACCESS\_WIFI\_STATE" />
<uses-permission android:name="android.permission.ACCESS\_FINE\_LOCATION" />

3. Getting Started

3.1 Initial SDKs And Parameters

param1: Context object. ApplicationContext is used.

Param2: Whether to enable Debug mode.

Param3: Custom storage component, which defaults to SharedPreferences and can be customized.

Param4: Custom log component, which defaults to system logs. The release version has no logs.

SDKManager.get().init(applicationContext, AppInfoManager.isBuildTypeDebug(), AppStorage(), AppLog())

3.2 KeyManager Methods

3.2.1 getValue

Obtains an aircraft property. The following example shows how to obtain camera information.

val key = KeyTools.createKey(CameraKey.KeyCameraDeviceInfo)

DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.getValue(key,
    object : CommonCallbacks.CompletionCallbackWithParam<DeviceInfoBean> {

        override fun onSuccess(t: DeviceInfoBean?) {
        }

        override fun onFailure(error: IAutelCode, msg: String?) {
        }
})

3.2.2 setValue

Sets an aircraft property. The following example shows how to set the camera mode.

val key = KeyTools.createKey(CameraKey.KeyCameraWorkMode)

DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.setValue(key,

    CameraWorkModeEnum.PHOTO,

    object : CommonCallbacks.CompletionCallback {

        override fun onSuccess() {
        }

        override fun onFailure(code: IAutelCode, msg: String?) {
        }
})

3.2.3 performAction

Executes an action or command. The following example shows how to take a photo.

val key = KeyTools.createKey(CameraKey.KeyStartTakePhoto)

DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.performAction(key, null,

    object : CommonCallbacks.CompletionCallbackWithParam<Void> {

        override fun onSuccess(t: Void?) {
        }

        override fun onFailure(code: IAutelCode, msg: String?) {
        }
})

3.2.4 listen

Receives information reported by the aircraft. The following example shows how to receive camera parameters.

val key = KeyTools.createKey(CameraKey.KeyProfessionalParamInfo)

val callback = object : CommonCallbacks.KeyListener<ProfessionalParamInfoBean> {

    override fun onValueChange( oldValue: ProfessionalParamInfoBean?, newValue: ProfessionalParamInfoBean) {

    }

}

DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.listen(key, callback)

3.2.5 cancelListen

Cancels the listening process set using the previous method.

val key = KeyTools.createKey(CameraKey.KeyProfessionalParamInfo)

val callback = object : CommonCallbacks.KeyListener<ProfessionalParamInfoBean> {
                override fun onValueChange(oldValue: ProfessionalParamInfoBean?,
                        newValue: ProfessionalParamInfoBean) {

                        }
                }
DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.cancelListen(key, callback)

3.2.6 removeAllListen

Cancels all listening processes.

DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.removeAllListen()

3.3 Aircraft Connection Status And Camera Capability Set Listening

interface IAutelDroneListener {

/**
* @param connected is connected
* @param drone drone device
* @Description: listener for drone device connecting status
*/
fun onDroneChangedListener(connected: Boolean, drone: IBaseDevice)

/**
*Notifies camera capability update.
* @param fetched true Capability set file updated. If it is false, the aircraft is disconnected.
*/
fun onCameraAbilityFetchListener(fetched: Boolean)
}

3.3.1 Registering Listening

SDKManager.get().getDeviceManager().addDroneListener(this)

3.3.2 Obtaining The Aircraft Connection Status

val connectStatus = DeviceManager.getDeviceManager().isConnected()

3.3.3 Obtaining The Camera Capability Set

val cameraSupport =DeviceManager.getFirstDroneDevice()?.getCameraAbilitySetManger()?.getCameraSupport()

The camera capability set is returned by the ICameraSupport API.

interface ICameraSupport {
    /**
    * @return Returns the list of valid video resolution and frame rate values currently supported.
    */
    fun getResolutionAndFrameRate(lensType: LensTypeEnum, flightMode: FightModeEnum,
                                  modeEnum: RecordModeEnum): List<VideoResolutionFrameBean>
    /**
    * @return Returns the list of HDR-supported resolution values.
    */
    fun getHDRSupportPhoto(flightMode: FightModeEnum, photoFormat:
    PhotoFormatEnum, modeEnum: CameraModeEnum): List<PhotoResolutionEnum>

    /**
    * @return Returns the supported camera modes.
    */
    fun getCameraModeRange(lensType : LensTypeEnum,
    flightMode: FightModeEnum = FightModeEnum.Manual,
    modeEnum: TakePhotoModeEnum = TakePhotoModeEnum.UNKNOWN): ArrayList<CameraModeEnum>

    /**
    * @return Returns teh supported manual focus range.
    */
    fun getManualFocus(): RangeStepIntValue

    /**
    * @return Returns the supported photo zoom rate range.
    */
    fun getPhotoZoom(lensType : LensTypeEnum): RangeStepValue

    /**
    * @return Returns the supported video zoom rate range.
    */
    fun getVideoZoom(lensType : LensTypeEnum,videoZoomType : VideoZoomTypeEnum = VideoZoomTypeEnum.Default): RangeStepValue

    /**
    * @return Returns stamps and timestamps.
    */
    fun getWatermarkTimestamp(lensType: LensTypeEnum, photoFormat:
    PhotoFormatEnum): Int

    /**
    * @return Returns the supported camera exposure modes (ExposureModeEnum).
    */
    fun getExposureModeRange(): ArrayList<ExposureModeEnum>

    /**
    * @return Returns the supported exposure compensation range (ExposureExposureCompensationEnum).
    */
    fun getExposureCompensationRange(): ArrayList<ExposureExposureCompensationEnum>

    /**
    * @return Returns the supported ISO range (ImageISOEnum).
    */
    fun getImageISOList(isPhoto: Boolean = true,
    pattern: Int = CameraPatternEnum.MANUAL_FLIGHT.value,
    modeEnum: TakePhotoModeEnum = TakePhotoModeEnum.UNKNOWN): ArrayList<ImageISOEnum>

    /**
    * @return Returns the supported ISO modes (ISOModeEnum).
    */
    fun getPhotoISOModeRange(): List<ISOModeEnum>

    /**
    * @return Returns the supported shutter speed range (ShutterSpeedEnum).
    */
    fun getShutterList(isPhoto: Boolean, fps: Int,
    modeEnum: TakePhotoModeEnum = TakePhotoModeEnum.UNKNOWN):
    ArrayList<ShutterSpeedEnum>

    /**
    * @return Returns the supported aperture range.
    */
    fun getApertureRange(): ArrayList<LrisEnum>

    /**
    * @return Returns the supported video formats.
    */
    fun getVideoFileFormatRange(lensType : LensTypeEnum): List<VideoFormatEnum>

    /**
    * @return Returns the supported photo interval range.
    */
    fun getPicInVideoIntervalRange(lensType : LensTypeEnum): List<VideoPivEnum>

    /**
    * @return Returns the supported video standards.
    */
    fun getVideoStandardRange(lensType : LensTypeEnum): List<VideoStandardEnum>

    /**
    * @return Returns the supported photo formats.
    */
    fun getPhotoFileFormatRange(lensType : LensTypeEnum, modeEnum:TakePhotoModeEnum): List<PhotoFormatEnum>

    /**
    * @return Returns the supported burst count.
    */
    fun getPhotoBurstCountRange(lensType: LensTypeEnum): List<Int>

    /**
    * @return Returns the supported AEB photo count.
    */
    fun getPhotoAEBCaptureCountRange(): List<Int>

    /**
    * @return Returns the supported photo interval range for timer.
    */
    fun getPhotoIntervalParamRange(lensType: LensTypeEnum = LensTypeEnum.Zoom): List<Int>

    /**
    * @return Returns the white balance range.
    */
    fun getWhiteBalanceList(): ArrayList<WhiteBalanceEnum>

    /**
    * @return Returns the supported custom color temperature range for white balance.
    */
    fun getCustomColorTemperatureRange(): RangeStepIntValue
    /**
    * @return Returns the defog range.
    */
    fun getDehazeModeRange(): List<DefogModeEnum>

    /**
    * @return Returns the supported defog enabling statuses.
    */
    fun getDehazeSettingSwitchRange(): List<DefogEnum>

    /**
    * @return Returns the supported anti-flicker range.
    */
    fun getAntiFlickerRange(): List<Int>

    /**
    * @return Returns the supported transmission resolution options: 1-720p, 2-1080p, 3-2.7K
    */
    fun getTransferMode(): List<VideoTransMissionModeEnum>

    /**
    * @return Returns the supported resolution range.
    */
    fun getPhotoResolution(lensType : LensTypeEnum = LensTypeEnum.Zoom,
                            flightMode: FightModeEnum,
                            modeEnum: TakePhotoModeEnum): List<PhotoResolutionEnum>
    /**
    * @return Returns the supported resolution range. No enumerations. When UNKNOWN is returned, the resolution list will be queried again.
    */
    fun getPhotoResolutionTwice(lensType : LensTypeEnum = LensTypeEnum.Zoom,
            flightMode: FightModeEnum,
            modeEnum: TakePhotoModeEnum): List<PhotoResolution>
    /**
    * @return Returns the supported sharpness range.
    */
    fun getSharpnessRange(modeEnum: TakePhotoModeEnum): List<Int>

    /**
    * @return Returns the supported contrast range.
    */
    fun getContrastRange(modeEnum: TakePhotoModeEnum): List<Int>

    /**
    * @return Returns the supported saturation range.
    */
    fun getSaturationRange(modeEnum: TakePhotoModeEnum): List<Int>

    /**
    * @return Returns the supported focus modes.
    */
    fun getLensFocusModeRange(modeEnum: CameraModeEnum): List<Int>

    /**
    * @return Returns the supported IR thermal colors.
    */
    fun supportedIrColor(): List<ThermalColorEnum>

    /**
    * @return Returns the IR temperature measurement modes.
    */
    fun getThermalIRTempMode(): List<IRTempModeEnum>

    /**
    * @return Returns the IR image modes.
    */
    fun getThermalIrImageMode(): IrImageMode?

    /**
    * @return Returns the IR image enhancement configuration.
    */
    fun getThermalIrImageEnhance(): RangeStepIntValue?

    /**
    * @return Returns the IR image denoiser configuration.
    */
    fun getThermalIrNr(): MutableList<Int>
    /**
    * @return Returns IR gains.
    */
    fun getIrGain(): IrGain?

    /**
    * @return Returns IR isotherms.
    */
    fun getIrIsoThermMode(): List<Int>

    /**
    * @return Returns IR temperature warnings.
    */
    fun getIrTempAlarm(): IRHotColdValue?

    /**
    * @return Returns the IR emissivity configuration.
    */
    fun getIrNrEmit(): RangeStepIntValue?

    /**
    * @return Returns the supported video decompression standards.
    */
    fun getVideoFileCompressionStandard(): List<VideoCompressStandardEnum>

    /**
    * @return Returns the supported storage types.
    */
    fun getStorageType(lensType: LensTypeEnum): List<StorageTypeEnum>

    fun getVersion():String
}

3.4 Aircraft Status Caching

val status = DeviceManager.getDeviceManager().getFirstDroneDevice()?.getStateMachine()

Information aircraft status information will be updated constantly, and mainly stored in DroneStateMachineBean.

data class DroneStateMachineBean(
    /**
     * Aircraft ID
     */
    val deviceId: Int,
    /**
     * Initial system data
     */
    var systemInitData: SystemInfoData? = null,
    /**
     * Aircraft component list
     */
    var componentList: List<DroneVersionItemBean> = mutableListOf(),
    /**
     * Camera status map. The key is the camera ID.
     */
    val cameraStateMachineList: MutableMap<Int, CameraStateMachineBean> = mutableMapOf(),
    /**
     * Gimbal status map. The key is the gimbal ID.
     */
    val gimbalStateMachineList: MutableMap<Int, GimbalStateMachineBean> = mutableMapOf(),
    /**
     * Reporting of general aircraft parameter (5 Hz)
     */
    var droneSystemStateHFNtfyBean: DroneSystemStateHFNtfyBean? = null,
    /**
     * Reporting of general aircraft parameter (2 Hz)
     */
    var droneSystemStateLFNtfyBean: DroneSystemStateLFNtfyBean? = null,
    /**
     * Aircraft working status
     */
    var flightControlStatusInfo: FlightControlStatusInfo? = null,
    /**
     * Aircraft warnings
     */
    var droneWarningStateNtfyBean: DroneWarningStateNtfyBean? = null,

)

3.5 AutelKeyInfo & AutelActionKeyInfo

3.5.1 AutelKeyInfo

AutelKeyInfo contains the properties and capabilities of an API. The aperture size is used as an example.

/** Aperture size */
val KeyApertureSize: AutelKeyInfo<Double> = AutelKeyInfo(component.value,CameraKeyConstants.ApertureSize, AutelDoubleConvert())
                                            .canGet(true).canSet(true)

Parameters:

• component.value: Module of the key, which may be camera, flight control, gimbal, or others.
• CameraKeyConstants.ApertureSize: Unique ID of the key.
• AutelDoubleConvert: Data conversion class, used to convert between protobuf and Java objects. The data type is Double.
• canGet(true).canSet(true): Capabilities of the key. There are four capabilities, which are canGet(true), canSet(true), canPerformAction(true), and canListen(true).

3.5.2 AutelActionKeyInfo

AutelActionKeyInfo is a subclass of AutelKeyInfo and contains the capabilities of AutelKeyInfo. This class has two generic types, which respectively represent the request parameter type and the response data type. The following uses the start of recording as an example.

/** Start recording */
val KeyStartRecord: AutelActionKeyInfo<Void, Void> =  AutelActionKeyInfo(component.value, CameraKeyConstants.StartRecord,

    AutelEmptyConvert(), AutelEmptyConvert()).canPerformAction(true)

3.6 Keys Of All Aircraft Modules

3.6.1 General

object CommonKey {
    private val component = ComponentType.COMMON

    /**
     * Aircraft heartbeat
     */
    val KeyHeartBeatPhone: AutelKeyInfo<Void> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.LISTENER_HEARTBEAT_PHONE,
        AutelEmptyConvert()
    ).canListen(true)

    /**
     * App heartbeat
     */
    val KeyHeartBeatApp: AutelKeyInfo<Void> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.LISTENER_HEARTBEAT_APP,
        AutelEmptyConvert()
    ).canListen(true)

    /**
     * System time configuration
     */
    val KeySetSystemDataTime: AutelActionKeyInfo<SystemTimeInfoBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.SET_SYSTEM_DATA_TIME_MSG,
        SystemTimeConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Initial system data acquisition
     */
    val keyGetSystemInitData: AutelActionKeyInfo<Void, SystemInfoData> = AutelActionKeyInfo(//Initial system data acquisition
        component.value,
        MessageTypeConstant.GET_SYSTEM_INIT_DATA_MSG,
        AutelEmptyConvert(),
        SystemInitDataConvert()
    ).canPerformAction(true)

    /**
     * Aircraft information acquisition
     */
    val KeyGetDroneDevicesInfo: AutelActionKeyInfo<Void, List<DroneVersionItemBean>> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.GET_DRONE_DEVICES_INFO_MSG,
        AutelEmptyConvert(),
        SystemProfileInfoConvert(),
    ).canPerformAction(true)

    /**
     * Reporting of general aircraft parameter (5 Hz)
     */
    val keyDroneSystemStatusHFNtfy: AutelKeyInfo<DroneSystemStateHFNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_SYSTEM_STATUS_HF_NTFY,
        DroneSystemStateHFNtfyConverter()
    ).canListen(true)

    /**
     * Reporting of general aircraft parameter (2 Hz)
     */
    val KeyDroneSystemStatusLFNtfy: AutelKeyInfo<DroneSystemStateLFNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_SYSTEM_STATUS_LF_NTFY,
        FlightControlStateLFConvert()
    ).canListen(true)

    /**
     * Reporting of aircraft working status
     */
    val KeyDroneWorkStatusInfoReport: AutelKeyInfo<FlightControlStatusInfo> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_WORK_STATUS_INFO_NTFY,
        WorkStatusInfoConvert()
    ).canListen(true)

    /**
     * Reporting of aircraft warnings
     */
    val KeyDroneWarningMFNtfy: AutelKeyInfo<DroneWarningStateNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_WARNING_MF_NTFY,
        FlightControlWarningStateConvert()
    ).canListen(true)

    /**
     * Control of an aircraft indicator
     */
    val KeyControlLed: AutelActionKeyInfo<DroneLedStatusBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_CONTROL_LED_MSG,
        DroneLedStatusConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Query of all aircraft indicators
     */
    val KeyQueryLedStatus: AutelActionKeyInfo<Void, DroneAllLedStatusBean> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_QUERY_LED_STATUS_MSG,
        AutelEmptyConvert(),
        DroneAllLedStatusConverter()
    ).canPerformAction(true)

    /**
     * General calibration commands
     */
    val KeyDroneCalibrationCommand: AutelActionKeyInfo<CalibrationCommandBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_CALIBRATION_COMMAND_MSG,
        CalibrationCommandConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Calibration event notifications
     */
    val KeyDroneCalibrationEventNtfy: AutelKeyInfo<CalibrationEventBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_CALIBRATION_EVENT_NTFY,
        CalibrationEventConvert(),
    ).canListen(true)

    /**
     * Calibration progress notifications
     */
    val KeyDroneCalibrationScheduleNtfy: AutelKeyInfo<CalibrationScheduleBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_CALIBRATION_SCHEDULE_NTFY,
        CalibrationScheduleConvert(),
    ).canListen(true)

    /**
     * Reporting of the high-frequency parameter of aircraft flight control (5 Hz)
     */
    val KeyDroneHfNtfy: AutelKeyInfo<DroneKeyInfoHFNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_KEY_INFO_HF_NTFY,
        DroneKeyInfoHFNtfyConvert(),
    ).canListen(true)

    /**
     * Reporting of the low-frequency parameter of aircraft flight control (2 Hz)
     */
    val KeyDroneLfNtfy: AutelKeyInfo<DroneKeyInfoLFNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_KEY_INFO_LF_NTFY,
        DroneKeyInfoLFNtfyConvert(),
    ).canListen(true)
    /**
     * Strobe control
     */
    val KeyDroneControlNightNavigationLed: AutelActionKeyInfo<Boolean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_CONTROL_NIGHT_NAVIGATION_LED_MSG,
        AutelIntToBoolConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Aircraft message notifications
     */
    val KeyDroneVersionNtfy: AutelKeyInfo<List<DroneVersionItemBean>> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_VERSION_NTFY,
        SystemProfileInfoConvert(),
    ).canListen(true)

    /**
     * Aircraft event notifications
     */
    val KeyDroneEventNtfy: AutelKeyInfo<EventInfoBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_EVENT_NTFY,
        DroneEventConvert()
    ).canListen(true)

    /**
     * Reporting of temporary device connections, which can be received when the aircraft is disconnected.
     */
    val KeyDroneTempConnectNtfy: AutelKeyInfo<DeviceTempConnectBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_TEMP_CONNECT_NTFY,
        DeviceTempConnectConvert()
    ).canListen(true)

    /**
     * GPS, UTC synchronization
     */
    val KeyDroneUtcTimeSyncNtfy: AutelKeyInfo<DroneUTCTimeSyncBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_UTC_TIME_SYNC_NTFY,
        DroneUTCTimeSyncConvert()
    ).canListen(true)

    /**
     * Country code configuration
     */
    val KeyDroneSetCountryCode: AutelActionKeyInfo<String, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_SET_COUNTRY_CODE_MSG,
        AutelStringConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Clearance of no-fly zone files
     */
    val KeyDroneCleanNoflyZone: AutelActionKeyInfo<CleanNoFlyZoneEnum, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_CLEAN_NOFLY_ZONE_COMMAND_MSG,
        CleanNoFlyZoneConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Aircraft warning notifications
     */
    val KeyDroneWarning: AutelKeyInfo<List<WarningAtom>> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_WARNING_NTFY,
        WarningInfoConvert(),
    ).canListen(true)

    /**
     * Aircraft real-time warning notifications
     */
    val KeyDroneRuntimeWarning: AutelKeyInfo<WarningAtom> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_RUNTIME_WARNING_NTFY,
        WarningAtomConvert(),
    ).canListen(true)
    /**
     * Aircraft debugging message notifications
     */
    val KeyDroneDebugInfo: AutelKeyInfo<DroneDebugBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.DRONE_DEBUG_INFO_NTFY,
        DroneDebugInfoConvert(),
    ).canListen(true)


    /**
     * Definition of file handling messages; file upload
     */
    val KeyFileUpload: AutelActionKeyInfo<FileUploadBean,Void > = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FILE_UPLOAD_MSG,
        FileUploadBeanConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

}

3.6.2 Mission

object FlightMissionKey{

    val component = ComponentType.MISSION

    // ----------------- Waypoint mission -----------------
    /**
     * Enter a waypoint mission.
     */
    val KeyEnter: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_ENTER_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Exit the waypoint mission.
     */
    val KeyExit: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_EXIT_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Start the waypoint mission.
     */
    val KeyStart: AutelActionKeyInfo<MissionWaypointGUIDBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_START_MSG,
        WaypointGUIDConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Pause the waypoint mission.
     */
    val KeyPause: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_PAUSE_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Resume the waypoint mission.
     */
    val KeyResume: AutelActionKeyInfo<MissionWaypointGUIDBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_CONTINUE_MSG,
        WaypointGUIDConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Stop the waypoint mission.
     */
    val KeyStop: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_STOP_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Query interruption of the waypoint mission.
     */
    val KeyBreakRequest: AutelActionKeyInfo<MissionWaypointGUIDBean, MissionWaypointBreakRspBean> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_BREAK_REQUEST_MSG,
        WaypointGUIDConverter(),
        WaypointBreakRspConverter()
    ).canPerformAction(true)

    /**
     * Report the waypoint mission status.
     */
    val KeyStatusReportNtfy: AutelKeyInfo<MissionWaypointStatusReportNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_WAYPOINT_STATUS_REPORT_NTFY,
        WaypointStatusReportNtfyConverter()
    ).canListen(true)

    //====================POI mission=========================
    /**
     * Enter a POI mission.
     */
    val KeyIPMEnter: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_INTEREST_POINT_ENTER_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Exit the POI mission.
     */
    val KeyIPExit: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_INTEREST_POINT_EXIT_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Start the POI mission.
     */
    val KeyIPMStart: AutelActionKeyInfo<MissionInterestPointStartMsgBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_INTEREST_POINT_START_MSG,
        MissionInterestPointStartMsgConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Stop the POI mission.
     */
    val KeyIPMStop: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_INTEREST_POINT_STOP_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Report the POI mission status.
     */
    val KeyIPMStatusReport: AutelKeyInfo<MissionInterestPointStatusReportNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_INTEREST_POINT_STATUS_REPORT_NTFY,
        MissionInterestPointStatusReportNtfyConverter()
    ).canListen(true)

    /**
     * Pin a POI.
     */
    val KeyIPMCreatePoint: AutelActionKeyInfo<MissionInterestPointCreatePointMsgBean, MissionInterestPointCreatePointRspBean> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_INTEREST_POINT_CREAT_POINT_MSG,
        MissionInterestPointCreatePointMsgConverter(),
        MissionInterestPointCreatePointRspConverter()
    ).canPerformAction(true)

    /**
     * Execute an emergency mission stop.
     */
    val KeyMissionOneClickStop: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_ONE_CLICK_STOP,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    //====================Team mission=======================
    /***
     *Enter a team mission.
     */
    val KeySwarmEnter: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_ENTER_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Exit the team mission.
     */
    val KeySwarmExit: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_EXIT_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Start the team mission.
     */
    val KeySwarmStart: AutelActionKeyInfo<MissionSwarmInfoBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_START_MSG,
        MissionSwarmInfoConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Pause the team mission.
     */
    val KeySwarmPause: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_PAUSE_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Resume the team mission.
     */
    val KeySwarmResume: AutelActionKeyInfo<MissionSwarmInfoBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_CONTINUE_MSG,
        MissionSwarmInfoConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Stop the team mission.
     */
    val KeySwarmStop: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_STOP_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Perform the team mission actions.
     */
    val KeySwarmDoAction: AutelActionKeyInfo<Int, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_ACTION_MSG,
        AutelIntConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Report the team mission status.
     */
    val KeySwarmStatusNtfy: AutelKeyInfo<MissionSwarmStatusNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_STATUS_NTFY,
        MissionSwarmStatusNtfyBeanConverter()
    ).canListen(true)

    /**
     * Report the team mission upload status.
     */
    val KeySwarmUploadNtfy: AutelKeyInfo<MissionSwarmUploadFileNtfyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.MISSION_SWARM_FILE_UPLOAD_NTFY,
        MissionSwarmUploadFileNtfyBeanConverter()
    ).canListen(true)
}

3.6.3 AIService

object AIServiceKey {

    private val component = ComponentType.AI_SERVICE
    /**
     * The aircraft detects objects and sends the bounding boxes to the app.
     */
    val KeyAiDetectTarget: AutelKeyInfo<DetectTrackNotifyBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.AISERVICE_DETECT_TARGET_RECT_NTFY,
        DetectTrackNotifyBeanConvert()
    ).canListen(true)

    /**
     * The user selects the target box to send it to the app.
     */
    val KeyTrackingTargetObject: AutelKeyInfo<TrackAreaBean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.AISERVICE_TRACKING_TARGET_RECT_NTFY,
        TrackAreaConvert()
    ).canListen(true)

    /**
     * Set the object detection type.
     */
    val KeyTrackingTargetTypeConfig: AutelActionKeyInfo<AIDetectObjectConfigBean?, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.AISERVICE_TARGET_TYPE_SET_MSG,
        AIDetectObjectConfigConvert(), AutelEmptyConvert()
    ).canSet(true).canPerformAction(true)


    /** Obtain extended reconigtion models.*/
    val KeyExtendedDetect: AutelActionKeyInfo<Void, ExtendedDetectCapBean> =
        AutelActionKeyInfo(
            MissionManagerKey.component.value,
            MessageTypeConstant.AISERVICE_GET_EXTENDED_DETECT_CAP,
            AutelEmptyConvert(), ExtendedDetectConvert()
        ).canPerformAction(true)

    /** AIService reports the extended recognition capability set to the app. */
    val KeyExtendedDetectReport: AutelKeyInfo<ExtendedDetectCapBean> =
        AutelKeyInfo(
            MissionManagerKey.component.value,
            MessageTypeConstant.AISERVICE_EXTENDED_DETECT_CAP_NTFY,
            ExtendedDetectConvert()
        ).canListen(true)

    /** Whether to enable planner bag record. */
    val plannerRosBagRecordEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(
            MissionManagerKey.component.value,
            MessageTypeConstant.PLANNER_ROS_BAG_RECORD_ENABLE,
            AutelIntToBoolConverter()
        ).canSet(true).canGet(true)

}

3.6.4 Camera

object CameraKey {
    private val component = ComponentType.CAMERA

    /**
     * Camera information
     */
    val KeyCameraDeviceInfo: AutelKeyInfo<DeviceInfoBean> = AutelKeyInfo(component.value, CameraKeyConstants.DeviceInfo, DeviceInfoConvert())
        .canGet(true).canSet(false)

    /**
     * Storage type
     */
    val KeyStorageType: AutelKeyInfo<StorageTypeEnum> = AutelKeyInfo(component.value, CameraKeyConstants.StorageType, StorageTypeConvert())
        .canGet(true).canSet(true)

    /**
     * SD card status
     */
    val KeyStorageStatus: AutelKeyInfo<CardStatusBean> = AutelKeyInfo(component.value, CameraKeyConstants.StorageStatus, StorageStatusConvert())
        .canGet(true).canListen(true)

    /**
     * MMC internal storage status
     */
    val KeyMMCStatus: AutelKeyInfo<CardStatusBean> = AutelKeyInfo(component.value, CameraKeyConstants.MMCStatus, StorageStatusConvert())
        .canGet(true).canSet(false)

    /**
     * Video encoding configuration
     */
    val KeyVideoEncoderConfig: AutelKeyInfo<VideoEncoderConfigBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.VideoEncoderConfig, VideoEncoderConfigConvert())
            .canGet(true).canSet(true)

    /**
     * Video source configuration
     */
    val KeyVideoSourceConfig: AutelKeyInfo<VideoSourceConfigBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.VideoSourceConfig, VideoSourceConfigConvert())
            .canGet(true).canSet(true)

    /**
     * Shooting mode
     */
    val KeyCameraGear: AutelKeyInfo<CameraGearEnum> = AutelKeyInfo(component.value, CameraKeyConstants.CameraGear, CameraGearConvert())
        .canGet(true).canSet(true)

    /**
     * Camera mode
     */
    val KeyCameraMode: AutelKeyInfo<CameraWorkModeInfoBean> = AutelKeyInfo(component.value, CameraKeyConstants.CameraMode, CameraModeConvert())
        .canGet(true).canSet(true)

    /**
     * Display mode
     */
    val KeyDisplayMode: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.DisplayMode, AutelIntConvert()).canGet(true).canSet(true)
            .canListen(true)

    /**
     * Photo parameters
     */
    val KeyTakePhotoParameters: AutelKeyInfo<TakePhotoParametersBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.TakePhotoParameters, TakePhotoParamConvert())
            .canGet(true).canSet(true)

    /**
     * Recording parameters
     */
    val KeyRecordParameters: AutelKeyInfo<RecordParametersBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.RecordParameters, RecordParamConvert())
            .canGet(true).canSet(true)

    /**
     * Metering point
     */
    val KeyMeteringPoint: AutelKeyInfo<MeteringPointBean> = AutelKeyInfo(component.value, CameraKeyConstants.MeteringPoint, MeteringPointConvert())
        .canGet(true).canSet(true)

    /**
     * Image style
     */
    val KeyImageStyle: AutelKeyInfo<ImageStyleBean> = AutelKeyInfo(component.value, CameraKeyConstants.ImageStyle, ImageStyleConvert())
        .canGet(true).canSet(true)

    /**
     * White balance parameter
     */
    val KeyWhiteBalance: AutelKeyInfo<WhiteBalanceBean> = AutelKeyInfo(component.value, CameraKeyConstants.WhiteBalance, WhiteBalanceConvert())
        .canGet(true).canSet(true)

    /**
     * Image color parameter
     */
    val KeyImageColor: AutelKeyInfo<ImageColorEnum> = AutelKeyInfo(component.value, CameraKeyConstants.ImageColor, ImageColorConvert())
        .canGet(true).canSet(true)

    /**
     * Image exposure parameter
     */
    val KeyImageExposure: AutelKeyInfo<Double> = AutelKeyInfo(component.value, CameraKeyConstants.ImageExposure, AutelDoubleConvert())
        .canGet(true).canSet(true)

    /**
     * Image ISO
     */
    val KeyImageIso: AutelKeyInfo<Int> = AutelKeyInfo(component.value, CameraKeyConstants.ImageIso, AutelIntConvert())
        .canGet(true).canSet(true)

    /**
     * AE Lock
     */
    val KeyAELock: AutelKeyInfo<Boolean> = AutelKeyInfo(component.value, CameraKeyConstants.AELock, AutelBooleanConvert())
        .canGet(true).canSet(true)

    /**
     * Shutter speed
     */
    val KeyShutterSpeed: AutelKeyInfo<ShutterSpeedBean> = AutelKeyInfo(component.value, CameraKeyConstants.ShutterSpeed, ShutterSpeedConvert())
        .canGet(true).canSet(true)

    /**
     * Shutter mode
     */
    val KeyShutterMode: AutelKeyInfo<ShutterModeEnum> = AutelKeyInfo(component.value, CameraKeyConstants.ShutterMode, ShutterModeConvert())
        .canGet(true).canSet(true)

    /**
     *  Focus mode
     **/
    val KeyFocusInfoMode: AutelKeyInfo<FocusModeEnum> = AutelKeyInfo(component.value, CameraKeyConstants.FocusInfoMode, FocusModeConvert())
        .canGet(true).canSet(true)

    /**
     *  Auto focus
     **/
    val KeyAFMeterMode: AutelKeyInfo<AFLensFocusModeEnum> = AutelKeyInfo(component.value, CameraKeyConstants.AFMeterMode, AFMeterModeConvert())
        .canGet(true).canSet(true)

    /**
     *  Focus point coordinate group
     **/
    val KeyCameraFocusSpotArea: AutelKeyInfo<MeteringPointBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraFocusSpotArea, MeteringPointConvert())
            .canGet(true).canSet(true)

    /**
     *  Manual focus
     * Object distance
     *   Object distance [0–50]
     */
    val KeyCameraMFObjectDistance: AutelKeyInfo<Int> = AutelKeyInfo(component.value, CameraKeyConstants.CameraMFObjectDistance, AutelIntConvert())
        .canGet(true).canSet(true)

    /**
     *  AF-assisted focus enabling
     **/
    val KeyCameraAFAssistFocusEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraAFAssistFocusEnable, AutelBooleanConvert())
            .canGet(true).canSet(true)

    /**
     *  MF-assisted focus enabling
     **/
    val KeyCameraMFAssistFocusEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraMFAssistFocusEnable, AutelBooleanConvert())
            .canGet(true).canSet(true)

    /**
     * Aperture size
     */
    val KeyApertureSize: AutelKeyInfo<Double> = AutelKeyInfo(component.value, CameraKeyConstants.ApertureSize, AutelDoubleConvert())
        .canGet(true).canSet(true)

    /**
     * Aperture mode
     */
    val KeyApertureMode: AutelKeyInfo<ApertureModeEnum> = AutelKeyInfo(component.value, CameraKeyConstants.ApertureMode, ApertureModeConvert())
        .canGet(true).canSet(true)

    /**
     * Digital/IR zoom
     */
    val KeyZoomFactor: AutelKeyInfo<Int> = AutelKeyInfo(component.value, CameraKeyConstants.ZoomFactor, AutelIntConvert())
        .canGet(true).canSet(true)

    /**
     * Camera pattern
     */
    val KeyPatternMode: AutelKeyInfo<PatternModeEnum> = AutelKeyInfo(component.value, CameraKeyConstants.PatternMode, PatternModeConvert())
        .canGet(true).canSet(true)

    /**
     * PIV recording status
     */
    val KeyRecordPiv: AutelKeyInfo<CameraRecordPivInfoBean> = AutelKeyInfo(component.value, CameraKeyConstants.RecordPiv, RecordPivConvert())
        .canGet(true).canSet(true)

    /**
     * HDR configuration
     */
    val KeyHDR: AutelKeyInfo<Boolean> = AutelKeyInfo(component.value, CameraKeyConstants.HDR, AutelBooleanConvert())
        .canGet(true).canSet(true)

    /**
     * Defog configuration
     */
    val KeyDefog: AutelKeyInfo<DefogBean> = AutelKeyInfo(component.value, CameraKeyConstants.Defog, DefogConvert())
        .canGet(true).canSet(true)

    /**
     * ROI configuration
     */
    val KeyROI: AutelKeyInfo<ROIBean> = AutelKeyInfo(component.value, CameraKeyConstants.ROI, ROIConvert())
        .canGet(true).canSet(true)

    /**
     * ISO mode
     */
    val KeyISOMode: AutelKeyInfo<ISOModeEnum> = AutelKeyInfo(component.value, CameraKeyConstants.ISOMode, ISOModeConvert())
        .canGet(true).canSet(true)

    /**
     * Recording packet size
     */
    val KeyRecordPacket: AutelKeyInfo<RecordPacketBean> = AutelKeyInfo(component.value, CameraKeyConstants.RecordPacket, RecordPacketConvert())
        .canGet(true).canSet(true)

    /**
     * Stamp
     */
    val KeyWatermark: AutelKeyInfo<WatermarkBean> = AutelKeyInfo(component.value, CameraKeyConstants.Watermark, WatermarkConvert())
        .canGet(true).canSet(true)

    /**
     * IR thermal color information
     */
    val KeyThermalColor: AutelKeyInfo<ThermalColorEnum> = AutelKeyInfo(component.value, CameraKeyConstants.ThermalColor, ThermalColorConvert())
        .canGet(true).canSet(true)

    /**
     * IR image mode
     */
    val KeyThermalMode: AutelKeyInfo<ThermalImageBean> = AutelKeyInfo(component.value, CameraKeyConstants.ThermalMode, ThermalImageConvert())
        .canGet(true).canSet(true)

    /**
     * IR image enhancement configuration
     */
    val KeyThermalEnhance: AutelKeyInfo<ThermalEnhanceBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.ThermalEnhance, ThermalEnhanceConvert())
            .canGet(true).canSet(true)

    /**
     * IR image denoiser configuration
     */
    val KeyThermalDenoising: AutelKeyInfo<Boolean> = AutelKeyInfo(component.value, CameraKeyConstants.ThermalDenoising, AutelBooleanConvert())
        .canGet(true).canSet(true)

    /**
     * IR image gain
     */
    val KeyThermalGain: AutelKeyInfo<ThermalGainEnum> = AutelKeyInfo(component.value, CameraKeyConstants.ThermalGain, ThermalGainConvert())
        .canGet(true).canSet(true)

    /**
     * IR isotherm
     */
    val KeyThermalIsotherm: AutelKeyInfo<ThermalIsothermBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.ThermalIsotherm, ThermalIsothermConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature property
     */
    val KeyThermalTemperature: AutelKeyInfo<ThermalTempAttrBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.ThermalTemperature, ThermalTempAttrConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature warning property
     */
    val KeyThermalTemperatureAlarm: AutelKeyInfo<ThermalTempAlarmBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.ThermalTemperatureAlarm, ThermalTempAlarmConvert())
            .canGet(true).canSet(true)

    /**
     * IR emissivity
     */
    val KeyThermalRadiance: AutelKeyInfo<Int> = AutelKeyInfo(component.value, CameraKeyConstants.ThermalRadiance, AutelIntConvert())
        .canGet(true).canSet(true)

    /**
     * Photo resolution
     */
    val KeyTakePhotoResolution: AutelKeyInfo<PhotoResolutionEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.TakePhotoResolution, TakePhotoResolutionConvert())
            .canGet(true).canSet(true)

    /**
     * Recording resolution
     */
    val KeyRecordResolution: AutelKeyInfo<VideoResolutionBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.RecordResolution, RecordResolutionConvert())
            .canGet(true).canSet(true)

    /**
     * Photo format
     */
    val KeyPhotoFileFormat: AutelKeyInfo<PhotoFormatEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.PhotoFileFormat, PhotoFileFormatConvert())
            .canGet(true).canSet(true)

    /**
     * AEB photo count
     */
    val KeyTakePhotoAebCount: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.TakePhotoAebCount, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Burst count
     */
    val KeyTakePhotoBustCount: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.TakePhotoBustCount, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Timelapse photo interval
     */
    val KeyTakePhotoTimeLapse: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.TakePhotoTimeLapse, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Recording format
     */
    val KeyRecordFileFormat: AutelKeyInfo<VideoFormatEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.RecordFileFormat, VideoFileFormatConvert())
            .canGet(true).canSet(true)

    /**
     * Recording encoding
     */
    val KeyRecordFileEncodeFormat: AutelKeyInfo<VideoCompressStandardEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.RecordFileEncodeFormat, VideoEncodeFormatConvert())
            .canGet(true).canSet(true)

    /**
     * Video subtitles on/off
     */
    val KeyCameraSubtitleKey: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraSubtitleKey, AutelBooleanConvert())
            .canGet(true).canSet(true)

    /**
     * Basic camera parameter acquisition
     */
    val KeyGetBaseParamMsg: AutelKeyInfo<CameraBaseParamBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.GetBaseParamMsg, CameraBaseParamConvert())
            .canGet(true).canSet(true)

    /**
     * Anti-flicker mode
     */
    val KeyCameraAntiflicker: AutelKeyInfo<AntiflickerEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraAntiflicker, AntiflickerConvert())
            .canGet(true).canSet(true)

    /**
     * Automatic deactivation of robotic arms during photo taking/recording
     */
    val KeyCameraTurnOffArmLight: AutelKeyInfo<Boolean> = AutelKeyInfo(
        component.value, CameraKeyConstants.CameraTurnOffArmLight, AutelBooleanConvert()
    ).canGet(true).canSet(true)

    /**
     * Synced zoom on/off
     */
    val KeyCameraLinkageZoom: AutelKeyInfo<Boolean> = AutelKeyInfo(
        component.value, CameraKeyConstants.CameraLinkageZoom, AutelIntToBoolConverter()
    ).canGet(true).canSet(true)

    /**
     * Smooth zoom
     */
    val KeySmoothZoom: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.SmoothZoom, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Visual transmission
     */
    val KeyCameraVisualTransfer: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraVisualTransfer, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Camera mode
     */
    val KeyCameraWorkMode: AutelKeyInfo<CameraWorkModeEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_WORK_MODE_NEW_MSG, CameraWorkModeConvert())
            .canGet(true).canSet(true)

    /**
     * Photo sub-mode
     */
    val KeyCameraWorkModeTakePhoto: AutelKeyInfo<TakePhotoModeEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_WORK_MODE_TAKE_PHOTO_MSG, CameraWorkModeTakePhotoConvert())
            .canGet(true).canSet(true)

    /**
     * Recording sub-mode
     */
    val KeyCameraWorkModeVideo: AutelKeyInfo<RecordModeEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_WORK_MODE_VIDEO_MSG, CameraWorkModeVideoConvert())
            .canGet(true).canSet(true)

    /**
     * Image style
     */
    val KeyCameraImageStyleType: AutelKeyInfo<ImageStyleEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IMAGE_STYLE_TYPE_MSG, ImageStyleTypeConvert())
            .canGet(true).canSet(true)

    /**
     * Image brightness
     */
    val KeyCameraImageStyleBrightness: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IMAGE_STYLE_BRIGHTNESS_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Image contrast
     */
    val KeyCameraImageStyleContrast: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IMAGE_STYLE_CONTRAST_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Image saturation
     */
    val KeyCameraImageStyleSaturation: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IMAGE_STYLE_SATURATION_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Image hue
     */
    val KeyCameraImageStyleHue: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IMAGE_STYLE_HUE_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Image sharpness
     */
    val KeyCameraImageStyleSharpness: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IMAGE_STYLE_SHARPNESS_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * White balance mode
     */
    val KeyCameraWhiteBalanceType: AutelKeyInfo<WhiteBalanceEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_WHITE_BALANCE_TYPE_MSG, WhiteBalanceTypeConvert())
            .canGet(true).canSet(true)

    /**
     * White balance color temperature
     */
    val KeyCameraWhiteBalanceColorTemp: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_WHITE_BALANCE_COLOR_TEMP_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * PIV recording on/off
     */
    val KeyCameraPivEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_PIV_ENABLE_MSG, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * PIV interval
     */
    val KeyCameraPivInterval: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_PIV_INTERVAL_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Defog on/off
     */
    val KeyCameraDehazeEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_DEHAZE_ENABLE_MSG, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * Defog level
     */
    val KeyCameraDehazeStrength: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_DEHAZE_STRENGTH_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * IR image mode
     */
    val KeyCameraIrImageModeType: AutelKeyInfo<ThermalImageModeEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_IMAGE_MODE_TYPE_MSG, IrImageModeConvert())
            .canGet(true).canSet(true)

    /**
     * IR image contrast
     */
    val KeyCameraIrImageModeContrast: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_IMAGE_MODE_CONTRAST_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * IR image brightness
     */
    val KeyCameraIrImageModeLum: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_IMAGE_MODE_LUM_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * IR image enhancement on/off
     */
    val KeyCameraIrEnhanceEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_ENHANCE_ENABLE_MSG, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * IR image enhancement level
     */
    val KeyCameraIrEnhanceStrength: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_ENHANCE_STRENGTH_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature property: temperature measurement
     */
    val KeyCameraIrTempAttrType: AutelKeyInfo<TemperatureModeEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_TEMP_ATTR_TYPE_MSG, IrTempModeConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature property: tap point coordinates
     */
    val KeyCameraIrTempAttrTouch: AutelKeyInfo<ParameterPointBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_TEMP_ATTR_TOUCH_MSG, ParameterPointConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature property: area temperature measurement
     */
    val KeyCameraIrTempAttrRegion: AutelKeyInfo<ParameterRectBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_TEMP_ATTR_REGION_MSG, ParameterRectConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature property: measurement limit
     */
    val KeyCameraIrTempAttrLimitTemp: AutelKeyInfo<ParameterRectBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_TEMP_ATTR_LIMITTEMP_MSG, ParameterRectConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature warning property on/off
     */
    val KeyCameraIrTempAlarmEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_TEMP_ALARM_ENABLE_MSG, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * IR temperature warning property: high temperature threshold
     */
    val KeyCameraIrTempAlarmHotthred: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_TEMP_ALARM_HOTTHRED_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * IR temperature warning property: low temperature threshold
     */
    val KeyCameraIrTempAlarmColdthred: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_IR_TEMP_ALARM_COLDTHRED_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Electronic anti-shaking on/off
     */
    val KeyCameraElectronicAntiShaking: AutelKeyInfo<ElectronicAntiShakingEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraElectronicAntiShaking, AutelElectronicAntiShakingConverter())
            .canGet(true).canSet(true)

    /**
     * Mission folder name
     */
    val KeyCameraSaveMapTaskName: AutelKeyInfo<String> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_SAVE_MAP_TASK_NAME, AutelStringConvert())
            .canGet(true).canSet(true)

    /**
     * User-defined folder name
     */
    val KeyCameraSaveMapUserDirName: AutelKeyInfo<String> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_SAVE_MAP_USER_DIR_NAME, AutelStringConvert())
            .canGet(true).canSet(true)

    /**
     * Fast zooming
     */
    val KeyCameraTypeXoomFixedFactor: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_TYPE_ZOOM_FIXED_FACTOR_MSG, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Camera data encryption on/off
     */
    val KeyCameraTypeEncryptEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_TYPE_ENCRYPT_ENABLE, AutelIntToBoolConverter())
            .canGet(true)

    /**
     * Camera custom debugging
     */
    val KeyCameraDebugEvent: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_DEBUG_EVENT, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Recording on/off
     */
    val KeyCameraRecordEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_RECORD_ENABLE, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * Recording frame rate
     */
    val KeyCameraRecordFps: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_RECORD_FPS, AutelIntConvert()).canGet(true).canSet(true)

    /**
     * Recording duration
     */
    val KeyCameraRecordDuration: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_RECORD_DURATION, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Recording count
     */
    val KeyCameraRecordNumber: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_RECORD_NUMBER, AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Acquisition of the camera capability set version
     */
    val KeyCameraCapabilityVersion: AutelKeyInfo<String> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_CAPABILITY_VERSION, AutelStringConvert())
            .canGet(true).canSet(false)

    /**
     * Camera on/off
     */
    val KeyCameraEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_ENABLE, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * Stamp GPS on/off
     */
    val KeyCameraWatermarkGpsEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_WATERMARK_GPS_ENABLE, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * Stamp SN on/off
     */
    val KeyCameraWaterMarkSnEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_WATERMARK_SN_ENABLE, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * Camera vision on/off
     */
    val KeyCameraVisualEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_VISUAL_ENABLE, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * Photo/Recording night mode on/off
     */
    val KeyCameraUltraPixelEnable: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_ULTRA_PIXEL_ENABLE, AutelIntToBoolConverter())
            .canGet(true).canSet(true)

    /**
     * Video stream encoding (different from recording encoding)
     */
    val KeyCameraTransferPayLoadType: AutelKeyInfo<VideoCompressStandardEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_TRANSFER_PAYLOAD_TYPE, VideoEncodeFormatConvert())
            .canGet(true).canSet(true)

    /**
     * =============================== Camera ======================================
     */
    /**
     * Restart camera
     */
    val KeyCameraReboot: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.CameraReboot, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Format SD card
     */
    val KeyFormatSDCard: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.FormatSDCard, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Format MMC internal storage
     */
    val KeyFormatMMC: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.FormatMMC, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Resotre factory settings
     */
    val KeyCameraReset: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.CameraReset, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Start photo taking
     */
    val KeyStartTakePhoto: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.StartTakePhoto, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Stop photo taking
     */
    val KeyStopTakePhoto: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.StopTakePhoto, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Start recording
     */
    val KeyStartRecord: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.StartRecord, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Stop recording
     */
    val KeyStopRecord: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.StopRecord, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * FFC shutter
     */
    val KeyCameraFfc: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.CAMERA_FFC_MSG, AutelEmptyConvert(), AutelEmptyConvert())
            .canPerformAction(true)

    /**
     * Obtain photo/video storage type
     */
    val KeyCameraVideoPictureStorageTypeGet: AutelActionKeyInfo<CameraVideoPhotoStorageBean, CameraVideoPhotoStorageListBean> =
        AutelActionKeyInfo(
            component.value,
            CameraKeyConstants.CAMERA_VIDEO_PICTURE_STORAGE_TYPE_GET_MSG,
            CameraVideoPhotoStorageGetConvert(),
            CameraVideoPhotoStorageSetConvert()
        ).canPerformAction(true)

    /**
     * Set photo/video storage type
     */
    val KeyCameraVideoPictureStorageTypeSet: AutelActionKeyInfo<CameraVideoPhotoStorageListBean, Void> =
        AutelActionKeyInfo(
            component.value,
            CameraKeyConstants.CAMERA_VIDEO_PICTURE_STORAGE_TYPE_SET_MSG,
            CameraVideoPhotoStorageSetConvert(),
            AutelEmptyConvert()
        ).canPerformAction(true)

    /**
     * Set camera data encryption
     */
    val KeyCameraTypeEncryptionKey: AutelActionKeyInfo<CameraEncryptSetBean, CameraDeEncryptRspBean?> =
        AutelActionKeyInfo(component.value, CameraKeyConstants.CameraTypeEncryptSet, CameraEncryptSetConvert(), CameraDeEncryptRspConvert())
            .canPerformAction(true)

    /**
     * Data encryption incorrect password attempts
     */
    val KeyCameraPasswordWrongTimes: AutelKeyInfo< Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraPasswordWrongTimes,  AutelIntConvert())
            .canGet(true)

    /**
     * IR-Cut filter switch
     */
    val KeyCameraIrcutSwitch: AutelKeyInfo<IrcutSwitchEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraIrcutSwitch,  AutelCameraIrcutConvert())
            .canGet(true).canSet(true)

    /**
     * IR-night fusion on/off
     */
    val KeyCameraIrNightFusionEnable: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraIrNightFusionEnable,  AutelIntConvert())
            .canGet(true).canSet(true)

    /**
     * Mechanical shutter on/off
     */
    val KeyCameraMechanicalShutterEnable: AutelKeyInfo<Int> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraMechanicalShutterEnable,  AutelIntConvert())
            .canGet(true).canSet(true)
    /**
     * =============================== Camera message reporting =================================
     */
    /**
     * Reporting of camera status messages
     */
    val KeyCameraStatus: AutelKeyInfo<CameraStatusBean> = AutelKeyInfo(component.value, CameraKeyConstants.CameraStatus, CameraStatusConvert())
        .canListen(true)

    /**
     * Reporting of professional parameter information
     */
    val KeyProfessionalParamInfo: AutelKeyInfo<ProfessionalParamInfoBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.ProfessionalParamInfo, ProfessionalParamInfoBeanConvert()).canListen(true)

    /**
     * Reporting of photo information
     */
    val KeyPhotoFileInfo: AutelKeyInfo<PhotoFileInfoBean> = AutelKeyInfo(component.value, CameraKeyConstants.PhotoFileInfo, PhotoFileInfoConvert())
        .canListen(true).canSet(true)

    /**
     * Reporting of photo status
     */
    val KeyTakePhotoStatus: AutelKeyInfo<TakePhotoStatusBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.TakePhotoStatus, TakePhotoStatusConvert())
            .canListen(true)

    /**
     * Reporting of recording status
     */
    val KeyRecordStatus: AutelKeyInfo<RecordStatusBean> = AutelKeyInfo(component.value, CameraKeyConstants.RecordStatus, RecordStatusConvert())
        .canListen(true)

    /**
     * Reporting of recording information
     */
    val KeyRecordFileInfo: AutelKeyInfo<RecordFileInfoBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.RecordFileInfo, RecordFileInfoConvert())
            .canListen(true)

    /**
     * Reporting of SD card status
     */
    val KeySDCardStatus: AutelKeyInfo<CardStatusBean> = AutelKeyInfo(component.value, CameraKeyConstants.SDCardStatus, StorageStatusConvert())
        .canListen(true)

    /**
     * Reporting of MMC status
     */
    val KeyMMCStatusInfo: AutelKeyInfo<CardStatusBean> = AutelKeyInfo(component.value, CameraKeyConstants.MMCStatusInfo, StorageStatusConvert())
        .canListen(true)

    /**
     * Reporting of timer countdown
     */
    val KeyIntervalShotStatus: AutelKeyInfo<Int> = AutelKeyInfo(component.value, CameraKeyConstants.IntervalShotStatus, AutelIntConvert())
        .canListen(true)

    /**
     * Reporting of panorama status
     */
    val KeyPanoramaStatus: AutelKeyInfo<PanoramaStatusBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.PanoramaStatus, PanoramaStatusConvert())
            .canListen(true)

    /**
     * Reporting of timelapse status
     */
    val KeyDelayShotStatus: AutelKeyInfo<DelayShotStatusBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.DelayShotStatus, DelayShotStatusConvert())
            .canListen(true)

    /**
     * Reporting of camera reset status
     */
    val KeyResetCameraState: AutelKeyInfo<Boolean> = AutelKeyInfo(component.value, CameraKeyConstants.ResetCameraState, AutelBooleanConvert())
        .canListen(true)

    /**
     * Reporting of AE/AF status change
     */
    val KeyAeAfStatusChange: AutelKeyInfo<CameraAFAEStatusBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.AeAfStatusChange, CameraAFAEStatusConvert())
            .canListen(true)

    /**
     * Reporting of temperature warning events
     */
    val KeyTempAlarm: AutelKeyInfo<TempAlarmBean> = AutelKeyInfo(component.value, CameraKeyConstants.TempAlarm, TempAlarmConvert())
        .canListen(true)

    /**
     * Reporting of motion timelapse status
     */
    val KeyMotionDelayShotStatus: AutelKeyInfo<MotionDelayShotBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.MotionDelayShotStatus, MotionDelayShotStatusConvert()).canListen(true)

    /**
     * Reporting of camera exposure status
     */
    val KeyPhotoExposure: AutelKeyInfo<ExposureEnum> = AutelKeyInfo(component.value, CameraKeyConstants.PhotoExposure, PhotoExposureConvert())
        .canListen(true)

    /**
     * Reporting of waypoint information for mission recording
     */
    val KeyMissionRecordWaypoint: AutelKeyInfo<MissionRecordWaypointBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.MissionRecordWaypoint, MissionRecordWaypointConvert()).canListen(true)

    /**
     * Reporting of AF status
     */
    val KeyAFState: AutelKeyInfo<AFStateEnum> = AutelKeyInfo(component.value, CameraKeyConstants.AFState, AFStateConvert())
        .canListen(true)

    /**
     * Reporting of camera mode change
     */
    val KeyCameraModeSwitch: AutelKeyInfo<CameraModeSwitchBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraModeSwitch, CameraModeSwitchConvert())
            .canListen(true)

    /**
     * Reporting of display mode change
     */
    val KeyDisplayModeSwitch: AutelKeyInfo<DisplayModeEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.DisplayModeSwitch, DisplayModeConvert())
            .canListen(true)

    /**
     * Reporting of IR temperature information
     */
    val KeyInfraredCameraTempInfo: AutelKeyInfo<InfraredCameraTempInfoBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.InfraredCameraTempInfo, InfraredCameraTempInfoConvert()).canListen(true)


    /**
     * Reporting of storage status
     */
    val KeyStorageStatusInfo: AutelKeyInfo<StorageStatusInfoBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.StorageStatusInfo, StorageStatusInfoBeanConvert())
            .canListen(true)

    /**
     * Reporting of metering point information
     */
    val KeyLocationMeterInfo: AutelKeyInfo<MeteringPointBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.LocationMeterInfo, MeteringPointConvert())
            .canListen(true)

    /**
     * Reporting of white balance parameter
     */
    val KeyWhiteBalanceNtfy: AutelKeyInfo<WhiteBalanceBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.WhiteBalanceNtfy, WhiteBalanceConvert())
            .canListen(true)

    /**
     * Reporting of AE lock information
     */
    val KeyAeLockNtfy: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.AeLockNtfy, AutelBooleanConvert())
            .canListen(true)

    /**
     * Reporting of focus information
     */
    val KeyFocusNtfy: AutelKeyInfo<FocusInfoBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.FocusNtfy, FocusInfoConvert())
            .canListen(true)

    /**
     * Reporting of HDR information
     */
    val KeyHdrNtfy: AutelKeyInfo<Boolean> =
        AutelKeyInfo(component.value, CameraKeyConstants.HdrNtfy, AutelBooleanConvert())
            .canListen(true)

    /**
     * Reporting of ROI configuration
     */
    val KeyRoiNtfy: AutelKeyInfo<ROIBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.RoiNtfy, ROIConvert())
            .canListen(true)

    /**
     * Reporting of photo resolution
     */
    val KeyPhotoResolutionNtfy: AutelKeyInfo<PhotoResolutionEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.PhotoResolutionNtfy, TakePhotoResolutionConvert())
            .canListen(true)

    /**
     * Reporting of video resolution
     */
    val KeyVideoResolutionNtfy: AutelKeyInfo<VideoResolutionBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.VideoResolutionNtfy, RecordResolutionConvert())
            .canListen(true)

    /**
     * Reporting of decryption progress
     */
    val KeyCameraEncryptProgressReportNtfy: AutelKeyInfo<CameraEncryptProgressReportBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraEncryptProgressReportNtfy, CameraEncryptProgressReportConvert())
            .canListen(true)

    /**
     * Reporting of transmission information
     */
    val KeyCameraTransferInfoNtfy: AutelKeyInfo<CameraTransferInfoBean> =
        AutelKeyInfo(component.value, CameraKeyConstants.CAMERA_TRANSFER_INFO_NTFY, CameraTransferInfoConvert())
            .canListen(true)

    /**
     * Reporting of video stream decoding format (different from recording decoding)
     */
    val KeyCameraPreviewResolution: AutelKeyInfo<CameraPreviewResolutionEnum> =
        AutelKeyInfo(component.value, CameraKeyConstants.CameraPreviewResolution, CameraPreviewConvert())
            .canGet(true).canSet(true)
}

3.6.5 Flight Control

object FlightControlKey {

    private val component = ComponentType.FLIGHT_CONTROLLER

    /**
     * Compass calibration
     */
    val KeyCalibrateCompass: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_CALIBRATE_COMPASS_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Takeoff
     */
    val KeyTakeOffAirCraft: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_TAKEOFF_AIRCRAFT_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * false: cancels auto landing, true: executes auto landing
     */
    val KeySetLanding: AutelActionKeyInfo<Boolean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_SET_LANDING_MSG,
        AutelBooleanConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Starts/Stops motor
     */
    val KeyStartStopMotor: AutelActionKeyInfo<Boolean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_START_STOP_MOTOR_MSG,
        AutelBooleanConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     *
    *  action: Int = 0, //Action   0: cancels auto return, 1: executes auto return
    *  type: Int = 0   //Return type   0: returns to the home point, 1: returns to the alternate point
    **/
    val KeyStartStopAutoBack: AutelActionKeyInfo<DroneAutoBackBean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_START_STOP_AUTOBACK_MSG,
        DroneAutoBackConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Home point settings
     */
    val KeySetHomeLocation: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_SET_HOMELOCATION_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Custom alternate point settings
     */
    val KeyCustomHomeLocation: AutelActionKeyInfo<HomeLocation, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_CUSTOM_HOMELOCATION_MSG,
        CustomHomeLocationConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)


    /**
     * Custom alternate point settings (double)
     */
    val KeyCustomHomeLocationDouble: AutelActionKeyInfo<HomeLocationDouble, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_CUSTOM_HOMELOCATION_MSG,
        CustomHomeLocationDoubleConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)


    /**
     * Whether to upload no-fly zone files
     */
    val KeyCheckNFZUpload: AutelActionKeyInfo<NoFlyQzoneBean, Boolean> =
        AutelActionKeyInfo(
            component.value,
            MessageTypeConstant.FCS_CHECK_NFZ_UPLOAD_MSG,
            CheckNFZUploadConvert(),
            AutelBooleanConvert()
        ).canPerformAction(true)

    /**
     * No-fly zone mode on/off
     */
    val KeyEnableNFZ: AutelActionKeyInfo<Boolean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_ENABLE_NFZ_MSG,
        AutelBooleanConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Allow takeoff in attitude mode
     */
    val KeySetAttiTakeOff: AutelActionKeyInfo<Boolean, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_SET_ATTI_TAKEOFF_MSG,
        AutelBooleanConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * IMU calibration
     */
    val KeyCalibrateIMU: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_CALIBRATE_IMU_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)



    /**
     * Obtain mission GUID
     */
    val KeyGetMissionGuid: AutelActionKeyInfo<Void, String> =
        AutelActionKeyInfo(
            component.value,
            MessageTypeConstant.FCS_GET_MISSION_GUID_MSG,
            AutelEmptyConvert(),
            AutelStringConvert()
        ).canPerformAction(true)

    /**
     * Cancel return upon low power
     */
    val KeyCancelLowPowerBack: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        component.value,
        MessageTypeConstant.FCS_CANCEL_LOWPOWER_BACK_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Allow takeoff when the compass is abnormal
     */
    val KeySetCompassTakeOff: AutelActionKeyInfo<Boolean, Void> =
        AutelActionKeyInfo(
            component.value,
            MessageTypeConstant.FCS_SET_COMPASS_TAKEOFF_MSG,
            AutelBooleanConvert(),
            AutelEmptyConvert()
        ).canPerformAction(true)

    /**
     * Set the fourth axis to portrait mode
     */
    val KeySetPortraitMode: AutelActionKeyInfo<Boolean, Void> =
        AutelActionKeyInfo(
            component.value,
            MessageTypeConstant.FCS_SET_PORTRAIT_MODE_MSG,
            AutelBooleanConvert(),
            AutelEmptyConvert()
        ).canPerformAction(true)

    /**
     * Obtain flight control parameter list
     */
    val KeyGetCommonParams: AutelActionKeyInfo<Void, DroneCommonParamSetBean> =
        AutelActionKeyInfo(
            component.value,
            MessageTypeConstant.FCS_GET_COMMON_PARAMS_MSG,
            AutelEmptyConvert(),
            DroneCommonParamSetConverter()
        ).canPerformAction(true)

    /**
     * Withdraw propellers
     */
    val KeyNestRetractPaddleControl: AutelActionKeyInfo<Void, NestWaitTimeBean>? = AutelActionKeyInfo(
        component.value,
        NestConstant.NestRetractPaddleControl,
        AutelEmptyConvert(),
        NestWaitTimeConvert()
    ).canPerformAction(true)
}

3.6.6 Flight Parameter Read And Configuration

object FlightPropertyKey {
    private val component = ComponentType.FLIGHT_PARAMS

    /**
     * Novice mode
     */
    val KeyBeginMode: AutelKeyInfo<OperatorModeEnum> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_BEGIN_MODE_MSG,
            FlightParamBeginModeConvert()
        ).canGet(true).canSet(true)

    /**
     * Obtain/Set the maximum flight altitude
     */
    val KeyMaxHeight: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value, MessageTypeConstant.FCS_MAX_HEIGHT_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Obtain/Set the maximum flight radius
     */
    val KeyMaxRadius: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value, MessageTypeConstant.FCS_MAX_RADIUS_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Maximum horizontal flight speed
     */
    val KeyMaxHorizontalSpeed: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_MAX_HORIZONTAL_SPEED_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Maximum ascent speed
     */
    val KeyMaxAscentSpeed: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_MAX_ASCENT_SPEED_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Maximum descent speed
     */
    val KeyDescentSpeed: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_MAX_DESCENT_SPEED_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Obtain/Set return altitude
     */
    val KeyMissionManagerBackHeight: AutelKeyInfo<Float> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.MISSIONMANAGER_BACK_HEIGHT_MSG,
        AutelFloatConvert()
    ).canGet(true).canSet(true)

    /**
     * Buzzing status (find aircraft)
     */
    val KeyBuzzingStatus: AutelKeyInfo<Boolean> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_BUZZING_STATUS_MSG,
            AutelIntToBoolConverter()
        ).canGet(true).canSet(true)

    /**
     * ATTI mode
     */
    val KeyAttiMode: AutelKeyInfo<Boolean> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_ATTI_MODE_MSG,
            AutelIntToBoolConverter()
        ).canGet(true).canSet(true)

    /**
     * Set/Obtain yaw sensitivity
     */
    val KeyYawAngleSensitivity: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_YAW_ANGLE_SENSITIVITY_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Set/Obtain pitch sensitivity
     */
    val KeyPitchSensitivity: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_PITCH_SENSITIVITY_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Set/Obtain roll sensitivity
     */
    val KeyRollSensitivity: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_ROLL_SENSITIVITY_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Set/Obtain throttle sensitivity
     */
    val KeyThrustSensitivity: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_THRUST_SENSITIVITY_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Set/Obtain attitude sensitivity
     */
    val KeyAttitudeSensitivity: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_ATTITUDE_SENSITIVITY_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Set/Obtain braking sensitivity
     */
    val KeyBrakeSensitivity: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_BRAKE_SENSITIVITY_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Yaw sensitivity; Default: 1.0; Range: [0.2-1.2]
     */
    val KeyYawTripSensitivity: AutelKeyInfo<Float> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_YAW_TRIP_SENSITIVITY_MSG,
            AutelFloatConvert()
        ).canGet(true).canSet(true)

    /**
     * Low battery power warning
     */
    val KeyBatteryLowWarning: AutelKeyInfo<Int> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.MISSIONMANAGER_BATTERY_LOW_WARNING_MSG,
            AutelIntConvert()
        ).canGet(true).canSet(true)

    /**
     * Critically low battery power warning
     */
    val KeyBatSeriousLowWarning: AutelKeyInfo<Int> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.MISSIONMANAGER_BAT_SERIOUS_LOW_WARNING_MSG,
            AutelIntConvert()
        ).canGet(true).canSet(true)

    /**
     * Low power return on/off
     */
    val KeyLowBatLowBack: AutelKeyInfo<Boolean> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.MISSIONMANAGER_LOW_BAT_LOW_BACK_MSG,
            AutelBooleanConvert()
        ).canGet(true).canSet(true)

    /**
     * Lost action
     */
    val KeyRCLostAction: AutelKeyInfo<DroneLostActionEnum> =
        AutelKeyInfo(
            component.value, MessageTypeConstant.FCS_RC_LOST_ACTION_MSG,
            DroneLostActionConverter()
        ).canGet(true).canSet(true)

    /**
     * Set/Obtain aircraft mode
     */
    val KeyGearLever: AutelKeyInfo<GearLevelEnum> =
        AutelKeyInfo(
            component.value, MessageTypeConstant.FCS_GEAR_LEVEL_MSG,
            GearLevelConverter()
        ).canGet(true).canSet(true)

    /**
     * Coordinated turn on/off
     */
    val KeyCoordinatedTurn: AutelKeyInfo<Boolean> =
        AutelKeyInfo(
            component.value,
            MessageTypeConstant.FCS_COORDINATED_TURN_MSG,
            AutelBooleanConvert()
        ).canGet(true).canSet(true)

    /**
     * Fusion positioning on/off
     */
    val KeyLocationStatus: AutelKeyInfo<Boolean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.FCS_VISION_LOCATION_STATUS_MSG,
        AutelIntToBoolConverter()
    ).canSet(true).canGet(true)

    /**
     * Obstacle avoidance on/off
     */
    val KeyFcsApasModeEn: AutelKeyInfo<Boolean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.FCS_APAS_MODE_EN,
        AutelIntToBoolConverter()
    ).canSet(true).canGet(true)

    /**
     * Silent mode on/off
     */
    val KeySilentModeStatus: AutelKeyInfo<Boolean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.FCS_SILENT_MODE_STATUS_MSG,
        AutelIntToBoolConverter(),
    ).canSet(true).canGet(true)

    /**
     * Supercapacity on/off
     */
    val KeyFCSEnSuperCap: AutelKeyInfo<Boolean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.FCS_EN_SUPER_CAP_MSG,
        AutelIntToBoolConverter(),
    ).canSet(true).canGet(true)

    /**
     * GPS flying on/off
     */
    val KeyFcsEnGpsMode: AutelKeyInfo<Boolean> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.FCS_EN_GPS_MODE,
        AutelIntToBoolConverter(),
    ).canSet(true).canGet(true)

    /**
     * GPS mode
     */
    val KeyFcsSwitchGpsMode: AutelKeyInfo<DroneGpsEnum> = AutelKeyInfo(
        component.value,
        MessageTypeConstant.FCS_SWITCH_GPS_MODE,
        DroneGpsConverter(),
    ).canSet(true).canGet(true)


}

3.6.7 Gimbal

object GimbalKey {

    private val componentVal = ComponentType.GIMBAL.value

    /**
     * Reporting of gimbal information
     */
    val KeyHeatBeat: AutelKeyInfo<DroneGimbalStateBean> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_HEART_BEAT_MSG,
        GimbalHeartBeatConvert()
    ).canListen(true)

    /**
     * Roll adjustment
     */
    val KeyRollAdjustAngle: AutelKeyInfo<Int> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_ROLL_ADJUST_ANGLE_MSG,
        AutelIntConvert(),
    ).canSet(true).canGet(true)

    /**
     * Pitch adjustment
     */
    val KeyPitchAngleRange: AutelKeyInfo<Int> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_PITCH_ADJUST_ANGLE_MSG,
        AutelIntConvert()
    ).canSet(true).canGet(true)

    /**
     * Yaw adjustment
     */
    val KeyYawAdjustAngle: AutelKeyInfo<Int> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_YAW_ADJUST_ANGLE_MSG,
        AutelIntConvert(),
    ).canSet(true).canGet(true)

    /**
     * Start IMU calibration
     */
    val KeyStartIMUCalibration: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_START_IMU_CALIBRATION_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Start gimbal calibration
     */
    val KeyStartCalibration: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_START_CALIBRATION_MSG,
        AutelEmptyConvert(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Rotating 4-axis gimbal
     */
    val KeyRotateFouraxisAngle: AutelActionKeyInfo<RotateFourAxisParamsBean, Void> = AutelActionKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_ROTATE_FOURAXIS_ANGLE_MSG,
        RotateFourAxisParamsConverter(),
        AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Gimbal work mode
     */
    val KeyWordMode: AutelKeyInfo<Int> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_WORK_MODE_MSG,
        AutelIntConvert()
    ).canSet(true).canGet(true)

    /**
     * Pitch range on/off
     */
    val KeyPitchAngelRange: AutelKeyInfo<Boolean> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_PITCH_ANGLE_RANGE_MSG,
        AutelIntToBoolConverter()
    ).canSet(true).canGet(true)

    /**
     * Pitch speed
     */
    val KeyPitchSpeed: AutelKeyInfo<Int> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_PITCH_SPEED_MSG,
        AutelIntConvert()
    ).canSet(true).canGet(true)

    /**
     * Gimbal angle control
     */
    val KeyAngleControl: AutelActionKeyInfo<Float, Void> = AutelActionKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_ANGLE_CONTROL_MSG,
        AutelFloatConvert(), AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Gimbal orientation control
     */
    val KeyOrientationControl: AutelActionKeyInfo<GimbalOrientationEnum, Void> = AutelActionKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_ORIENTATION_CONTROL_MSG,
        GimbalOrientationConverter(), AutelEmptyConvert()
    ).canPerformAction(true)

    /**
     * Laser rangefinder on/off
     */
    val KeyLaserRangingSwitch: AutelKeyInfo<Boolean> = AutelKeyInfo(
        componentVal,
        MessageTypeConstant.GIMBAL_LASER_RANGING_SWITCH,
        AutelIntToBoolConverter(),
    ).canSet(true).canGet(true)

}

3.6.8 Vision

object VisionKey {

    val component = ComponentType.VISION

    /**
     * Radar chart warning
     */
    val KeyReportEmergency: AutelKeyInfo<List<VisionRadarInfoBean>> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_REPORT_EMERGENCY_MSG,
        VisionWarningConvert()
    ).canListen(true)

    /**
     * Obstacle avoidance on/off
     */
    val KeyObstacleAvoidance: AutelKeyInfo<Boolean> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_HORIZONTAL_OBSTACLE_AVOIDANCE_MSG,
        AutelIntToBoolConverter()
    ).canSet(true).canGet(true)

    /**
     * Horizontal braking distance
     */
    val KeyHorizontalBrakeDistance: AutelKeyInfo<Float> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_HORIZONTAL_BRAKE_DISTANCE_MSG,
        AutelFloatConvert()
    ).canSet(true).canGet(true)

    /**
     * Horizontal warning distance
     */
    val KeyHorizontalWarningDistance: AutelKeyInfo<Float> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_HORIZONTAL_WARNING_DISTANCE_MSG,
        AutelFloatConvert()
    ).canSet(true).canGet(true)


    /**
     * Top braking distance
     */
    val KeyTopBrakeDistance: AutelKeyInfo<Float> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_TOP_BRAKE_DISTANCE_MSG,
        AutelFloatConvert()
    ).canSet(true).canGet(true)

    /**
     * Top warning distance
     */
    val KeyTopWarningDistance: AutelKeyInfo<Float> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_TOP_WARNING_DISTANCE_MSG,
        AutelFloatConvert()
    ).canSet(true).canGet(true)


    /**
     * Bottom braking distance
     */
    val KeyBottomBrakeDistance: AutelKeyInfo<Float> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_BOTTOM_BRAKE_DISTANCE_MSG,
        AutelFloatConvert()
    ).canSet(true).canGet(true)

    /**
     * Bottom warning distance
     */
    val KeyBottomWarningDistance: AutelKeyInfo<Float> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_BOTTOM_WARNING_DISTANCE_MSG,
        AutelFloatConvert()
    ).canSet(true).canGet(true)

    /**
     * Radar detection on/off
     */
    val KeyRadarDetection: AutelKeyInfo<Boolean> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.VISION_RADAR_DETECTION_MSG,
        AutelBooleanConvert()
    ).canSet(true).canGet(true)

    /**
     * MIF visual positioning status
     */
    val KeyAutonomyMifWorkStatus: AutelKeyInfo<Boolean> = AutelKeyInfo(
        FlightMissionKey.component.value,
        MessageTypeConstant.AUTONOMY_MIF_WORK_STATUS_MSG,
        AutelIntToBoolConverter()
    ).canSet(true).canGet(true)

}

3.6.9 Airlink Transmission

object AirLinkKey {
    private val component = ComponentType.ALINK

    /**
     * Transmission frequency band read and write
     */
    val KeyALinkBandMode: AutelKeyInfo<AirLinkBandModeEnum> = AutelKeyInfo(
        component.value,
        ALinkConstant.AirLinkBandMode,
        AirLinkBandModeConvert()
    ).canGet(true).canSet(true)

    /**
     * Transmission resolution mode
     */
    val KeyALinkTransmissionMode: AutelKeyInfo<VideoTransMissionModeEnum> =
        AutelKeyInfo(
            component.value,
            ALinkConstant.AirLinkTransmissionMode,
            AirLinkTransmissionModeConvert()
        ).canGet(true).canSet(true)

    /**
     * Radiated power mode
     */
    val KeyALinkFccCeMode: AutelKeyInfo<FccCeModeEnum> =
        AutelKeyInfo(
            component.value,
            ALinkConstant.AIRLINK_FCC_CE_MODE_MSG,
            AirLinkFccCeModeConvert()
        ).canGet(true).canSet(true)

    /**
     * Start pairing
     */
    val KeyALinkStartMatching: AutelActionKeyInfo<Void, Void> =
        AutelActionKeyInfo(
            ComponentType.REMOTE_CONTROLLER.value,
            ALinkConstant.AirLinkStartMatching,
            AutelEmptyConvert(),
            AutelEmptyConvert()
        ).canPerformAction(true)

    /**
     * Pairing progress reporting event
     */
    val KeyALinkMatchingStatus: AutelKeyInfo<AirLinkMatchStatusEnum> =
        AutelKeyInfo(
            ComponentType.REMOTE_CONTROLLER.value,
            ALinkConstant.AirLinkMatchingStatus,
            AirLinkMatchingStatusConvert()
        ).canListen(true)

    /**
     * Reporting of pairing duration. Will be reported twice, and the shorter duration will be used. Debugging tool is used.
     */
    val KeyALinkMatchCostTime: AutelKeyInfo<AirlinkMatchCostTimeBean> =
        AutelKeyInfo(
            ComponentType.REMOTE_CONTROLLER.value,
            ALinkConstant.AIRLINK_MATCH_COST_TIME_NTFY,
            AirLinkMatchCostTimeConvert()
        ).canListen(true)
}

3.7 Remote Controller

Remote controller commands are sent through KeyManager like the aircraft, but differing in the way to obtain KeyManager. The following uses the query of remote controller information as an example.

val remoteKeyManager =

DeviceManager.getDeviceManager().getFirstRemoteDevice()?.getKeyManager()

remoteKeyManager?.performAction(KeyTools.createKey(RemoteControllerKey.KeyRcDeviceInfo),null,
            object :
            CommonCallbacks.CompletionCallbackWithParam<List<DroneVersionItemBean>> {
            override fun onSuccess(t: List<DroneVersionItemBean>?) {
            }

            override fun onFailure(error: IAutelCode, msg: String?) {
            }
})

3.8 Precautions

Calling performAction, setValue, and getValue requires the corresponding module key. For example, you can call getValue only when canGet(true) is available.