1. Overview

The purpose of this tutorial is to help you understand the functionality of AUTEL Mobile SDK (referred to as MSDK) and master the usage of its related interfaces. MSDK covers services for communicating with various aircraft modules, which mainly include:

• General module
• Flight mission module
• AI service module
• Camera module
• Flight control module
• Flight parameter module
• Gimbal module
• Vision module
• Image transmission module

Additionally, it provides functionality for monitoring aircraft connection status and remote controller module features. Below, we will explain how to utilize these features during development.

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, refer to the GitHub sample program for other related dependencies.

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

SDKManager.get().init(applicationContext, sdkInitConfig)

param1: Context object. ApplicationContext is used.

Param2: MSDK configuration parameters, using SDKInitConfig, as shown below:

class SDKInitConfig {
    /**
     * Debug mode
     */
    var debug: Boolean = false

    /**
     * Data storage interface
     */
    var storage: IAutelStorage? = null

    /**
     * Log printing interface
     */
    var log: IAutelLog? = null

    /**
     * Player rendering mode
     * RenderNone: The player will not decode/render internally
     * RenderWithSurface: High-efficiency rendering mode that binds a Surface to the decoder and renders via OpenGL. When using this mode, even if a callback function is set, YUV data will not be returned.
     * RenderWithYUV: The player's internal decoder outputs YUV frame data for rendering. If external access to YUV data is required,this mode must be set for the onFrameYuv callback to be triggered.
     */
    var renderMode: RenderMode? = RenderMode.RenderWithYUV

    /**
     * For DragonFish series, this should be set to false(DragonFish defaults to mesh version)
     */
    var single: Boolean? = false

    /**
     * For the DragonFish series, this should be set to true(DragonFish and DragonFish base station supported)
     */
    var bSupportBaseStation: Boolean? = true
}

3.2 KeyManager Overview

3.2.1 Obtaining Devices

Various devices can be obtained through DeviceManager for our operations.

//remoter device
 val remoterDevice = DeviceManager.getDeviceManager().getFirstRemoteDevice()
 //drone device
 val droneDevice = DeviceManager.getDeviceManager().getFirstDroneDevice()
 //Wifi base station device
 val baseStationDevice = DeviceManager.getDeviceManager().getBaseStationDevice()

3.2.2 AutelKey Interface Definition

AutelKey serves as the unified interface definition format in MSDK:

• MSDK provides numerous Key interface definitions (refer to KeyValue documentation for details)
• The Key's properties determine what operations can be performed through the interface
• Some Keys support mixed operations

canSet(true)  //Indicates the property associated with the Key can be set
canGet(true)  //Indicates the property associated with the Key can be retrieved
canPerformAction(true) //Indicates the Key has Action capability
canListen(true) //Indicates the Key can be monitored/listened to
setFrequencyReport(true) //Enables frequency reporting, no request result acknowledgment

KeyTools: AutelKey Instantiation Utility：

val createKey = KeyTools.createKey(CameraKey.KeyCameraDeviceInfo)
//For multi-lens camera configurations, specific lenses can be designated for certain interfaces.
val key = KeyTools.createLensKey(CameraKey.KeyApertureSize,  LensTypeEnum.WideAngle)

3.2.3 Obtaining the KeyManager

KeyManager serves as the request manager for processing AutelKey operations.

val dKeyManager = DeviceManager.getDeviceManager().getFirstRemoteDevice()?.getKeyManager()
val rKeyManager = DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()
val bKeyManager = DeviceManager.getDeviceManager().getBaseStationDevice()?.getKeyManager()

3.2.4 KeyManager getValue Interface

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

val key = KeyTools.createKey(CameraKey.KeyCameraDeviceInfo)
DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.getValue(key,
    object : CommonCallbacks.CompletionCallbackWithParam<DeviceInfoBean> {
        override fun onSuccess(t: CameraDeviceInfoBean?) {}
        override fun onFailure(error: IAutelCode, msg: String?) {}
})

3.2.5 KeyManager setValue interface

This is generally used to set specific properties on the aircraft. For example, setting the camera work mode:Cancels the listening process set using the previous method.

val key = KeyTools.createKey(CameraKey.KeyCameraWorkMode)
val param = CameraWorkModeEnum.PHOTO
DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.setValue(key,param,                    object : CommonCallbacks.CompletionCallback {
        override fun onSuccess() {}
        override fun onFailure(code: IAutelCode, msg: String?) {}
})

3.2.6 KeyManager performAction interface

This interface is typically used to execute specific actions or commands. Example: triggering photo capture:

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.7 KeyManager setFrequencyReport interface

The App supports periodic reporting to the device without requiring ACK acknowledgment. Example: RTK data reporting to the aircraft:

private val rtkSendKey = KeyTools.createKey(RtkPropertKey.KeyRTKRtcmSent)
val bean = RtkRtcmDataBean()
DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()?.setFrequencyReport(rtkSendKey, bean)

3.2.8 KeyManager listen interface

Used to monitor device notifications. The reporting mechanism supports both fixed frequencies (5Hz/2Hz/1Hz) and event-triggered updates. Example: periodic reporting of camera professional 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.9 KeyManager cancelListen interface

The listener should be removed when monitoring is no longer required by the business logic, otherwise memory leaks may occur. Example: unsubscribing from camera professional parameter updates:

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.3 Aircraft Status Monitoring

The UAV maintains multiple state conditions. The business layer must verify that all states are normal before executing corresponding operations.

DeviceManager.getDeviceManager().addDroneListener(this)
DeviceManager.getDeviceManager().removeDroneListener(this)

Monitoring Interface Specification

interface IAutelDroneListener {

/**
 * Drone Connection State Listener
 *
 * @param connected  - isConnected
 * @param drone - drone device
*/
fun onDroneChangedListener(connected: Boolean, drone: IAutelDroneDevice)
  
/**
 * Indicates the availability of the UAV's main service. When available, the UAV is typically capable of processing requests."
 * @param valid true: can use，false: can not use
 * @param drone: drone device
 */
fun onMainServiceValid(valid: Boolean, drone: IAutelDroneDevice) {}

/**
 * Drone Camera Capabilities Change Notification
 * @param localFetched true: local camera capabilities load
 * @param remoteFetched true: drone camera capabilities download and load success
 */
fun onCameraAbilityFetchListener(localFetched: Boolean, remoteFetched: Boolean, drone: IAutelDroneDevice){}
  
/**
* drone device create
* @param drone:drone device
*/
fun onDroneCreate(drone: IAutelDroneDevice){}

/**
* drone device destroy
* @param drone:drone device
*/
fun onDroneDestroy(drone: IAutelDroneDevice){}

3.4 UAV and Remote Controller Frequency Pairing

Frequency pairing between the remote controller and aircraft is required to establish connectivity. For multi-aircraft network configuration, please consult the networking documentation. The UAV can be put into pairing mode by double-clicking its power button.

Use the following interface to initiate remote controller pairing mode:

val matchKey = KeyTools.createKey(AirLinkKey.KeyALinkStartMatching)
DeviceManager.getDeviceManager().getLocalRemoteDevice().getKeyManager().performAction(matchKey, null, 
     object : CommonCallbacks.CompletionCallbackWithParam<Void> {
          override fun onSuccess(t: Void?) { }
          override fun onFailure(error: IAutelCode, msg: String?) {}
  })

Pairing Status Monitoring:

val listenCallBack: CommonCallbacks.KeyListener<AirLinkMatchStatusEnum> = object : CommonCallbacks.KeyListener<AirLinkMatchStatusEnum> {
        override fun onValueChange(oldValue: AirLinkMatchStatusEnum?, newValue: AirLinkMatchStatusEnum) {
            AutelLog.i(AppTagConst.MatchTag, "keyLinkMatch -> $newValue")
        }
}
DeviceManager.getDeviceManager().getLocalRemoteDevice().getKeyManager().listen(KeyTools.createKey(AirLinkKey.KeyALinkMatchingStatus), listenCallBack)

3.5 Obtaining Camera Capabilities Information

The camera capability set provides an interface to access the UAV's gimbal and camera configuration settings. The following interface allows retrieval of gimbal camera lens configuration data.

val cameraAbility =DeviceManager.getFirstDroneDevice()?.getCameraAbilitySetManger()

The camera capability set defines the available functionalities of the current camera and lens configuration, including their supported parameter ranges and specifications.

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

interface ICameraSupport2 {
    /**
     * Returns the list of currently supported valid video resolutions and frame rates.
     * @param lensType lens type enum
     * @param flightMode flight mode enum
     * @param modeEnum recording mode enum
     * @return video resolution frame data list
     */
    fun getResolutionAndFrameRate(
        lensType: LensTypeEnum,
        flightMode: FightModeEnum?,
        modeEnum: RecordModeEnum?
    ): List<VideoResolutionFrameBean>

    /**
     * Returns the list of photo resolutions supported for HDR.
     * @param lensType lens type enum
     * @param flightMode flight mode enum
     * @param photoFormat photo output format enum
     * @param modeEnum camera mode enum
     * @return list of all photo resolution list
     */
    fun getHDRSupportPhoto(
        lensType: LensTypeEnum,
        flightMode: FightModeEnum,
        photoFormat: PhotoFormatEnum,
        modeEnum: CameraModeEnum
    ): List<PhotoResolutionEnum>

    /**
     * Returns the currently valid camera modes.
     * @param lensType lens type enum
     * @param flightMode flight mode enum and by default manual
     * @param modeEnum take photo mode enum and by default unknown
     * @return camera mode list
     */
    fun getCameraModeRange(
        lensType: LensTypeEnum,
        flightMode: FightModeEnum,
        modeEnum: TakePhotoModeEnum
    ): ArrayList<CameraModeEnum>

    /**
     * Returns the range for manual focus, including the minimum, maximum, and step values."Default": {"Min": 1,"Max": 50,"Step": 1 }
     * @param lensType lens type enum
     *  @return range with min, max and step value
     */
    fun getManualFocus(
        lensType: LensTypeEnum
    ): RangeStepIntValue?

    /**
     *  Returns the zoom range for the camera.
     * @param lensType lens type enum
     * @return range with min, max and step value
     */
    fun getPhotoZoom(
        lensType: LensTypeEnum,
        videoZoomType: VideoZoomTypeEnum
    ): RangeStepValue?

    /**
     * Returns the size of the video zoom.
     * @param lensType lens type enum
     * @param videoZoomType video zoom type and by default as Default enum
     * @return range with min, max and step value
     */
    fun getVideoZoom(
        lensType: LensTypeEnum,
        videoZoomType: VideoZoomTypeEnum
    ): RangeStepValue?

    /**
     * Returns the list of values for watermarks and timestamps.
     * @param lensType lens type enum
     * @param photoFormat photo output format enum
     * @return time stamp in integer value
     */
    fun getWatermarkTimestamp(
        lensType: LensTypeEnum,
        photoFormat: PhotoFormatEnum
    ): Int

    /**
     * Returns the current valid camera exposure modes.
     * @param lensType lens type enum
     * @return Exposure modes in list
     */
    fun getExposureModeRange(
        lensType: LensTypeEnum
    ): ArrayList<ExposureModeEnum>

    /**
     * Returns the current valid range for exposure compensation.
     * @param lensType lens type enum
     * @return exposure compensations in list
     */
    fun getExposureCompensationRange(
        lensType: LensTypeEnum
    ): ArrayList<ExposureExposureCompensationEnum>

    /**
     * Returns the current valid camera ISO range.
     * @param lensType lens type enum
     * @param isPhoto photo or not defined with boolean
     * @param pattern camera pattern enum and by default Manual flight
     * @param modeEnum Take photo mode enum by default Unknown
     * @return image ISO enums list
     */
    fun getImageISOList(
        lensType: LensTypeEnum,
        isPhoto: Boolean,
        pattern: Int = PatternModeEnum.MANUAL.value,
        modeEnum: TakePhotoModeEnum
    ): ArrayList<ImageISOEnum>

    /**
     * Returns the list of ISO modes valid for the camera in photo mode.
     * @param lensType lens type enum
     * @return image ISO enums list
     */
    fun getPhotoISOModeRange(
        lensType: LensTypeEnum
    ): List<ISOModeEnum>

    /**
     * Returns the list of ISO modes valid for the camera in video mode.
     * @param lensType lens type enum
     * @return ISOModeEnum list
     */
    fun getVideoISOModeRange(
        lensType: LensTypeEnum
    ): List<ISOModeEnum>

    /**
     * Returns the range of shutter speeds currently available for the camera.
     * @param lensType lens type enum
     *  @param isPhoto photo or not
     * @param modeEnum take photo mode enum and by default unknown
     * @return ShutterSpeedEnums list
     */
    fun getShutterList(
        lensType: LensTypeEnum,
        isPhoto: Boolean,
        fps: Int,
        modeEnum: TakePhotoModeEnum
    ): ArrayList<ShutterSpeedData>

    /**
     * Returns the range of apertures that can be set on the current camera.
     * @param lensType lens type enum
     * @return Lris enum list
     */
    fun getApertureRange(
        lensType: LensTypeEnum
    ): List<Double>

    /**
     * Returns the range of video formats currently selectable for the camera.
     * @param lensType lens type enum
     * @return video format enum list
     */
    fun getVideoFileFormatRange(
        lensType: LensTypeEnum
    ): List<VideoFormatEnum>

    /**
     *Returns the range of intervals at which photos can be taken during video recording.
     * @param lensType lens type enum
     * @return video piv enum list
     */
    fun getPicInVideoIntervalRange(
        lensType: LensTypeEnum
    ): List<VideoPivEnum>

    /**
     * Returns the range of video standards currently selectable for the camera.
     * @param lensType lens type enum
     * @return video standard
     */
    fun getVideoStandardRange(
        lensType: LensTypeEnum
    ): List<VideoStandardEnum>

    /**
     * Returns the range of photo file formats currently selectable for the camera.
     * @param lensType lens type enum
     * @param modeEnum take photo mode state
     * @return photo formatted enum list
     */
    fun getPhotoFileFormatRange(
        lensType: LensTypeEnum,
        modeEnum: TakePhotoModeEnum,
        photoResolution: PhotoResolutionEnum
    ): List<PhotoFormatEnum>

    /**
     * Returns the range of burst shot counts currently selectable for the camera.
     * @param lensType lens type enum
     * @return count list send
     */
    fun getPhotoBurstCountRange(
        lensType: LensTypeEnum
    ): List<Int>

    /**
     * Returns the range of AEB (Auto Exposure Bracketing) shot counts currently selectable for the camera.
     * @param lensType The type of lens as an enum.
     * @param lensType lens type enum
     * @return photo count list send
     */
    fun getPhotoAEBCaptureCountRange(
        lensType: LensTypeEnum
    ): List<Int>

    /**
     * Returns the range of time intervals currently selectable for timed photography.
     * @param lensType lens type enum
     * @return lens type list
     */
    fun getPhotoIntervalParamRange(
        lensType: LensTypeEnum
    ): List<Int>

    /**
     * Returns the list of current camera white balance options.
     * @param lensType lens type enum
     * @return white balances enum list
     */
    fun getWhiteBalanceList(
        lensType: LensTypeEnum
    ): ArrayList<WhiteBalanceEnum>

    /**
     * Returns the range of custom color temperature values for white balance.
     * @param lensType lens type enum
     * @return range step int value
     */
    fun getCustomColorTemperatureRange(
        lensType: LensTypeEnum
    ): RangeStepIntValue?

    /**
     * Returns the range of defog modes available for the current camera.
     * @param lensType lens type enum
     * @return defog mode enum list
     */
    fun getDehazeModeRange(
        lensType: LensTypeEnum
    ): List<DefogModeEnum>

    /**
     * Returns the range of selectable defog settings for the current camera.
     * @param lensType lens type enum
     * @return defog mode enum list
     */
    fun getDehazeSettingSwitchRange(
        lensType: LensTypeEnum
    ): List<DefogEnum>

    /**
     * Returns the merged range of selectable defog settings for the current camera.
     * @param lensType lens type enum
     * @return defog mode enum list
     */
    fun getDehazeSettingSwitchMergeRange(
        lensType: LensTypeEnum
    ): List<DefogEnum>

    /**
     * Returns the range of selectable anti-flicker modes for the current camera.
     * @param lensType lens type enum
     * @return anti flicker range list
     */
    fun getAntiFlickerRange(
        lensType: LensTypeEnum
    ): List<Int>

    /**
     * The transferMode represents the clarity of the video transmission: 1 for Smooth 720p, 2 for HD 1080p, 3 for Ultra HD 2.7K.
     * @param lensType lens type enum
     * @return video transmission mode enum list
     */
    fun getTransferMode(
        lensType: LensTypeEnum
    ): List<VideoTransMissionModeEnum>

    /**
     * Returns the range of selectable image resolutions for the current camera.
     * @param lensType lens type enum
     * @param flightMode flight mode enum
     * @param modeEnum take photo mode enum and by default unknown
     * @return photo resolution enum list
     */
    fun getPhotoResolution(
        lensType: LensTypeEnum,
        flightMode: FightModeEnum,
        modeEnum: TakePhotoModeEnum
    ): List<PhotoResolutionEnum>

    /**
     * Returns the range of selectable image resolutions for the current camera. If there is no corresponding enum, return UNKNOWN and then re-acquire the photo album resolution list.
     * @param lensType lens type enum
     * @param flightMode flight mode enum
     * @param modeEnum take photo mode enum and by default unknown
     * @return photo resolution list
     */
    fun getPhotoResolutionTwice(
        lensType: LensTypeEnum ,
        flightMode: FightModeEnum,
        modeEnum: TakePhotoModeEnum
    ): List<PhotoResolution>

    /**
     * Returns the range of selectable sharpness levels for the current camera.
     * @param lensType lens type enum
     * @param modeEnum take photo mode enum and by default unknown
     * @return list of integer
     */
    fun getSharpnessRange(
        lensType: LensTypeEnum,
        modeEnum: TakePhotoModeEnum
    ): List<Int>

    /**
     *  Returns the range of selectable contrast levels for the current camera.
     *  @param lensType lens type enum
     *  @param modeEnum take photo mode enum and by default unknown
     *  @return list of integer
     */
    fun getContrastRange(
        lensType: LensTypeEnum,
        modeEnum: TakePhotoModeEnum
    ): List<Int>

    /**
     *  Returns the range of selectable saturation levels for the current camera.
     *  @param lensType lens type enum
     *  @param modeEnum take photo mode enum and by default unknown
     *  @return list of integer
     */
    fun getSaturationRange(
        lensType: LensTypeEnum,
        modeEnum: TakePhotoModeEnum
    ): List<Int>

    /**
     *  Returns the range of selectable focus modes for the current camera.
     * @param lensType lens type enum
     * @param modeEnum take photo mode enum and by default unknown
     *  @return list of integer
     */
    fun getLensFocusModeRange(
        lensType: LensTypeEnum ,
        modeEnum: CameraModeEnum
    ): List<Int>

    /**
     *  Returns the list of thermal color modes supported by the current camera.
     * @param lensType lens type enum
     * @return thermal color enum list
     */
    fun supportedIrColor(
        lensType: LensTypeEnum
    ): List<ThermalColorEnum>

    /**
     * Returns the temperature measurement modes for thermal imaging.
     * @param lensType lens type enum
     * @return IR temp mode enum
     */
    fun getThermalIRTempMode(
        lensType: LensTypeEnum
    ): List<IRTempModeEnum>

    /**
     * Returns the image modes for thermal imaging.
     * @param lensType lens type enum
     * @return Ir image mode object
     */
    fun getThermalIrImageMode(
        lensType: LensTypeEnum
    ): IrImageMode?

    /**
     * Returns the enhancement settings for thermal imaging.
     * @param lensType lens type enum
     * @return range step int value object
     */
    fun getThermalIrImageEnhance(
        lensType: LensTypeEnum
    ): RangeStepIntValue?

    /**
     * Returns the noise reduction settings for thermal imaging.
     * @param lensType lens type enum
     * @return list of integer
     */
    fun getThermalIrNr(
        lensType: LensTypeEnum
    ): MutableList<Int>

    /**
     * Returns the gain settings for thermal imaging to reduce noise.
     * @param lensType lens type enum
     * @return Ir gain object
     */
    fun getIrGain(
        lensType: LensTypeEnum
    ): IrGain?

    /**
     * Returns the isotherm modes for thermal imaging.
     * @param lensType lens type enum
     * @return list of integer
     */
    fun getIrIsoThermMode(
        lensType: LensTypeEnum
    ): List<Int>

    /**
     *Returns the temperature alarm settings for thermal imaging.
     * @param lensType lens type enum
     * @return IR hot cold value
     */
    fun getIrTempAlarm(
        lensType: LensTypeEnum
    ): IRHotColdValue?

    /**
     * Checks if the infrared temperature span feature is supported.
     * @param lensType lens type enum
     * @return support temp. span weather or not
     */
    fun isIrTempSpanEnable(
        lensType: LensTypeEnum
    ): Boolean

    /**
     * Returns the range for the infrared temperature span feature.
     * @param lensType lens type enum
     *  @return IR temp high low range value
     */
    fun getIrTempSpanRange(
        lensType: LensTypeEnum
    ): IRTempSpanValue?

    /**
     * Returns the emission settings for thermal imaging to reduce noise.
     * @param lensType lens type enum
     * @return range step int value object
     */
    fun getIrNrEmit(
        lensType: LensTypeEnum
    ): RangeStepIntValue?

    /**
     * Returns the supported video file compression standards for the current camera.
     * @param lensType lens type enum
     * @return video compress standard enum
     */
    fun getVideoFileCompressionStandard(
        lensType: LensTypeEnum
    ): List<VideoCompressStandardEnum>

    /**
     * Returns the supported storage types for the current camera.
     * @param lensType lens type enum
     * @return storage type enums list
     */
    fun getStorageType(
        lensType: LensTypeEnum
    ): List<StorageTypeEnum>

    /**
     * Returns the player port ID for the current type of camera.
     * @return The player port ID as an integer.
     */
    fun getPlayerID(
        lensType: LensTypeEnum
    ): Int

    /**
     *  Checks if the camera supports AI services.
     *  @param lensType The lens type enum.
     *  @return True if AI services are supported, false otherwise.
     */
    fun getAiServiceEnabled(
        lensType: LensTypeEnum
    ): Boolean

    /**
     *  @param lensType lens type enum
     *  @return The list of switchable Ircut ranges.
     */
    fun getIrcutSwitchRange(
        lensType: LensTypeEnum
    ): List<IrcutSwitchEnum>?

    /**
     * Checks if the current gimbal supports thermal fusion.
     * @return Whether thermal fusion is supported.
     */
    fun isSupportFusion(): Boolean

    /**
     * getting version of camera
     */
    fun getVersion(): String

    /**
     * Returns the horizontal field of view of the camera.
     * @param lensType The lens type enum.
     * @return The horizontal field of view as a float.
     */
    fun getHFov(lensType: LensTypeEnum):Float?
    /**
     * Returns the vertical field of view of the camera.
     * @param lensType The lens type enum.
     * @return The vertical field of view as a float.
     */
    fun getVFov(lensType: LensTypeEnum):Float?

     /**
     * Returns the focal length of the camera lens.
     * @param lensType The lens type enum.
     * @return The focal length as a float.
     */
    fun getFocalLength(lensType: LensTypeEnum):Float?

     /**
     * Checks if the camera supports AFAE lock.
     * @param lensType The lens type enum.
     * @return True if AFAE lock is supported, false otherwise.
     */
    fun isAFAELockSupport(lensType: LensTypeEnum): Boolean
  
     /**
     * Camera Photo Capture Time
     */
    fun getTakePhotoCostTime(): Int

    /**
     * Returns whether the current lens supports professional parameter configuration
     */
    fun isPROSettingsSupport(lensType: LensTypeEnum): Boolean

    /**
     * Laser Light Mode
     */
    fun getLaserLightMode():LaserLightModeEnum
    /**
     * Checks whether the lens supports the heating and de-fogging feature.
     */
    fun isLensDehazeSupport(lensType: LensTypeEnum?): Boolean

    /**
     * Gets the maximum duration (in seconds) for lens heating and de-fogging.
     */
    fun getLensDehazeMaxTime(lensType: LensTypeEnum?): Int
}

3.6 Aircraft Status Information Cache

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

The UAV state information cache maintains critical aircraft data that is continuously refreshed and stored in the DroneStateData structure.

data class DroneStateData(
    /** Camera */
    var gimbalDataMap: MutableMap<GimbalTypeEnum, GimbalData> = mutableMapOf(),
    /** Flight control state*/
    var flightControlData: FlightControlData = FlightControlData(),
    /**  Flight control get、set cache*/
    var flightoperateData: FlightOperateData = FlightOperateData(),
    /** missionManager cache data*/
    var missionManagerData: MissionManagerData = MissionManagerData(),
    /**System initial param*/
    var systemInfoData: SystemInfoData = SystemInfoData(),

    /** SDCard*/
    var sdcardData: SDCardData = SDCardData(),
    /** MMC*/
    var emmcData: EmmcData = EmmcData(),
    /**
     * ADS-B
     * */
    var adsbReportStateMap: ConcurrentHashMap<String, AirSensePlaneState> = ConcurrentHashMap(),
    /**droneKeyInfoData 2HZ*/
    var droneKeyInfoData: DroneKeyInfoLFNtfyBean? = null,

    /**droneRuntimeReportBean*/
    var droneRuntimeReportBean: DroneRuntimeReportBean? = null,

    /**Droneinfo.（sn、version）*/
    var droneInfoData: DroneInfoData = DroneInfoData(),

    /**Dragon fish data cache*/
    var dragonFishData: DragonFishData = DragonFishData()
)