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 {
/**
* Drone connection status listener
*
* @param connected Indicates if the drone is connected
* @param drone The drone device
* @Description: Listener for the connection status of the drone device
*/
@Deprecated("See [onDroneChangedListener] for more parameters")
void onDroneChangedListener(boolean connected, IBaseDevice drone);
/**
* Notification of camera capability set change
*
* @param fetched true if the capability set file is updated, false if the drone is disconnected
*/
@Deprecated("See [onCameraAbilityFetchListener] for more parameters")
void onCameraAbilityFetchListener(boolean fetched);
/**
* Listener for the connection status of the drone device
*
* @param connected Indicates if the drone is connected - is connected
* @param drone The drone device - drone device
*/
void onDroneChangedListener(boolean connected, IAutelDroneDevice drone);
/**
* Notification of the camera capability set change
*
* @param localFetched true if the local capability set is successfully parsed
* @param remoteFetched true if the remote capability set is successfully parsed
* @param drone The drone device
*/
void onCameraAbilityFetchListener(boolean localFetched, boolean remoteFetched, IAutelDroneDevice drone);
}
3.3.1 Registering Listening
SDKManager.get().getDeviceManager().addDroneListener(this)
3.3.2 Obtaining The Aircraft Connection Status
val connectStatus = DeviceManager.getDeviceManager().isConnected()
3.4 Obtaining The Camera Capability Set
val cameraSupport =DeviceManager.getFirstDroneDevice()?.getCameraAbilitySetManger()?.getCameraSupport2()
The camera capability set is returned by the ICameraSupport API.
interface ICameraSupport2 {
companion object {
const val TAG = "ICameraSupport-"
}
/**
* Returns the list of currently supported valid video resolutions and frame rates.
* @param lensType The type of lens as an enum.
* @param flightMode The flight mode enum.
* @param modeEnum The recording mode enum.
* @return The list of video resolution frame data.
*/
fun getResolutionAndFrameRate(
lensType: LensTypeEnum,
flightMode: FlightModeEnum?,
modeEnum: RecordModeEnum?
): List<VideoResolutionFrameBean>
/**
* Returns the list of photo resolutions supported for HDR.
* @param lensType The lens type enum.
* @param flightMode The flight mode enum.
* @param photoFormat The photo output format enum.
* @param modeEnum The camera mode enum.
* @return The list of photo resolutions.
*/
fun getHDRSupportPhoto(
lensType: LensTypeEnum,
flightMode: FlightModeEnum,
photoFormat: PhotoFormatEnum,
modeEnum: CameraModeEnum
): List<PhotoResolutionEnum>
/**
* Returns the currently valid camera modes.
* @param lensType The type of lens as an enum.
* @param flightMode The flight mode enum, with a default of manual.
* @param modeEnum The photo capture mode enum, with a default of unknown.
* @return A list of camera modes.
*/
fun getCameraModeRange(
lensType: LensTypeEnum,
flightMode: FlightModeEnum, // Corrected from '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 The lens type enum.
* @return The range with min, max, and step values.
*/
fun getManualFocus(
lensType: LensTypeEnum
): RangeStepIntValue?
/**
* Returns the zoom range for the camera.
* @param lensType The type of lens as an enum.
* @param videoZoomType The type of video zoom as an enum.
* @return The range with minimum, maximum, and step values for zoom.
*/
fun getPhotoZoom(
lensType: LensTypeEnum,
videoZoomType: VideoZoomTypeEnum
): RangeStepValue?
/**
* Returns the size of the video zoom.
* @param lensType The type of lens as an enum.
* @param videoZoomType The type of video zoom, with a default as the Default enum.
* @return The range with minimum, maximum, and step values for the zoom level.
*/
fun getVideoZoom(
lensType: LensTypeEnum,
videoZoomType: VideoZoomTypeEnum
): RangeStepValue?
/**
* Returns the list of values for watermarks and timestamps.
* @param lensType The type of lens as an enum.
* @param photoFormat The format for photo output as an enum.
* @return An integer value for the timestamp.
*/
fun getWatermarkTimestamp(
lensType: LensTypeEnum,
photoFormat: PhotoFormatEnum
): Int
/**
* Returns the current valid camera exposure modes.
* @param lensType The type of lens as an enum.
* @return A list of exposure modes.
*/
fun getExposureModeRange(
lensType: LensTypeEnum
): ArrayList<ExposureModeEnum>
/**
* Returns the current valid range for exposure compensation.
* @param lensType The type of lens as an enum.
* @return A list containing the range of exposure compensation values.
*/
fun getExposureCompensationRange(
lensType: LensTypeEnum
): ArrayList<ExposureCompensationEnum> // Corrected the enum name if it was a typo
/**
* Returns the current valid camera ISO range.
* @param lensType The type of lens as an enum.
* @param isPhoto A boolean value indicating whether it's for photo mode.
* @param pattern The camera operation pattern enum, with a default of manual flight.
* @param modeEnum The photo capture mode enum, defaulting to unknown.
* @return A list of image ISO enums.
*/
fun getImageISOList(
lensType: LensTypeEnum,
isPhoto: Boolean,
pattern: Int = PatternModeEnum.MANUAL.value, // Assumes there's an enum with MANUAL as a constant
modeEnum: TakePhotoModeEnum
): ArrayList<ImageISOEnum>
/**
* Returns the list of ISO modes valid for the camera in photo mode.
* @param lensType The type of lens as an enum.
* @return The list of ISO modes for photo.
*/
fun getPhotoISOModeRange(
lensType: LensTypeEnum
): List<ISOModeEnum>
/**
* Returns the list of ISO modes valid for the camera in video mode.
* @param lensType The type of lens as an enum.
* @return The list of ISO modes for video.
*/
fun getVideoISOModeRange(
lensType: LensTypeEnum
): List<ISOModeEnum>
/**
* Returns the range of shutter speeds currently available for the camera.
* @param lensType The type of lens as an enum.
* @param isPhoto A boolean indicating if it's for photo mode.
* @param fps The frame per second value for video mode.
* @param modeEnum The photo mode enum, defaulting to unknown.
* @return A list of shutter speeds.
*/
fun getShutterList(
lensType: LensTypeEnum,
isPhoto: Boolean,
fps: Int,
modeEnum: TakePhotoModeEnum
): ArrayList<ShutterSpeedEnum> // Assumes ShutterSpeedData is a typo and corrects to ShutterSpeedEnum
/**
* Returns the range of apertures that can be set on the current camera.
* @param lensType The type of lens as an enum.
* @return A list of available apertures.
*/
fun getApertureRange(
lensType: LensTypeEnum
): List<Double>
/**
* Returns the range of video formats currently selectable for the camera.
* @param lensType The type of lens as an enum.
* @return A list of video format enums.
*/
fun getVideoFileFormatRange(
lensType: LensTypeEnum
): List<VideoFormatEnum>
/**
* Returns the range of intervals at which photos can be taken during video recording.
* @param lensType The type of lens as an enum.
* @return A list of video PIV (Picture in Video) enums.
*/
fun getPicInVideoIntervalRange(
lensType: LensTypeEnum
): List<VideoPivEnum>
/**
* Returns the range of video standards currently selectable for the camera.
* @param lensType The type of lens as an enum.
* @return A list of video standard enums.
*/
fun getVideoStandardRange(
lensType: LensTypeEnum
): List<VideoStandardEnum>
/**
* Returns the range of photo file formats currently selectable for the camera.
* @param lensType The type of lens as an enum.
* @param modeEnum The state of the photo capture mode.
* @param photoResolution The resolution of the photo.
* @return A list of photo format enums.
*/
fun getPhotoFileFormatRange(
lensType: LensTypeEnum,
modeEnum: TakePhotoModeEnum,
photoResolution: PhotoResolutionEnum
): List<PhotoFormatEnum>
/**
* Returns the range of burst shot counts currently selectable for the camera.
* @param lensType The type of lens as an enum.
* @return A list of integers representing the count range.
*/
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.
* @return A list of integers representing the AEB capture count range.
*/
fun getPhotoAEBCaptureCountRange(
lensType: LensTypeEnum
): List<Int>
/**
* Returns the range of time intervals currently selectable for timed photography.
* @param lensType The type of lens as an enum.
* @return A list of integers representing the range of intervals.
*/
fun getPhotoIntervalParamRange(
lensType: LensTypeEnum
): List<Int>
/**
* Returns the list of current camera white balance options.
* @param lensType The lens type enum.
* @return The list of white balance options.
*/
fun getWhiteBalanceList(
lensType: LensTypeEnum
): ArrayList<WhiteBalanceEnum>
/**
* Returns the range of custom color temperature values for white balance.
* @param lensType The lens type enum.
* @return The range step integer value.
*/
fun getCustomColorTemperatureRange(
lensType: LensTypeEnum
): RangeStepIntValue?
/**
* Returns the range of defog modes available for the current camera.
* @param lensType The type of lens as an enum.
* @return A list of defog mode enums.
*/
fun getDehazeModeRange(
lensType: LensTypeEnum
): List<DefogModeEnum>
/**
* Returns the range of selectable defog settings for the current camera.
* @param lensType The type of lens as an enum.
* @return A list of defog settings enums.
*/
fun getDehazeSettingSwitchRange(
lensType: LensTypeEnum
): List<DefogEnum>
/**
* Returns the merged range of selectable defog settings for the current camera.
* @param lensType The type of lens as an enum.
* @return A list of defog settings enums.
*/
fun getDehazeSettingSwitchMergeRange(
lensType: LensTypeEnum
): List<DefogEnum>
/**
* Returns the range of selectable anti-flicker modes for the current camera.
* @param lensType The type of lens as an enum.
* @return A list of anti-flicker modes.
*/
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 The type of lens as an enum.
* @return A list of video transmission mode enums.
*/
fun getTransferMode(
lensType: LensTypeEnum
): List<VideoTransMissionModeEnum>
/**
* Returns the range of selectable image resolutions for the current camera.
* @param lensType The type of lens as an enum.
* @param flightMode The flight mode enum.
* @param modeEnum The photo mode enum, defaulting to unknown.
* @return A list of photo resolution enums.
*/
fun getPhotoResolution(
lensType: LensTypeEnum,
flightMode: FlightModeEnum, // Assuming 'FightModeEnum' was a typo and correcting to 'FlightModeEnum'
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 The type of lens as an enum.
* @param flightMode The flight mode enum.
* @param modeEnum The photo mode enum, defaulting to unknown.
* @return A list of photo resolutions.
*/
fun getPhotoResolutionTwice(
lensType: LensTypeEnum,
flightMode: FlightModeEnum, // Assuming 'FightModeEnum' was a typo and correcting to 'FlightModeEnum'
modeEnum: TakePhotoModeEnum
): List<PhotoResolution>
/**
* Returns the range of selectable sharpness levels for the current camera.
* @param lensType The type of lens as an enum.
* @param modeEnum The photo mode enum, defaulting to unknown.
* @return A list of integer values representing sharpness levels.
*/
fun getSharpnessRange(
lensType: LensTypeEnum,
modeEnum: TakePhotoModeEnum
): List<Int>
/**
* Returns the range of selectable contrast levels for the current camera.
* @param lensType The type of lens as an enum.
* @param modeEnum The photo mode enum, defaulting to unknown.
* @return A list of integer values representing contrast levels.
*/
fun getContrastRange(
lensType: LensTypeEnum,
modeEnum: TakePhotoModeEnum
): List<Int>
/**
* Returns the range of selectable saturation levels for the current camera.
* @param lensType The type of lens as an enum.
* @param modeEnum The photo mode enum, defaulting to unknown.
* @return A list of integer values representing saturation levels.
*/
fun getSaturationRange(
lensType: LensTypeEnum,
modeEnum: TakePhotoModeEnum
): List<Int>
/**
* Returns the range of selectable focus modes for the current camera.
* @param lensType The type of lens as an enum.
* @param modeEnum The photo mode enum, defaulting to unknown.
* @return A list of integer values representing focus modes.
*/
fun getLensFocusModeRange(
lensType: LensTypeEnum,
modeEnum: CameraModeEnum
): List<Int>
/**
* Returns the list of thermal color modes supported by the current camera.
* @param lensType The type of lens as an enum.
* @return A list of thermal color enums.
*/
fun supportedIrColor(
lensType: LensTypeEnum
): List<ThermalColorEnum>
/**
* Returns the temperature measurement modes for thermal imaging.
* @param lensType The type of lens as an enum.
* @return A list of IR temperature mode enums.
*/
fun getThermalIRTempMode(
lensType: LensTypeEnum
): List<IRTempModeEnum>
/**
* Returns the image modes for thermal imaging.
* @param lensType The type of lens as an enum.
* @return An object representing the IR image mode.
*/
fun getThermalIrImageMode(
lensType: LensTypeEnum
): IrImageMode?
/**
* Returns the enhancement settings for thermal imaging.
* @param lensType The type of lens as an enum.
* @return An object representing the range step integer value for enhancement.
*/
fun getThermalIrImageEnhance(
lensType: LensTypeEnum
): RangeStepIntValue?
/**
* Returns the noise reduction settings for thermal imaging.
* @param lensType The type of lens as an enum.
* @return A mutable list of integers representing the noise reduction levels.
*/
fun getThermalIrNr(
lensType: LensTypeEnum
): MutableList<Int>
/**
* Returns the gain settings for thermal imaging to reduce noise.
* @param lensType The type of lens as an enum.
* @return An IrGain object representing the noise reduction gain settings.
*/
fun getIrGain(
lensType: LensTypeEnum
): IrGain?
/**
* Returns the isotherm modes for thermal imaging.
* @param lensType The type of lens as an enum.
* @return A list of integers representing the isotherm modes.
*/
fun getIrIsoThermMode(
lensType: LensTypeEnum
): List<Int>
/**
* Returns the temperature alarm settings for thermal imaging.
* @param lensType The type of lens as an enum.
* @return An IRHotColdValue object representing the temperature alarm thresholds.
*/
fun getIrTempAlarm(
lensType: LensTypeEnum
): IRHotColdValue?
/**
* Checks if the infrared temperature span feature is supported.
* @param lensType The type of lens as an enum.
* @return A boolean value indicating whether the temperature span feature is supported.
*/
fun isIrTempSpanEnable(
lensType: LensTypeEnum
): Boolean
/**
* Returns the range for the infrared temperature span feature.
* @param lensType The type of lens as an enum.
* @return An IRTempSpanValue object representing the high and low range values for the temperature span.
*/
fun getIrTempSpanRange(
lensType: LensTypeEnum
): IRTempSpanValue?
/**
* Returns the emission settings for thermal imaging to reduce noise.
* @param lensType The type of lens as an enum.
* @return An object representing the range step integer value for emission.
*/
fun getIrNrEmit(
lensType: LensTypeEnum
): RangeStepIntValue?
/**
* Returns the supported video file compression standards for the current camera.
* @param lensType The type of lens as an enum.
* @return A list of video compression standard enums.
*/
fun getVideoFileCompressionStandard(
lensType: LensTypeEnum
): List<VideoCompressStandardEnum>
/**
* Returns the supported storage types for the current camera.
* @param lensType The type of lens as an enum.
* @return A list of storage type enums.
*/
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(): 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 The type of lens as an 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
/**
* Retrieves the version of the camera.
* @return The version of the camera as a String.
*/
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
}
3.5 Aircraft Status Caching
val status = DeviceManager.getDeviceManager().getFirstDroneDevice()?.getDeviceStateData()
Information aircraft status information will be updated constantly, and mainly stored in DroneStateMachineBean.
data class DroneStateData(
var gimbalDataMap: MutableMap<GimbalTypeEnum, GimbalData> = mutableMapOf(),
/** Gimbal control status */
var flightControlData: FlightControlData = FlightControlData(),
/** Flight control operation get and set cache data */
var flightOperateData: FlightOperateData = FlightOperateData(),
/** RTK (Real-Time Kinematic) cache data */
var rtkControlData: RTKControlData = RTKControlData(),
/** Mission manager cache data */
var missionManagerData: MissionManagerData = MissionManagerData(),
/** Warning message cache */
var droneWarningData: DroneWarningData = DroneWarningData(),
/** Visual obstacle information cache */
var visionObsacleData: VisionObstacleData = VisionObstacleData(),
/** System initialization parameters */
var systemInfoData: SystemInfoData = SystemInfoData(),
/** Thrower (projector) status */
var accessoriesData: AccessoriesData = AccessoriesData(),
var throwMessageData: ThrowerMessageBean? = null,
/** RTK reporting data */
var rtkReportData: RtkReportBean? = null,
/** SD card cache */
var sdcardData: SDCardData = SDCardData(),
/** eMMC (Embedded Multi-Media Controller) card cache */
var emmcData: EmmcData = EmmcData(),
/**
* ADS-B (Automatic Dependent Surveillance-Broadcast) reporting data, only receives version information
* */
var adsbReportStateMap: ConcurrentHashMap<String, AirSensePlaneState> = ConcurrentHashMap(),
/** Key flight controller parameter reporting at a frequency of 2Hz */
var droneKeyInfoData: DroneKeyInfoLFNtfyBean? = null,
/** Aircraft flight information reporting (duration, count, etc.) */
var droneRuntimeReportBean: DroneRuntimeReportBean? = null,
/** Aircraft related information (sn, version, etc.) */
var droneInfoData: DroneInfoData = DroneInfoData(),
/** Dragon Fish related parameter cache */
var dragonFishData: DragonFishData = DragonFishData()
)
3.6 AutelKeyInfo & AutelActionKeyInfo
3.6.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.6.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).canRetry(true)
3.7 Keys Of All Aircraft Modules
3.7.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)
/**
* Definition of file handling messages; file upload
*/
val KeyFileUpload: AutelActionKeyInfo<FileUploadBean,Void > = AutelActionKeyInfo(
component.value,
MessageTypeConstant.FILE_UPLOAD_MSG,
FileUploadBeanConvert(),
AutelEmptyConvert()
).canPerformAction(true)
}
3.7.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.7.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.7.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.7.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.7.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.7.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.7.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.7.9 Airlink Transmission
object AirLinkKey {
private val component = ComponentType.ALINK
/**
* Video transmission band read and write.
*/
val KeyALinkBandMode: AutelKeyInfo<AirLinkBandModeEnum> = AutelKeyInfo(
component.value,
ALinkConstant.AirLinkBandMode,
AirLinkBandModeConvert()
).canGet(true).canSet(true).canRetry(true)
/**
* Video transmission clarity mode.
*/
val KeyALinkTransmissionMode: AutelKeyInfo<VideoTransMissionModeEnum> =
AutelKeyInfo(
component.value,
ALinkConstant.AirLinkTransmissionMode,
AirLinkTransmissionModeConvert()
).canGet(true).canSet(true)
/**
* Radiation power mode.
*/
val KeyALinkFccCeMode: AutelKeyInfo<FccCeModeEnum> =
AutelKeyInfo(
component.value,
ALinkConstant.AIRLINK_FCC_CE_MODE_MSG,
AirLinkFccCeModeConvert()
).canGet(true).canSet(true)
/**
* Start frequency matching.
*/
val KeyALinkStartMatching: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
ComponentType.REMOTE_CONTROLLER.value,
ALinkConstant.AirLinkStartMatching,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Frequency matching progress report event.
*/
val KeyALinkMatchingStatus: AutelKeyInfo<AirLinkMatchStatusEnum> =
AutelKeyInfo(
ComponentType.REMOTE_CONTROLLER.value,
ALinkConstant.AirLinkMatchingStatus,
AirLinkMatchingStatusConvert()
).canListen(true)
/**
* Video transmission signal strength report. For debugging tools.
*/
val KeyALinkSignalStrength: AutelKeyInfo<AirLinkSignalStrengthBean> =
AutelKeyInfo(
ComponentType.REMOTE_CONTROLLER.value,
ALinkConstant.AIRLINK_SIGNAL_STRENGTH_NTFY,
AirLinkSignalStrengthConvert()
).canListen(true)
/**
* Reset frequency matching flag.
*/
val KeyAirlinkResetMatchFlag: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AirlinkResetMatchFlag,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* User single-click battery confirmation connection notification.
*/
val KeyALinkConnectConfirm: AutelKeyInfo<Void> =
AutelKeyInfo(
component.value,
ALinkConstant.ALRLINK_CONNECT_CONFIRM_NTFY,
AutelEmptyConvert()
).canListen(true)
/**
* Switch to high-speed mode.
* Interface:
* 0 - Normal mode, 1 - High-speed file upload (upload task files), 2 - High-speed download mode (download photos or videos), 3 - Exclusive mode (upgrade).
*/
val KeyAirlinkControlHighSpeed: AutelActionKeyInfo<HighSpeedEnum, Void> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AIRLINK_CONTROL_HIGH_SPEED_MSG,
AirLinkHighSpeedConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Get high-speed mode interface.
*/
val KeyAirlinkGetHighSpeed: AutelActionKeyInfo<Void, HighSpeedEnum> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AIRLINK_GET_HIGH_SPEED_MSG,
AutelEmptyConvert(),
AirLinkHighSpeedConvert()
).canPerformAction(true)
/**
* Enter video transmission silent mode.
*/
val KeyAirlinkEnterSilenceMode: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AIRLINK_ENTER_SILENCE_MODE_MSG,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* App video transmission display mode.
*/
val KeyAirlinkAppSplitScreenInfo: AutelActionKeyInfo<List<GimbalTransmissionBean>, Void> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AIRLINK_APP_SPLIT_SCREEN_INFO_MSG,
SplitScreenInfoConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* 4G streamer maximum bitrate.
*/
val KeyAirlinkLteStreamerMaxBtrate: AutelKeyInfo<Int> =
AutelKeyInfo(
component.value,
ALinkConstant.AIRLINK_LTE_STREAMER_MAX_BTRATE,
AutelIntConvert()
).canGet(true).canSet(true)
/**
* Video transmission visible light maximum bitrate.
*/
val KeyAirlinkAtMaxBtrateVisible: AutelKeyInfo<Int> =
AutelKeyInfo(
component.value,
ALinkConstant.AIRLINK_AT_MAX_BITRATE_VISIBLE,
AutelIntConvert()
).canGet(true).canSet(true).canRetry(true)
/**
* Main remote controller sends a forced desynchronization message to the aircraft.
*/
val KeyAirlinkTriggerCpOff: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AIRLINK_TRIGGER_CP_OFF_ON_MSG,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Set the video transmission frequency list. In certain SS scenarios, users require that certain frequencies be forcibly enabled or disabled.
* operation: 0 - Enable frequency, 1 - Disable frequency
* frequencyList: List<FrequencyInfoBean> - Frequency list
*/
val KeyAirLinkFrequencySet: AutelActionKeyInfo<FrequencySetBean, Void> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AIRLINK_FREQUENCY_SET_MSG,
FrequencySetConverter(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Get the video transmission frequency list. Gets the frequency list settings from the aircraft for display in the app.
* disableFrequencyList: List<FrequencyInfoBean> - User-specified disabled frequency list
* enableFrequencyList: List<FrequencyInfoBean> - User-specified enabled frequency list
*/
val KeyAirFrequencyGet: AutelActionKeyInfo<Void, FrequencyGetBean> =
AutelActionKeyInfo(
component.value,
ALinkConstant.AIRLINK_FREQUENCY_GET_MSG,
AutelEmptyConvert(),
FrequencyGetConverter()
).canPerformAction(true)
/**
* Video transmission switch.
* false - Video transmission enabled
* true - Video transmission disabled
*/
val KeyAirLinkVideoScreenClose: AutelKeyInfo<Boolean> =
AutelKeyInfo(
component.value,
ALinkConstant.AIRLINK_VIDEO_SCREEN_CLOSE_MSG,
AutelIntToBoolConverter()
).canGet(true).canSet(true)
/**
* Video transmission wireless radio signal transmission power.
*/
val KeyAirLinkPowerCtrl: AutelKeyInfo<Int> =
AutelKeyInfo(
component.value,
ALinkConstant.AIRLINK_POWER_CTRL,
AutelIntConvert()
).canGet(true).canSet(true)
}
3.7.10 Task Recording Module
object AccurateRetakeKey {
val component = ComponentType.MISSION
/**
* Begins map editing for accurate retake.
*/
val KeyBeginMapEditMsg: AutelActionKeyInfo<MissionWaypointGUIDBean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeBeginMapEditMsg,
WaypointReTakeGUIDConverter(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Exits map editing for accurate retake.
*/
val KeyEndMapEditMsg: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeEndMapEditMsg,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Deletes a map for accurate retake.
*/
val KeyDeleteMapMsg: AutelActionKeyInfo<MissionWaypointGUIDBean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeDeleteMapMsg,
WaypointReTakeGUIDConverter(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Adds the current position to the map for accurate retake.
*/
val KeyAddPoiMsg: AutelActionKeyInfo<Void, AccurateRetakePOIResponseBean> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeAddPoiMsg,
AutelEmptyConvert(),
AutelAccurateRetakePOIResponseConvert()
).canPerformAction(true)
/**
* Deletes a point from the map for accurate retake.
*/
val KeyDelPoiMsg: AutelActionKeyInfo<AccurateRetakePOIBean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeDelPoiMsg,
AutelAccurateRetakePOIConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Retrieves map information for accurate retake.
*/
val KeyGetMapInfoMsg: AutelActionKeyInfo<Void, AccurateRetakeMapListBean> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeGetMapInfoMsg,
AutelEmptyConvert(),
AutelAccurateRetakeMapListConvert()
).canPerformAction(true)
/**
* Adjusts the order number of a point in the map for accurate retake.
*/
val KeySetPoiNoMsg: AutelActionKeyInfo<AccurateRetakeSetPoiNoBean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeSetPoiNoMsg,
AutelAccurateRetakeSetPoiNoConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Updates point information in the map for accurate retake.
*/
val KeyEditPosMsg: AutelActionKeyInfo<AccurateRetakePOIBean, AccurateRetakePOIResponseBean> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeEditPosMsg,
AutelAccurateRetakePOIConvert(),
AutelAccurateRetakePOIResponseConvert()
).canPerformAction(true)
/**
* Begins flight for accurate retake.
*/
val KeyBeginFlyMsg: AutelActionKeyInfo<MissionWaypointGUIDBean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeBeginFlyMsg,
WaypointReTakeGUIDConverter(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Ends flight for accurate retake.
*/
val KeyEndFlyMsg: AutelActionKeyInfo<MissionWaypointGUIDBean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeEndFlyMsg,
WaypointReTakeGUIDConverter(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Pauses flight during accurate retake.
*/
val KeyPauseFlyMsg: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakePauseFlyMsg,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Resumes flight during accurate retake.
*/
val KeyResumeFlyMsg: AutelActionKeyInfo<MissionWaypointGUIDBean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeResumeFlyMsg,
WaypointReTakeGUIDConverter(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Queries the flight breakpoint for accurate retake.
*/
val KeyQueryFlyBkMsg: AutelActionKeyInfo<MissionWaypointGUIDBean, AccurateRetakeBreakIDBean> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.AccurateRetakeQueryFlyBkMsg,
WaypointReTakeGUIDConverter(),
AutelAccurateRetakeBreakIDConvert()
).canPerformAction(true)
//====================================New Interfaces Supporting Slam Accurate Retake===================================
/**
* Enters accurate retake mode for key frame capture.
* Enter this mode when starting video recording or waypoint collection.
*/
val KeyEnterKeyFrameMode: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.MODULE_KEY_FRAME_MODE_ENTER,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Exits accurate retake mode for key frame capture.
* Exit this mode when stopping video recording or waypoint collection.
*/
val KeyExitKeyFrameMode: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.MODULE_KEY_FRAME_MODE_EXIT,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Starts task recording for accurate retake.
* Requires passing a Map ID.
*/
val KeyStartTaskRecord: AutelActionKeyInfo<String, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.MODULE_KEY_FRAME_START_RECORD,
AutelStringConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Stops task recording and saves the Slam map for accurate retake.
* 0: Do not save the Slam map. 1: Save the Slam map.
*/
val KeyFinishTaskRecord: AutelActionKeyInfo<Boolean, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.MODULE_KEY_FRAME_FINISH_RECORD,
AutelBooleanConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Enters user mode for collecting 3D reconstruction video for accurate retake.
*/
val KeyStartVideoMapCollect: AutelActionKeyInfo<String, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.MODULE_KEY_FRAME_START_MAP_COLLECT,
AutelStringConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Ends the 3D reconstruction video collection for accurate retake.
*/
val KeyFinishVideoMapCollect: AutelActionKeyInfo<Void, Void> =
AutelActionKeyInfo(
component.value,
MessageTypeConstant.MODULE_KEY_FRAME_STOP_MAP_COLLECT,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Monitor notifications for accurate retake.
*/
val KeyUAVKeyFrameInfoNtfy: AutelKeyInfo<UAVKeyFrameInfoBean> = AutelKeyInfo(
component.value,
MessageTypeConstant.UAV_KEY_FRAME_INFO,
UAVKeyFrameInfoConverter()
).canListen(true)
/**
* Notifications for the progress of saving and loading the accurate map.
*/
val KeyUAVKeyMapProgressNtfy: AutelKeyInfo<UAVKeyMapProgressBean> = AutelKeyInfo(
component.value,
MessageTypeConstant.ACCURATE_SL_MIF_MAP_PROGRESS_NTFY,
UAVKeyMapProgressConverter()
).canListen(true)
/**
* Message to stop saving the recorded map for accurate retake.
*/
val KeyUAVStopSaveMap: AutelActionKeyInfo<Void, Void> = AutelActionKeyInfo(
component.value,
MessageTypeConstant.ACCURATE_STOP_SAVE_MAP_MSG,
AutelEmptyConvert(),
AutelEmptyConvert()
).canPerformAction(true)
/**
* Query the size of the recorded map for accurate retake, in MB.
*/
val KeyUAVQueryMapSize: AutelActionKeyInfo<Void, Int> = AutelActionKeyInfo(
component.value,
MessageTypeConstant.ACCURATE_QUERY_MAP_SIZE_MSG, // Corrected message type
AutelEmptyConvert(),
AutelIntConvert()
).canPerformAction(true)
}
3.8 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.9 Precautions
Calling performAction, setValue, and getValue requires the corresponding module key. For example, you can call getValue only when canGet(true) is available.