imobile_for_reactnative/NativeModule/interfaces/ar/SARMap.ts

iMobile for ReactNative，是SuperMap iMobile推出的一款基于React-Native框架的移动应用开发工具。基于该开发工具，用户可以使用JavaScript开发语言，开发出在Android和IOS操作系统下运行的原生移动GIS应用，入门门槛低，一次开发，处处运行。

import EventConst from "imobile_for_reactnative/NativeModule/constains/EventConst"
import { EmitterSubscription, Platform } from "react-native"
import {
  NativeModules,
  NativeEventEmitter,
} from "react-native"
import { DatasetInfo, LongitudeAndLatitude, Point2D, Point3D, Vector3 } from "../data/SData"
// eslint-disable-next-line @typescript-eslint/no-unused-vars
import { PrjCoordSys } from '../data/SData'
import { FieldValue3D, TLayer3DType } from "../scene/SScene"

const SARMap = NativeModules.SARMap

const event = new NativeEventEmitter(SARMap)


/** AR图层类型 */
export interface IARLayerType {
  /** 当图层找不到对应数据集时类型为 -1 */
  UNKNOWN: -1
  /** 特效图层 */
  EFFECT_LAYER: 2
  /** 三维图层 */
  AR3D_LAYER: 3
  /** 三维场景图层 */
  AR_SCENE_LAYER: 4
  /** AR 点图层 */
  AR_POINT_LAYER: 100
  /** AR 文本图层 */
  AR_TEXT_LAYER: 101
  /** AR POI 图层 （图片，视频及网页） */
  AR_MEDIA_LAYER: 105
  /** AR 模型，沙盘图层 */
  AR_MODEL_LAYER: 106
  /** AR 小组件图层 */
  AR_WIDGET_LAYER: 107
  /** AR 线图层 */
  AR_LINE_LAYER: 301
  /** AR 面图层 */
  AR_REGION_LAYER: 302
  /** AR 符号线图层 */
  AR_MARKER_LINE_LAYER: 401
}
/** AR对象类型 */
export interface IARElementType {
  /** AR视频 */
  AR_VIDEO: 1
  /** AR图片 */
  AR_IMAGE: 2
  /** AR网页 */
  AR_WEBVIEW: 3
  /** AR文本 */
  AR_TEXT: 4
  /** AR相册 */
  AR_ALBUM: 5
  /** AR气泡文字 */
  AR_BUBBLE_TEXT: 6
  /** AR属性 */
  AR_ATTRIBUTE_ALBUM: 7
  /** AR地图册 */
  AR_BROCHOR: 8
  /** AR视频册 */
  AR_VIDEO_ALBUM: 9
  /** AR沙盘册 */
  AR_SAND_TABLE_ALBUM:10
  /** AR点*/
  AR_POINT: 101
  /** AR线 */
  AR_LINE: 102
  /** AR面 */
  AR_REGION: 103
  /** AR模型 */
  AR_MODEL: 201
  /** AR沙盘 */
  AR_SAND_TABLE: 202
  /** 柱状图的element类型 */
  AR_BAR_CHART: 203
  /** 饼图的element类型 */
  AR_PIE_CHART: 204
  AR_ELEMENT_GROUP: 301
  /** 线符号的element类型 */
  AR_MARKER_LINE: 302
}
/** ARAction操作类型 */
export interface IARAction {
  /** 空操作，可以点击对象 */
  NULL: 0
  /** 选择对象，若对象所在图层可编辑，将选择的对象设为编辑对象 */
  SELECT: 1
  /** 选择对象内的某个子节点，若对象可编辑，将子节点设备编辑对象 */
  SELECT_NODE: 2
  /** 移动手势 */
  MOVE: 101
  /** 旋转手势 */
  ROTATE: 102
  /** 缩放手势 */
  SCALE: 103
  /** AR测量，AR测图，AR轨迹需要设置为此模式 */
  MEASURE: 200
  /** 聚焦，可通过{@link getFocusPosition}获取焦点位置 */
  FOCUS: 400
  /** 矢量线添加的Action */
  LINE_CREATE_FOUCUS: 601
  /** 创建线操作 */
  LINE_CREATE: 602
  /** 矢量线和符号线的编辑Action */
  VERTEX_ADD_FOUCUS: 701
  /** 添加点 */
  VERTEX_ADD: 702
  /** 焦点定位添加虚线（虚线+线段长度） */
  LineDot_CREATE_FOUCUS: 611
  /** 户型采集RoomPlan  需要编译环境 Xcode 14+  需要运行环境 iOS 16+ */
  ARACTION_ROOMPLAN: 1000
}
/** 气泡文字排列位置类型 */
export interface IARTextAlign {
  LEFT: 1
  TOP: 2
  RIGHT: 3
  BOTTOM: 4
  LEFT_START: 5
  LEFT_END: 6
  TOP_START: 7
  TOP_END: 8
  RIGHT_START: 9
  RIGHT_END: 10
  BOTTOM_START: 11
  BOTTOM_END:12
}
/** AR窗格动画分类类型 */
export interface IARAnimatorCategory {
  /** 消失类型动画 */
  DISAPPEAR: 0
  /** 出现类型动画 */
  APPEAR: 1
  /** 其他动画 */
  CUSTOM: 2
}
/** AR窗格动画类型 */
export interface IARAnimatorType {
  /** 节点类型，可设置节点位移，旋转，缩放属性的动画 */
  NODE_TYPE: 0
  /** 模型自带动画类型，适用与带有动画的glb模型的动画 */
  MODEL_TYPE: 1
  /** 动画组，可包括节点类型，模型类型，甚至另外一个动画组类型的动画作为其子动画 */
  GROUP_TYPE: 2
}
/** 节点类型动画的类型 */
export interface IARNodeAnimatorType {
  /** 位移类型动画 */
  TRANSLATION: 0
  /** 旋转类型动画 */
  ROTATION: 1
  /** 缩放类型动画 */
  SCALE: 2
}
/** AR窗格动画播放顺序类型 */
export interface IARAnimatorPlayOrder {
  /** 在前一个动画播放完后播放 */
  AFTER_PREVIOUS: 0
  /** 和前一个动画同时播放 */
  WITH_PREVIOUS: 1
  /** 点击屏幕后播放 */
  ON_TOUCH: 2
}

/** AR实景标注的类型 */
export interface IARTrackingMarkerType {
  /** 图片类型的AR实景标注 */
  IMAGE: 'image',
  /** 模型类型的AR实景标注 */
  MODEL:'model',
}

/** AR实景标注类型 */
export type TARTrackingMarkerType = IARTrackingMarkerType[keyof IARTrackingMarkerType]

/** AR实景标注类型常量 */
export const ARTrackingMarkerType: IARTrackingMarkerType = {
  IMAGE: 'image',
  MODEL:'model',
}


/** AR图层类型 */
export type TARLayerType = IARLayerType[keyof IARLayerType]

/** AR对象类型 */
export type TARElementType = IARElementType[keyof IARElementType]

/** ARAction操作类型 */
export type TARAction = IARAction[keyof IARAction]

/** AR气泡文字锚点类型 */
export type TARTextAlign = IARTextAlign[keyof IARTextAlign]

/** AR窗格动画分类 */
export type TARAnimatorCategory = IARAnimatorCategory[keyof IARAnimatorCategory]

/** AR窗格动画类型 */
export type TARAnimatorType = IARAnimatorType[keyof IARAnimatorType]

/** AR节点分类的动画类型 */
export type TARNodeAnimatorType = IARNodeAnimatorType[keyof IARNodeAnimatorType]

/** AR窗格动画播放顺序类型 */
export type TARAnimatorPlayOrder = IARAnimatorPlayOrder[keyof IARAnimatorPlayOrder]



// ********************* 各个类性具体对象

/** AR图层类型 */
export const ARLayerType: IARLayerType = {
  UNKNOWN: -1,
  EFFECT_LAYER: 2,
  AR3D_LAYER: 3,
  AR_SCENE_LAYER: 4,
  AR_POINT_LAYER: 100,
  AR_TEXT_LAYER: 101,
  AR_MEDIA_LAYER: 105,
  AR_MODEL_LAYER: 106,
  AR_WIDGET_LAYER: 107,
  AR_LINE_LAYER: 301,
  AR_REGION_LAYER: 302,
  AR_MARKER_LINE_LAYER: 401,
}
/** AR对象类型 */
export const ARElementType: IARElementType = {
  AR_VIDEO: 1,
  AR_IMAGE: 2,
  AR_WEBVIEW: 3,
  AR_TEXT: 4,
  AR_ALBUM: 5,
  AR_ATTRIBUTE_ALBUM: 7,
  AR_VIDEO_ALBUM: 9,
  AR_SAND_TABLE_ALBUM:10,
  AR_BROCHOR: 8,
  AR_BUBBLE_TEXT: 6,
  AR_POINT: 101,
  AR_LINE: 102,
  AR_REGION: 103,
  AR_MODEL: 201,
  AR_SAND_TABLE: 202,
  AR_BAR_CHART: 203,
  AR_PIE_CHART: 204,
  AR_ELEMENT_GROUP: 301,
  AR_MARKER_LINE: 302,
}
/** ARAction操作类型 */
export const ARAction: IARAction = {
  NULL: 0,
  SELECT: 1,
  SELECT_NODE: 2,
  MOVE: 101,
  ROTATE: 102,
  SCALE: 103,
  MEASURE: 200,
  FOCUS: 400,
  LINE_CREATE_FOUCUS: 601,
  LINE_CREATE: 602,
  VERTEX_ADD_FOUCUS: 701,
  VERTEX_ADD: 702,
  LineDot_CREATE_FOUCUS: 611,
  ARACTION_ROOMPLAN: 1000,
}
/** AR气泡文字锚点类型 */
export const ARTextAlign: IARTextAlign = {
  LEFT: 1,
  TOP: 2,
  RIGHT: 3,
  BOTTOM: 4,
  LEFT_START: 5,
  LEFT_END: 6,
  TOP_START: 7,
  TOP_END: 8,
  RIGHT_START: 9,
  RIGHT_END: 10,
  BOTTOM_START: 11,
  BOTTOM_END:12,
}
/** AR窗格动画分类 */
export const ARAnimatorCategory: IARAnimatorCategory = {
  DISAPPEAR: 0,
  APPEAR: 1,
  CUSTOM: 2,
}
/** AR窗格动画类型 */
export const ARAnimatorType: IARAnimatorType = {
  NODE_TYPE: 0,
  MODEL_TYPE: 1,
  GROUP_TYPE: 2
}
/** AR节点分类的动画类型 */
export const ARNodeAnimatorType: IARNodeAnimatorType = {
  TRANSLATION: 0,
  ROTATION: 1,
  SCALE: 2
}
/** AR窗格动画播放顺序类型 */
export const ARAnimatorPlayOrder: IARAnimatorPlayOrder = {
  AFTER_PREVIOUS: 0,
  WITH_PREVIOUS: 1,
  ON_TOUCH: 2,
}


interface IARWarning {
  /** 正常 */
  none?: true
  /** 距离太近 */
  close?: true
  /** 光线太暗 */
  dark?: true
  /** 移动太快 */
  fast?: true
  /** 特征点太少 */
  nofeature?: true
  /** 距离太远 */
  far?:true
}

interface ARStatusListeners {
  /**
   * AR是否在跟踪状态
   * 只有在跟踪状态才能获取正确的位置
   */
  onTrackingStateChange?: (isTracking: boolean) => void

  /**
   * 检测到的环境问题的回调
   */
  infoListener?: (info: IARWarning) => void
}


/**
 * AR对象图层信息，是AR对象显示的基本图层
 */
export interface ARElementLayer {
  /** 图层类型 */
  type: IARLayerType[Exclude<keyof IARLayerType, | 'EFFECT_LAYER' | 'AR3D_LAYER' | 'AR_SCENE_LAYER'>],
  /** 图层名 */
  name: string
  /** 图层显示名 */
  caption: string
  /** 图层关联的数据源别名 */
  datasourceAlias: string
  /** 图层关联的数据集名 */
  datasetName: string
  /** 图层是否可见 */
  isVisible: boolean
  /** 图层是否可选 */
  isSelectable: boolean
  /** 图层最大可见距离，单位米 */
  maxVisibleBounds: number
  /** 图层最小可见距离，单位米 */
  minVisibleBounds: number
  /** 图层最大动画距离，单位米，超出此距离时图层动画停止播放 */
  maxAnimationBounds: number
  /** 图层最小动画距离，单位米，小于此距离时图层动画停止播放 */
  minAnimationBounds: number
  /** 图层动画播放重复次数 */
  animationRepeatCount: number
}

/** AR特效图层 */
export interface AREffectLayer {
  /** 图层类型 */
  type: IARLayerType['EFFECT_LAYER'] | IARLayerType['UNKNOWN']
  /** 图层名 */
  name: string
  /** 图层显示名 */
  caption: string
  /** 图层是否可见 */
  isVisible: boolean
  /** 图层最大可见距离，单位米 */
  maxVisibleBounds: number
  /** 图层最小可见距离，单位米 */
  minVisibleBounds: number
  /** 特效播放时间，单位秒，0表示一直播放 */
  duration: number
  /** 特效图层中心点在AR地图坐标系下X坐标 */
  layerCenterX: number
  /** 特效图层中心点在AR地图坐标系下Y坐标 */
  layerCenterY: number
}

/**
 * AR场景图层，对应3维工作空间内的一个场景。
 *
 * 一副AR地图中只能加载一个3维场景，即只有一个AR场景图层
 */
export interface ARSceneLayer {
  /** 图层类型 */
  type: IARLayerType['AR_SCENE_LAYER'] | IARLayerType['UNKNOWN'],
  /** 图层名 */
  name: string
  /** 图层显示名 */
  caption: string
  /** 图层关联的数据源别名 */
  datasourceAlias: string
  /** 图层关联的数据集名 */
  datasetName: string
  /** AR3维场景图层包含的AR3维图层 */
  ar3DLayers: AR3DLayer[]
  /** 图层是否可见 */
  isVisible: boolean
}

/**
 * AR3维图层，对应3维工作空间一个场景内的3维图层
 */
export interface AR3DLayer {
  /** AR图层类型 */
  type: IARLayerType['AR3D_LAYER'] | IARLayerType['UNKNOWN'],
  /** 3维图层类型 */
  layer3DType: TLayer3DType
  /** 图层名 */
  name: string
  /** 图层显示名 */
  caption: string
  /** 图层关联的数据源别名 */
  datasourceAlias: string
  /** 图层关联的数据集名 */
  datasetName: string
  /** 此3维图层所在场景的名称 */
  sceneName?: string
  layer3DName: string
  /** 图层是否可见 */
  isVisible: boolean
}

/** AR地图中的图层。包括四种图层：
 * > {@link ARElementLayer} AR对象图层信息，是AR对象显示的基本图层
 *
 * > {@link AREffectLayer} AR特效图层
 *
 * > {@link ARSceneLayer} AR场景图层，对应3维工作空间内的一个场景。
 *
 * > {@link AR3DLayer} AR3维图层，对应3维工作空间一个场景内的3维图层
 */
export type ARLayer = ARElementLayer | AREffectLayer | ARSceneLayer | AR3DLayer

export interface ARElementStyle {
  /** 线颜色，前景色，文字颜色 */
  strokeColor: string
  /** 填充颜色，背景色 */
  fillColor: string

  /** 透明度 0-1 */
  opacity: number
  /** （文字，几何，边框）前景透明度 0-1 */
  strokeOpacity: number
  /** （文字，几何）填充透明度 0-1 */
  fillOpacity: number

  /** 点大小  */
  pointSize: number
  /** 线宽度  */
  lineWidth: number
  /** 文字大小  */
  textSize: number
  /** 对齐方式 */
  textAlign: TARTextAlign

  /** 边框颜色 */
  borderColor: string
  /** 边框宽度  单位：米*/
  borderWidth: number

  /** 符号线的符号角度 */
  markerLineRotation: number
  /** 符号线的符号间距 */
  pointInterval: number
  /** 符号线的符号路径 */
  markerSymbolPath: string
  /** 符号线符号的流速 */
  markerFlowVelocity: number

  /** 属性面板方向是否固定 */
  rotationFix: boolean

}


/** AR 对象 */
export type ARElement = ARElementBase | ARVideoAlbum

/** ARElement 基类 */
export interface ARElementBase {
  /** ar对象名 */
  layerName: string
  /** ar对象id */
  id: number
  /** ar对象类型 */
  type: TARElementType
}

export interface ARVideoAlbum extends ARElementBase{
  type: IARElementType['AR_VIDEO_ALBUM']
  /** 0： 循环， 1： 列表 */
  videoType: number
}

/** AR变换信息 */
export interface IARTransform {
  type: 'position' | 'rotation' | 'scale' | 'size'
  id: number
  layerName: string
  positionX: number
  positionY: number
  positionZ: number
  scale: number
  rotationX: number
  rotationY: number
  rotationZ: number
  touchType: number
  width?: number
  height?: number
}

/** AR模型动画参数信息 */
export type IAnimationParam =  IAnimationTranslation | IAnimationRotation

interface IAnimationTranslation {
  name: string
  type: 'translation',
  /** 动画时间，单位：毫秒，默认 1000ms */
  duration?: number,
  delay?: number,
  repeatCount?: number,
  repeatMode?: 1 | 2,
  startPosition: Point3D,
  direction: 'x' | 'y' | 'z'
  distance: number
}

interface IAnimationRotation {
  name: string
  type: 'rotation',
  duration?: number,
  delay?: number,
  repeatCount?: number,
  repeatMode?: 1 | 2,
  rotationAxis: Point3D,
  clockwise: boolean,
}


/**
 * 推演动画参数
 */
export type ARAnimatorParameter = ARModelAnimatorParameter | ARNodeAnimatorParameter | ARGroupAnimatorParameter<ARAnimatorParameter>

export type ARNodeAnimatorParameter = ARNodeTranslationAnimatorParameter
                             | ARNodeRotationAnimatorParameter
                             | ARNodeScaleAnimatorParameter

interface ARAnimatorParameterBase {
  category: TARAnimatorCategory
  type: TARAnimatorType
  name: string
  order?: TARAnimatorPlayOrder
  repeatCount?: number
  /** 延时 单位秒 */
  delay?: number
}

interface ARNodeAnimatorParameterBase extends ARAnimatorParameterBase {
  layerName: string
  elementID: number

  type: typeof ARAnimatorType.NODE_TYPE
  nodeType: TARNodeAnimatorType
  /** 节点动画时长 单位秒 */
  duration?: number
}

export interface ARNodeTranslationAnimatorParameter extends ARNodeAnimatorParameterBase {
  nodeType: typeof ARNodeAnimatorType.TRANSLATION
  translations: Vector3[]
}

export interface ARNodeRotationAnimatorParameter extends ARNodeAnimatorParameterBase {
  nodeType: typeof ARNodeAnimatorType.ROTATION
  rotationAxis?: Vector3
  degrees: number[]
}

export interface ARNodeScaleAnimatorParameter extends ARNodeAnimatorParameterBase {
  nodeType: typeof ARNodeAnimatorType.SCALE
  scales: Vector3[]
}

export interface ARModelAnimatorParameter extends ARAnimatorParameterBase {
  layerName: string
  elementID: number

  type: typeof ARAnimatorType.MODEL_TYPE
  modelAnimationIndex: number

  /** 模型动画时长 单位秒 */
  duration?: number
  /** 模型动画开始帧时间 单位秒 */
  startFrame?: number
  /** 模型动画结束帧时间 单位秒 */
  endFrame?: number
}

export interface ARGroupAnimatorParameter<Animator> extends ARAnimatorParameterBase {
  type: typeof ARAnimatorType.GROUP_TYPE
  animations: Animator[]
}

// ************************************
// 监听回调
// ************************************

let hittestListener: EmitterSubscription | undefined = undefined
let arinfoListener: EmitterSubscription | undefined = undefined
/** 设置 AR tracking状态 和 场景信息 监听*/
export function setARStatusListener(listeners?: ARStatusListeners): void {
  hittestListener?.remove()
  arinfoListener?.remove()
  hittestListener = listeners?.onTrackingStateChange && event.addListener(EventConst.MEASUREAREA_ADD, listeners.onTrackingStateChange)
  arinfoListener = listeners?.infoListener && event.addListener(EventConst.MEASUREAREA_DIOLOG, listeners.infoListener)
}



// ************************************
// 公共方法
// ************************************

/**
 * 是否支持 AR 功能
 *  返回值 1：正常 0：不支持AR -1：未安装AR服务
 * @platform ios android
 */
export function isSupportAR(): Promise<-1 | 0 | 1> {
  //android 需要连接google服务，暂不使用此接口
  return SARMap.isSupportAR()
}

/**
 * 跳转到 ARCore 安装页面(android)
 *
 * @platform android
 */
export async function installARCore(): Promise<void> {
  if(Platform.OS === 'android') {
    SARMap.installARCore()
  }
}

/**
 * 判断是否是华为设备
 *
 * @platform android
 */
export async function isHuawei(): Promise<boolean> {
  if(Platform.OS === 'android') {
    return await SARMap.isHuawei()
  }
  return false
}

/**
 * 屏幕截图
 * @param path 截图存放路径
 * @param withInfo 是否包含AI识别信息等，默认 false
 */
export async function captureImage(path: string, withInfo = false): Promise<boolean> {
  return await SARMap.captureImage(path, withInfo)
}

/**
 * 截取当前帧并解析其中的二维码信息
 * @returns 解码的二维码信息，失败返回空字符串
 */
export function qrScan(): Promise<string> {
  return SARMap.qrScan()
}

/** 暂停AR跟踪及场景渲染 */
export function onPause(): Promise<boolean> {
  return SARMap.onPause()
}

/** 开始AR跟踪及场景渲染 */
export function onResume(): Promise<boolean> {
  return SARMap.onResume()
}

/** 停止并释放AR场景所占有的资源 */
export function dispose(): Promise<boolean> {
  return SARMap.dispose()
}



// ************************************
// AR设置选项
// ************************************

/**
 * 显示或隐藏点云
 * @param show 是否显示AR场景中的点云
 */
export async function showPointCloud(show: boolean): Promise<void> {
  await SARMap.showPointCloud(show)
}

/**
 * AR场景是否3维优先
 * 3维优先时3维场景将显示在最下层
 * 其他所有对象都将盖在三维上面，
 * 反之，则3维在上层，将盖住所有其他对象
 *
 * 目前优先显示3维的话，设备仅支持横屏
 * @param is3dFirst 3维是否优先显示(在最下层)
 * @platform android
 */
export async function setIs3dSceneFirst(is3dFirst: boolean): Promise<void> {
  if(Platform.OS !== 'android') return
  await SARMap.setIs3dSceneFirst(is3dFirst)
}

/**
 * 获取当前是否是3为优先显示状态
 * @returns 3维是否优先显示(在最下层)
 * @platform android
 */
export async function getIs3dSceneFirst(): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.getIs3dSceneFirst()
}

/**
 * 设置是否开启深度遮挡 （1. 在优先渲染到三维开启状态下无效； 2.设置之后需要重新初始化AR地图才生效）
 * @param isOpenDepthMode 是否开启深度遮挡 true: 开启 false:不开启
 * @returns
 */
export async function setIsOpenDepthMode(isOpenDepthMode: boolean): Promise<void> {
  if(Platform.OS !== 'android') return
  await SARMap.setIsOpenDepthMode(isOpenDepthMode)
}

/**
 * 获取深度遮挡开启状态
 * @returns 深度遮挡开启状态 true: 开启 false:未开启
 * @platform android
 */
export async function getIsOpenDepthMode(): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.getIsOpenDepthMode()
}



// ************************************
// 地图校准相关
// ************************************


/**
 * 位置校准（设备垂直地面，摄像头面对正北方向进行）
 * @param longitude 经度
 * @param latitude 纬度
 * @param height 相对地面高度 单位 米
 */
export function calibrate(longitude: number, latitude: number, height: number): Promise<boolean> {
  return SARMap.calibrate(longitude, latitude, height)
}

/**
 * 开始增强位置校准
 *
 * 定位结果用 SMARMapview#onAugmentedCalibrateResult 回调来监听
 *
 * 通过扫描识别带有位置信息二维码的图片进行增强位置校准
 * 二维码解码后为json字符串，格式为：
 *
 * > {
 *
 * >> x: number //图片所在地理位置的横坐标
 *
 * >> y: number //图片所在地理位置的纵坐标
 *
 * >> h: number //图片相对地面的高度， 单位 米
 *
 * >> mercator: boolean //可选，当前坐标系是否为墨卡托，默认为 true，否则为经纬度
 *
 * >> vertical: boolean //可选，图片是否垂直放置（贴在墙上），默认为 false，即放在地面上
 *
 * >> angle: number //可选，图片正面与正北的夹角，默认为 0
 *
 * > }
 */
export function startAugmentedCalibrate():Promise<boolean>{
  return SARMap.startAugmentedCalibrate()
}

/**
 * 退出增强位置校准
 */
export function stopAugmentedCalibrate():Promise<boolean>{
  return SARMap.stopAugmentedCalibrate()
}

/**
 * 高精自动定位状态下是否自动校准（打开或关闭）
 * @param isRTKAutoCalibration 设置的状态（true为打开， false为关闭）
 * @returns boolean 是否设置成功
 * @platform android
 * @author lyx
 */
export async function setRTKAutoCalibration(isRTKAutoCalibration: boolean): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.setRTKAutoCalibration(isRTKAutoCalibration)
}

export interface RTKCalibrateParam {
  /** 校准位置 */
  location: LongitudeAndLatitude,
  /** 校准精度 */
  HDOP?: number,
}

/**
 * 设置高精度定位信息进行自动校准
 *
 * 当关闭高精定位自动校准时可使用此接口手动进行高精度定位校准
 * @param calibrationParam 高精度的定位信息(校准位置和校准精度)
 * @platform android
 */
export async function RTKCalibrate(calibrationParam: RTKCalibrateParam): Promise<boolean> {
  return SARMap.RTKCalibrate(calibrationParam)
}

/** 两点定位的参数类型 */
export interface TwoPointPositionParamType {
  /** 第一个定位点的经纬度坐标点（是arPnt1对应的实景点的经纬度作标） */
  gpsPnt1: Point2D,
  /** 第二个定位点的经纬度坐标点（是arPnt2对应的实景点的经纬度作标） */
  gpsPnt2: Point2D,
  /** 第一个实景点的AR坐标点（对应的经纬度坐标点是gpsPnt1） */
  arPnt1: Point3D,
  /** 第二个实景点的AR坐标点（对应的经纬度坐标点是gpsPnt2） */
  arPnt2: Point3D,
  /** 两点定位校准高度 */
  height: number,
}


/**
 * 两点定位
 * @param param 两点定位的参数
 * @returns boolean 是否定位成功
 * @author lyx
 */
export function twoPointPosition(param: TwoPointPositionParamType): Promise<boolean> {
  return SARMap.twoPointPosition(param)
}


// ************************************
// 地图坐标相关
// ************************************

/**
 * 获取当前相机在AR场景的坐标，即当前位置所处的AR坐标
 *
 * AR坐标系为右手坐标系
 */
export function getCurrentARPosition(): Promise<Vector3 | undefined | null> {
  return SARMap.getCurrentARPosition()
}

/**
 * 获取当前AR地图坐标系XML字符串形式的描述
 * @returns 当前AR地图坐标系({@link PrjCoordSys})XML字符串形式的描述
 */
export function getPrjCoordSys(): Promise<string> {
  return SARMap.getPrjCoordSys()
}

/**
 * 将AR场景坐标转换成AR地图的地图坐标
 *
 * 当前AR地图所用投影坐标系用 {@link getPrjCoordSys} 获取
 * @param points AR场景坐标
 * @returns 转换后对应AR地图当前投影坐标系的坐标,其中z为相对地面高度
 */
export function CoordSysTranslatorARToMapPrj(points: Vector3[]): Promise<Vector3[]> {
  return SARMap.CoordSysTranslatorARToMapPrj(points)
}

/**
 * 将AR地图投影坐标系的坐标转换成AR场景坐标
 *
 * 当前AR地图所用投影坐标系用 {@link getPrjCoordSys} 获取
 * @param points AR地图当前投影坐标系的坐标,其中z为相对地面高度
 * @returns AR场景中的坐标
 */
export function CoordSysTranslatorMapPrjToAR(points: Vector3[]): Promise<Vector3[]> {
  return SARMap.CoordSysTranslatorMapPrjToAR(points)
}

/**
 * ios切换AR界面时可能会有问题，需要前调用此接口
 * @param bAdd
 * @platform ios
 * @deprecated todo 内部使用
 */
export function coachingOverlayView(bAdd:boolean): void {
  if (Platform.OS === 'ios') {
    SARMap.coachingOverlayView(bAdd)
  }
}



// ************************************
// ar地图
// ************************************

/**
 * 根据路径打开 ar 地图 xml
 * @param path 地图xml所在绝对路径
 * @returns 是否成功
 */
export function open(path: string): Promise<boolean> {
  return SARMap.open(path)
}

/**
 * 关闭当前ar地图
 * @returns 是否成功
 */
export function close(): Promise<boolean> {
  return SARMap.close()
}

/**
 * 将AR地图中心点移动到当前位置
 *
 * 即使用AR地图中心点进行位置校准
 * @returns 操作是否成功
 */
export async function moveToMapCenter(): Promise<boolean>{
  return await SARMap.moveToMapCenter()
}

/**
 * 保存当前地图
 * @returns 保存是否成功
 * @throws 许可异常
 */
export function save(): Promise<boolean> {
  return SARMap.save()
}

/**
 * 保存当前地图到指定文件中
 * @param path 文件所在绝对路径
 * @returns 另存是否成功
 * @throws 许可异常
 */
export function saveAs(path: string): Promise<boolean> {
  return SARMap.saveAs(path)
}

/**
 * 导出AR地图到指定目录下
 * @param mapName 要导出的AR地图名
 * @param targetPath 要到处的目录绝对路径
 * @returns 导出是否成功
 * @throws 许可异常
 */
export function exportMap(mapName: string, targetPath: string): Promise<boolean> {
  return SARMap.exportMap(mapName, targetPath)
}

/**
 * 导入AR地图
 * @param mapPath 要导入的 ar地图xml 所在的绝对路径
 * @returns 导入是否成功
 */
export function importMap(mapPath: string): Promise<boolean> {
  return SARMap.importMap(mapPath)
}

/**
 * 设置AR地图点击操作类型
 *
 * @param action 操作类型，详见 {@link ARAction}
 */
export function setAction(action: TARAction): Promise<boolean> {
  return SARMap.setAction(action)
}

/**
 * 清除AR地图中对象的选中状态
 */
export function clearSelection(): Promise<boolean> {
  return SARMap.clearSelection()
}

/**
 * 获取当前焦点的AR坐标 (屏幕中心点发出的射线与当前场景中平面的焦点)
 * @returns 设置 {@link ARAction} 为FOCUS时，焦点所在坐标，若没有焦点，则为空
 */
export function getFocusPosition(): Promise<Vector3 | null | undefined> {
  return SARMap.getFocusPosition()
}

/**
 * 指定编辑的AR对象
 * @param elementID AR对象的id
 * @param layerName AR对象所在图层名
 */
export function appointEditElement(elementID: number, layerName: string): Promise<boolean> {
  return SARMap.appointEditElement(elementID, layerName)
}

/**
 * 指定要编辑的{@link ARSceneLayer}或{@link AR3DLayer}
 * @param layerName 要编辑的 ARSceneLayer 或 AR3DLayer 图层名
 */
export function appointEditAR3DLayer(layerName: string): Promise<boolean>{
  return SARMap.appointEditAR3DLayer(layerName)
}

/**
 * 提交对AR对象或3D图层的修改
 * @throws 许可异常
 */
export function submit(): Promise<boolean> {
  return SARMap.submit()
}

/** 取消对AR对象或3D图层的修改 */
export function cancel(): Promise<boolean> {
  return SARMap.cancel()
}

/** 刷新地图 */
export function refresh(): Promise<boolean> {
  return SARMap.refresh()
}



// ************************************
// AR 图层相关
// ************************************


/** 获取ar地图中的图层信息 */
export function getLayers(): Promise<Array<ARLayer>> {
  return SARMap.getLayers()
}

/**
 * 获取 {@link ARElementLayer} 的风格
 * @param layerName ARElementLayer 图层名
 * @returns 图层风格
 */
export function getLayerStyle(layerName: string): Promise<ARElementStyle | undefined | null> {
  return SARMap.getLayerStyle(layerName)
}

/**
 * 设置 {@link ARElementLayer} 的风格
 * @param layerName ARElementLayer 图层名
 * @param style 要设置的风格
 */
export function setLayerStyle(layerName: string, style: Partial<ARElementStyle>): Promise<boolean> {
  return SARMap.setLayerStyle(layerName, style)
}

/**
 * 设置AR图层的可见性
 * @param layerName 图层名
 * @param visible 是否可见
 */
export function setLayerVisible(layerName: string, visible: boolean): Promise<boolean> {
  return SARMap.setLayerVisible(layerName, visible)
}

/**
 * 设置图层显示名(caption)
 * @param layerName 图层名
 * @param caption 图层显示名
 */
export function setLayerCaption(layerName: string, caption: string): Promise<boolean> {
  return SARMap.setLayerCaption(layerName, caption)
}

/**
 * 设置AR图层中的对象是否可选
 * @param layerName 图层名
 * @param caption 是否可选
 */
export function setLayerSelectable(layerName: string, selectable: boolean): Promise<boolean>{
  return SARMap.setLayerSelectable(layerName, selectable)
}

/**
 * 设置 {@link ARElementLayer} 或 {@link AREffectLayer} 最大可见距离
 * @param layerName ARElementLayer 或 AREffectLayer 图层名
 * @param bounds 最大可见距离，单位米，超过此距离的对象将不显示
 */
export function setLayerMaxVisibleBounds(layerName: string, bounds: number): Promise<boolean> {
  return SARMap.setLayerMaxVisibleBounds(layerName, bounds)
}

/**
 * 设置 {@link ARElementLayer} 或 {@link AREffectLayer} 最小可见距离
 * @param layerName ARElementLayer 或 AREffectLayer 图层名
 * @param bounds 最小可见距离，单位米，小于此距离的对象将不显示
 */
export function setLayerMinVisibleBounds(layerName: string, bounds: number): Promise<boolean> {
  return SARMap.setLayerMinVisibleBounds(layerName, bounds)
}

/**
 * 设置 {@link ARElementLayer} 最大动画距离
 * @param layerName ARElementLayer 图层名
 * @param bounds 图层最大动画距离，单位米，超出此距离时图层动画停止播放
 */
export function setLayerMaxAnimationBounds(layerName: string, bounds: number): Promise<boolean> {
  return SARMap.setLayerMaxAnimationBounds(layerName, bounds)
}

/**
 * 设置 {@link ARElementLayer} 最小动画距离
 * @param layerName ARElementLayer 图层名
 * @param bounds 图层最小动画距离，单位米，小于此距离时图层动画停止播放
 */
export function setLayerMinAnimationBounds(layerName: string, bounds: number): Promise<boolean> {
  return SARMap.setLayerMinAnimationBounds(layerName, bounds)
}

/**
 * 设置图层动画重复次数
 * @param repeatCount  0: 不重复 ； -1: 无限重复； 大于0: 重复次数
 */
export function setLayerAnimationRepeatCount(layerName: string, repeatCount: number): Promise<boolean> {
  return SARMap.setLayerAnimationRepeatCount(layerName, repeatCount)
}

/**
 * 上移 {@link AREffectLayer}
 * @param layerName AREffectLayer 图层名
 */
export function moveLayerUp(layerName: string): Promise<boolean> {
  return SARMap.moveLayerUp(layerName)
}

/**
 * 下移图层 {@link AREffectLayer}
 * @param layerName AREffectLayer 图层名
 */
export function moveLayerDown(layerName: string): Promise<boolean> {
  return SARMap.moveLayerDown(layerName)
}

/**
 * 设置特效图层 {@link AREffectLayer} 的中心点
 *
 * @param layerName 特效图层名
 * @param center 要设置的点，坐标系为当前AR地图的投影坐标系
 */
export function setEffectLayerCenter(layerName: string, center: Point2D): Promise<boolean> {
  return SARMap.setEffectLayerCenter(layerName, center)
}

/**
 * 设置特效图层 {@link AREffectLayer} 持续时间
 * @param duration 持续时间，整数，单位秒，0表示一直播放
 */
export function setEffectLayerDuration(layerName: string, duration: number): Promise<boolean> {
  return SARMap.setEffectLayerDuration(layerName, duration)
}

/**
 * 设置特效图层{@link AREffectLayer}使用的特效
 * @param layerName 要修改的特效图层名
 * @param effectPath 特效文件绝对路径
 */
export function setAREffect(layerName: string, effectPath: string): Promise<boolean> {
  return SARMap.setAREffect(layerName, effectPath)
}


/**
 * 添加 {@link ARElementLayer} 图层
 * @param datasetInfo 图层要添加到的数据集信息
 * @param type ARLementLayer的图层类型
 * @returns  返回添加的图层名称,失败返回空字符串
 */
export function addElementLayer(datasetInfo: DatasetInfo, type: IARLayerType[Exclude<keyof IARLayerType, | 'EFFECT_LAYER' | 'AR3D_LAYER' | 'AR_SCENE_LAYER' | 'UNKNOWN'>]): Promise<string>
/**
 * 添加 {@link ARElementLayer} 图层
 * @param datasetInfo 图层要添加到的数据集信息
 * @param type ARLementLayer的图层类型
 * @param forceAdd 是否可以重复添加同一数据集,默认false
 * @returns  返回添加的图层名称,失败返回空字符串
 */
export function addElementLayer(datasetInfo: DatasetInfo, type: IARLayerType[Exclude<keyof IARLayerType, | 'EFFECT_LAYER' | 'AR3D_LAYER' | 'AR_SCENE_LAYER' | 'UNKNOWN'>], forceAdd: boolean): Promise<string>
export function addElementLayer(datasetInfo: DatasetInfo, type: IARLayerType[Exclude<keyof IARLayerType, | 'EFFECT_LAYER' | 'AR3D_LAYER' | 'AR_SCENE_LAYER' | 'UNKNOWN'>], forceAdd = false): Promise<string> {
  return SARMap.addElementLayer(datasetInfo, type, forceAdd)
}

/**
 * 添加AR3维场景图层
 * @param datasetInfo 保存三维图层的数据集，注意此数据需要为空数据集
 * @param workspaceServer 三维场景工作空间路径
 * @param initForm 初始的位置，旋转和缩放参数
 * @param sceneOption 设置添加时的3维中心点偏移坐标，3维图层在AR场景中的坐标系类型
 * @returns  返回添加的图层名称,失败返回空字符串
 */
export function addSceneLayer(datasetInfo: DatasetInfo, workspaceServer: string, initForm?: Partial<Transform>, sceneOption?: Partial<SceneOption>): Promise<string> {
  return SARMap.addSceneLayer(datasetInfo, workspaceServer, initForm, sceneOption)
}

interface SceneOption {
  /** 3维中心点偏移坐标，如想让3维场景中（10， 0， 0）变为添加时的中心点，则可在此处填写此坐标 */
  offset: Point3D
  /**
   * 指定3维场景内3维图层保存的点的类型，0：局部坐标， 1： ar地图坐标
   * 添加后不可更改。默认为局部坐标
   */
  childCoordSysType: 0 | 1
}

/**
 * 添加在线AR3维场景图层
 * @param datasetInfo 保存三维图层的数据集，注意此数据需要为空数据集
 * @param serverUrl 在线三维场景的的url
 * @param sceneName 在线三维场景名
 * @param initForm 初始的位置，旋转和缩放参数
 * @param sceneOption 设置添加时的3维中心点偏移坐标，3维图层在AR场景中的坐标系类型
 * @returns  返回添加的图层名称,失败返回空字符串
 */
export function addSceneLayerOnline(datasetInfo: DatasetInfo, serverUrl: string, sceneName: string, initForm?: Partial<Transform>, sceneOption?: Partial<SceneOption>): Promise<string> {
  return SARMap.addSceneLayerOnline(datasetInfo, serverUrl, sceneName, initForm, sceneOption)
}

/**
 * 新建kml格式的三维图层到AR三维场景图层中
 * @param sceneLayerName 要添加到的AR场景图层 ({@link ARSceneLayer}）名
 * @param layerName 指定添加的图层名称
 * @returns 返回添加的图层名称,失败返回空字符串
 */
export function add3DLayer(sceneLayerName: string, layerName: string): Promise<string>
/**
 * 根据指定的kml文件添加三维图层到AR三维场景图层中
 * @param sceneLayerName 要添加到的AR场景图层 ({@link ARSceneLayer}）名
 * @param layerName 指定添加的图层名称
 * @param kmlPath 指定的kml文件的绝对路径
 * @returns 返回添加的图层名称,失败返回空字符串
 */
export function add3DLayer(sceneLayerName: string, layerName: string, kmlPath: string): Promise<string>
export function add3DLayer(sceneLayerName: string, layerName: string, kmlPath = ''): Promise<string>  {
  return SARMap.add3DLayer(sceneLayerName, layerName, kmlPath)
}

/**
 * 向已添加的3Dlayer，动态添加对象
 * @param layerName 指定添加的图层名称
 * @param jsonData json对象
 * @returns 成功返回true，失败返回false
 */
export function addJsonTo3DLayer(layerName: string, jsonData:string): Promise<boolean>  {
  return SARMap.addJsonTo3DLayer(layerName, jsonData)
}

/**
 * 导出 {@link AR3DLayer} 为kml文件
 * @param layerName AR3DLayer 图层名
 * @returns 是否成功
 */
export function save3DLayerAsKml(layerName: string, kmlPath: string): Promise<boolean> {
  return SARMap.save3DLayerAsKml(layerName, kmlPath)
}

/**
 * 修改3维kml图层上的几何对象
 * @param layerName {@link AR3DLayer}图层名（通过kml添加的）
 * @param id 几何对象id
 * @param param 更新参数
 * @returns 是否成功
 */
export function updateAR3DGeometry(layerName: string, id: number, param: AR3DGeometryParam): Promise<boolean> {
  return SARMap.updateAR3DGeometry(layerName, id, param)
}

/** AR 3维kml对象参数 */
export interface AR3DGeometryParam {
  /** 坐标数组 */
  coordinates: [number, number, number][]
}

/** RGBA的颜色 */
export interface RGBA {
  /** 红色 [0,255] */
  r: number
  /** 绿色 [0,255] */
  g: number
  /** 蓝色 [0,255] */
  b: number
  /** 透明度 [0,1] */
  a: number
}

export interface GeoStyle3D {
  /** 面的颜色 */
  fillForeColor?: RGBA
  /** 线的颜色 */
  lineColor?: RGBA
  /** 线的宽度 */
  lineWidth?: number
  /** 点的颜色 */
  markerColor?: RGBA
  /** 点的缩放 */
  markerScale?: number
  /**
   * marker文件路径
   * 若是 app 内置资源，使用 APP:// 开头
   */
  markerFile?: string
  /** 高度模式 */
  // altitudeMode: AltitudeMode[keyof AltitudeMode]
}

export async function setAR3DLayerStyle(layerName: string, styleParam: GeoStyle3D): Promise<boolean> {
  // if(Platform.OS !== 'android') return false
  return await SARMap.setAR3DLayerStyle(layerName, styleParam)
}

/**
 * 获取三维图层的风格
 * @param layerName 三维图层的名字
 * @returns 返获取到的风格
 * @author lyx
 */
export async function getAR3DLayerStyle(layerName: string): Promise<GeoStyle3D | null | undefined> {
  // if(Platform.OS !== 'android') return null
  return await SARMap.getAR3DLayerStyle(layerName)
}

// export async function get3DLayerObjectsIds(layerName: string): Promise<Array<number> | null> {
//   if(Platform.OS !== 'android') return null
//   return await SARMap.get3DLayerObjectsIds(layerName)
// }

/**
 * 三维图层对象的透明度设置
 * @param layerName 三维图层的名字
 * @param ids 该三维图层里需要设置透明度的对象id（不是SmId,对应桌面里的序号）
 * @param color 颜色 透明度在 [0,1]这个闭区间
 * @return 是否设置成功
 */
export async function setAR3DLayerObjectsColor(layerName: string, ids:Array<number>, color: RGBA): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.setAR3DLayerObjectsColor(layerName, ids, color)
}

/**
 * 三维图层对象的透明度获取
 * @param layerName 三维图层的名字
 * @param ids 该三维图层里需要设置透明度的对象id（不是SmId,对应桌面里的序号）
 * @return 成功返回颜色数组
 */
export async function getAR3DLayerObjectsColor(layerName: string, ids:Array<number>): Promise<Array<RGBA | null | undefined>> {
  if(Platform.OS !== 'android') return []
  return await SARMap.getAR3DLayerObjectsColor(layerName, ids)
}

/**
 * 获取当前已添加的场景路径
 * @returns 场景路径
 */
export async function getARSceneLayerPath(): Promise<string | null| undefined> {
  if(Platform.OS !== 'android') return null
  return await SARMap.getARSceneLayerPath()
}

/**
 * 三个不共线的点确定一个平面，平面的法线方向遵循右手法制（顺时针和逆时针由第一个过第二个点向第三个点转确定）
 */
export interface clipPlanePointParam {
  // 裁剪面第一个点
  firstPoint: Point3D
  // 裁剪面第二个点
  secondPoint: Point3D
  // 裁剪面第三个点
  thirdPoint: Point3D
}

/** 三维图层裁剪参数 */
export interface clipAR3DLayerParam extends clipPlanePointParam {
  /** 图层名字 */
  layerName: string
  // 剖切面（线）的颜色
  color?: RGBA
  // 是否清除上一次的裁剪结果 true:清除 false:不清除(不传默认为false）
  // clearLast?: boolean
}

/**
 * 根据指定平面裁剪三维图层 （裁剪面分析，按顺序设置三个顶点的位置，裁剪面分析的结果指只显示该面法线方向的部分，法线遵循右手法则，逆时针法线朝上，顺时针法线朝下，分析结果只显示大拇指方向上的模型结构。一个图层同一时间只能有一个剖切平面）
 * @param clipParam 裁剪参数
 * @returns 裁剪成功返回true，失败返回false
 */
export async function clipAR3DLayerByPlane(clipParam: clipAR3DLayerParam): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.clipAR3DLayerByPlane(clipParam)
}

/**
 * 清除指定图层的裁剪面
 * @param layerName 图层名字
 * @returns 清除成功返回true, 失败返回false
 */
export async function clearAR3DLayerClipPlane(AR3DLayerName: string): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.clearAR3DLayerClipPlane(AR3DLayerName)
}


/**
 * 获取指定三维图层的裁剪面
 * @param AR3DLayerName  三维图层名字
 * @returns 成功返回裁剪面
 */
export async function getAR3DLayerClipPlan(AR3DLayerName: string): Promise<clipPlanePointParam | null | undefined> {
  if(Platform.OS !== 'android') return null
  return await SARMap.getAR3DLayerClipPlan(AR3DLayerName)
}

/**
 * 添加特效图层
 * @param layerName 要添加的图层名
 * @param effectPath 特效文件 .areffect 所在绝对路径
 * @returns  返回添加的图层名称,失败返回空字符串
 */
export function addEffectLayer(layerName: string, effectPath: string): Promise<string> {
  return SARMap.addEffectLayer(layerName, effectPath)
}

/**
 * 移除AR图层
 * @param layerName 要移除的图层名字
 */
export function removeARLayer(layerName: string): Promise<boolean> {
  return SARMap.removeARLayer(layerName)
}



// ************************************
// AR 对象添加
// ************************************

/** 场景中对象的位置，旋转和缩放 */
export interface Transform {
  /** 位置坐标 */
  position: Vector3
  /** 欧拉角或者四元数表示的角度 */
  rotation: Vector3 | Quaternion
  /** 缩放比例 */
  scale: Vector3
}

/** 四元数 */
interface Quaternion {
  x: number
  y: number
  z: number
  w: number
}



/**
 * 添加 ar media 对象（图片，视频或网页）
 * @param layerName 要添加到的图层
 * @param type ar图片，ar视频或ar网页的类型
 * @param content 图片，视频，网页的地址
 * @param initForm 初始的位置，旋转和缩放参数
 */
export function addARMedia(layerName: string, type: IARElementType['AR_IMAGE'] | IARElementType['AR_VIDEO'] | IARElementType['AR_WEBVIEW'], content: string, initForm?: Partial<Transform>): Promise<boolean> {
  return SARMap.addARMedia(layerName, type, content, initForm)
}

/**
 * 添加 ar text 对象
 * @param layerName 要添加到的图层
 * @param content 要添加的文字
 * @param initForm 初始的位置，旋转和缩放参数
 */
export function addARText(layerName: string, content: string, initForm?: Partial<Transform>): Promise<boolean>{
  return SARMap.addARText(layerName, content, initForm)
}

/**
 * 获取 ARText 的文字
 * @param layerName ar文本图层名
 * @param id ARText对象id
 * @returns ARText当前显示的文字
 */
export function getARText(layerName: string, id: number): Promise<string> {
  return SARMap.getARText(layerName, id)
}

/**
 * 设置 ARText 的文字
 * @param layerName ar文本图层名
 * @param id ARText对象id
 * @param text 要设置的文本内容
*/
export function setARText(layerName: string, id: number, text: string): Promise<boolean> {
  return SARMap.setARText(layerName, id, text)
}

/**
 * 添加 ar 气泡文字 对象
 * @param layerName 要添加到的图层
 * @param content 要添加的文字
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function addARBubbleText(layerName: string, content: string, initForm?: Partial<Transform>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARBubbleText(layerName, content, initForm)
}

/**
 * 往场景中添加模型
 * @param layerName 要添加到的图层名
 * @param modelPath 模型文件所在的绝对路径
 * @param initForm 初始的位置，旋转和缩放参数
 */
export function addARModel(layerName: string, modelPath: string, initForm?: Partial<Transform>): Promise<boolean>{
  return SARMap.addARModel(layerName, modelPath, initForm)
}

/**
 * 往场景中添加沙盘模型
 * @param layerName 要添加到的图层名
 * @param sourcePath 沙盘xml文件所在绝对路径
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function addARSandTable(layerName: string, sourcePath: string, initForm?: Partial<Transform>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARSandTable(layerName, sourcePath, initForm)
}

/**
 * 获取沙盘内容
 * @param layerName 沙盘所在图层
 * @param modelID 沙盘对象 elementid
 * @returns 沙盘xml文件的json字符串
 * @platform android
 */
export async function getARSandTableData(layerName: string, modelID: number): Promise<string>{
  if(Platform.OS !== 'android') return ''
  return await SARMap.getARSandTableData(layerName, modelID)
}

/**
 * 修改沙盘内容
 * @param layerName 沙盘所在图层
 * @param modelID 沙盘对象 elementid
 * @param json 沙盘xml文件的json字符串
 * @throws 许可异常
 * @platform android
 */
export async function setARSandTableData(layerName: string, modelID: number, json: string): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.setARSandTableData(layerName, modelID, json)
}




//********************** ar geometry ************************/


/**
 * 添加 ar 矢量线 或矢量符号线的 节点对象
 * @param layerName 要添加到的图层
 * @param params 添加参数
 * @platform android
 */
export async function addARLinePoint(layerName: string, params?: Partial<Pick<Transform, 'position'>>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARLinePoint(layerName, params)
}

/**
 * 取消（退出）添加 ar 矢量线 或矢量符号线的 节点对象
 * @param layerName 图层名
 * @platform android
 */
export async function exitAddARLine(layerName: string): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.exitAddARLine(layerName)
}

/**
 * 撤销 ar 矢量线 或矢量符号线的 节点对象的添加操作
 * @param layerName 图层名
 * @platform android
 */
export async function cancelAddARLinePoint(layerName: string): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.cancelAddARLinePoint(layerName)
}

/**
 * 添加 ar 矢量线 或矢量符号线的 对象
 * @param layerName 图层名
 * @platform android
 */
export async function addARLineElement(layerName: string): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARLineElement(layerName)
}




//********************** ar 小组件 ************************/

export interface MediaSource {
  /** 图片绝对路径或 uri */
  uri: string
  /** 图片的时间戳 */
  timestamp: number
}

/**
 * 添加 ar相册 小组件 (流程图样式)
 * @param layerName 要添加到的小组件图层名
 * @param arPhotos 要添加的图片的信息
 * @param albumName 相册标题
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function addARAlbum(layerName: string, arPhotos: MediaSource[], albumName: string, initForm?: Partial<Transform>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARAlbum(layerName, arPhotos, albumName, initForm)
}

/**
 *  添加 ar属性相册 小组件（列表样式）
 * @param layerName 要添加到的小组件图层名
 * @param arPhotos 要添加的图片的信息
 * @param albumName 相册标题
 * @param initForm 初始的位置，旋转和缩放参数
 */
export function addARAttributeAlbum(layerName: string, arPhotos: MediaSource[], albumName: string, initForm?: Partial<Transform>): Promise<boolean>{
  return SARMap.addARAttributeAlbum(layerName, arPhotos, albumName, initForm)
}

/**
 *  添加 ar视频册 小组件
 * @param layerName 要添加到的小组件图层名
 * @param arPhotos 要添加的视频的信息
 * @param albumName 相册标题
 * @param alignment 排列样式 0： 循环， 1： 列表； ios 只支持列表
 * @param initForm 初始的位置，旋转和缩放参数
 */
export function addARVideoAlbum(layerName: string, arPhotos: MediaSource[], albumName: string, alignment: 0 | 1, initForm?: Partial<Transform>): Promise<boolean>{
  return SARMap.addARVideoAlbum(layerName, arPhotos, albumName, alignment, initForm)
}

/**
 * 添加 ar地图册 小组件
 * @param layerName 要添加到的小组件图层名
 * @param mapPath 地图相对应用目录的路径
 * @param albumName 相册标题
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function addARMapAlbum(layerName: string, mapPath: string[], albumName: string, initForm?: Partial<Transform>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARMapAlbum(layerName, mapPath, albumName, initForm)
}

/**
 * 添加地图册ai配图使用的图片
 * @param layerName 地图相册所在图层
 * @param id 地图相册的id
 * @param pics ai配图的图片绝对路径或uri路径
 * @platform android
 */
export async function addAIPictureToMapAlbum(layerName: string, id: number, pics: string[]): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return SARMap.addAIPictureToMapAlbum(layerName, id, pics)
}

/**
 * 添加 ar沙盘册 小组件
 * @param layerName 要添加到的小组件图层名
 * @param sourcePaths 沙盘xml的绝对路径
 * @param albumName 相册标题
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function addARSandTableAlbum(layerName: string, sourcePaths: string[], albumName:string, initForm?: Partial<Transform>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARSandTableAlbum(layerName, sourcePaths, albumName, initForm)
}

/** 单个图表数据 */
interface ChartData {
  /** 数据名称 */
  name: string,
  /** 数据值 */
  value: string,
  /** 16进制的颜色字符串，格式：#RRGGBB 或 #AARRGGBB */
  color: string,
}

/** 图表数据 */
interface Chart {
  /** 图标数据数组 */
  data: Array<ChartData>,
  /** 单位字符串 */
  unit: string
}

/**
 * 添加 ar柱状图 小组件
 * @param layerName 要添加到的小组件图层名
 * @param data 图表数据
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function addBarChart(layerName: string, data: Chart, initForm?: Partial<Transform>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addBarChart(layerName, data, initForm)
}

/**
 * 修改 ar柱状图 小组件
 * @param layerName 柱状图小组件所在图层名
 * @param id 柱状图小组件的id
 * @param data 要更新的图表数据
 * @platform android
 */
export async function updateBarChart(layerName: string, id: number, data: Chart): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.updateBarChart(layerName, id, data)
}

/**
 * 获取 ar柱状图 小组件的数据信息
 * @param layerName 柱状图小组件所在图层名
 * @param id 柱状图小组件的id
 * @returns 柱状图小组件的图表数据信息
 * @platform android
 */
export async function getBarChartData(layerName: string, id: number): Promise<Chart | null | undefined>{
  if(Platform.OS !== 'android') return null
  return await SARMap.getBarChartData(layerName, id)
}


/**
 * 添加 ar饼图 小组件
 * @param layerName 要添加到的小组件图层名
 * @param data 图表数据
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function addARPieChart(layerName: string, data: ChartData[], initForm?: Partial<Transform>): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.addARPieChart(layerName, data, initForm)
}

/**
 * 修改 ar饼图 小组件
 * @param layerName 饼图小组件所在图层名
 * @param id 饼图小组件的id
 * @param data 要更新的图表数据
 * @param initForm 初始的位置，旋转和缩放参数
 * @platform android
 */
export async function updatePieChart(layerName: string, id: number, data: ChartData[]): Promise<boolean>{
  if(Platform.OS !== 'android') return false
  return await SARMap.updatePieChart(layerName, id, data)
}

/**
 * 获取 ar饼图 小组件的数据信息
 * @param layerName 饼图小组件所在图层名
 * @param id 饼图小组件的id
 * @returns 饼图小组件的图表数据信息
 * @platform android
 */
export async function getPieChartData(layerName: string, id: number): Promise<ChartData[]>{
  if(Platform.OS !== 'android') return []
  return await SARMap.getPieChartData(layerName, id)
}





//*********************** 修改对象 ************************************************/


/**
 * 删除编辑中的AR对象
 */
export function removeEditElement(): Promise<boolean> {
  return SARMap.removeEditElement()
}

/**
 * poi 模型参数化变换
 * 增量修改AR对象的位置，旋转及缩放
 */
export function setARElementTransform(params: IARTransform): Promise<boolean> {
  return SARMap.setARElementTransform(params)
}

/**
 * 设置 ar对象 ({@link ARElement}) 的AR坐标
 * @param element ar对象所在图层名及id
 * @param position 要设置的ar坐标
 */
export function setARElementPosition(element: Pick<ARElement,'layerName' | 'id'>, position: Vector3): Promise<boolean> {
  return SARMap.setARElementPosition(element, position)
}

/**
 * 设置 AR 场景图层 ({@link ARSceneLayer}) 的AR坐标
 *
 * 设置场景图层的ar坐标后，其所有子节点（即AR3维图层({@link AR3DLayer})）均会跟随移动
 * @param arSceneLayerName AR 场景图层名称
 * @param position 要设置的ar坐标
 */
export function setARSceneLayerPosition(arSceneLayerName: string, position: Vector3): Promise<boolean> {
  return SARMap.setARSceneLayerPosition(arSceneLayerName, position)
}

/**
 * 设置 AR 3维图层 ({@link AR3DLayer}) 的AR坐标
 * @param ar3dlayerName AR 3维图层名称
 * @param position 要设置的ar坐标
 */
export function setAR3DLayerPosition(ar3dlayerName: string, position: Vector3): Promise<boolean> {
  return SARMap.setAR3DLayerPosition(ar3dlayerName, position)
}

/**
 * 设置 AR 3维图层 ({@link AR3DLayer}) 相对于场景图层（{@link ARSceneLayer}）的局部坐标
 *
 * 设置相对与场景图层的局部坐标时，3维图层最终在AR场景的坐标会受到其父节点（即场景图层）的位置，旋转及缩放影响。
 * @param ar3dlayerName AR 3维图层名称
 * @param position 相对与场景图层的ar局部坐标
 */
export function setAR3DLayerLocalPosition(ar3dlayerName: string, localPosition: Vector3): Promise<boolean> {
  return SARMap.setAR3DLayerLocalPosition(ar3dlayerName, localPosition)
}

/**
 * 修改小组件的标题
 * @param layerName {@link  ARLayerType[AR_WIDGET_LAYER]} 图层名
 * @param id 要修改的小组件的id
 * @param title 要修改的标题
 */
export function setARWidgetTitle(layerName: string, id: number, title:string): Promise<boolean>{
  return SARMap.setARWidgetTitle(layerName, id, title)
}

/** 相册小组件风格 */
interface NodeStyle extends Omit<WidgetTextStyle, 'TextFlags'> {
  Flags: number
  ButtonTextSize: number
  /** 标题字体颜色 */
  TextColor: string
  LineColor: string
  TimeColor: string
  /** Node排列方式 */
  Array: number
  /** 填充颜色，背景色 */
  fillColor: string
  /** 透明度 0-1 */
  opacity: number
   /** 边框颜色 */
  borderColor: number
  /** 边框宽度  单位：米*/
  borderWidth: number
  /** 标题字体透明度 */
  TextOpacity: number
}

/** 相册小组件字体风格 */
interface WidgetTextStyle {
  TextShadow: number
  TextBold: number
  TextFlags: number
  /** 标题字体大小 */
  TextSize: number
  /** 标题字体旋转角度 */
  TextRotation: number
}


/**
 * 修改相册小组件风格
 * @param style 要设置的风格，一次只能设置一个
 * @param widget 要修改的对象
 */
export function setNodeStyle(style: Partial<NodeStyle>, widget: ARElement): Promise<boolean>{
  return SARMap.setNodeStyle(style, widget)
}

/**
 * 获取小组件字体相关风格
 * @param params 小组件对象
 * @returns 小组件字体相关风格
 */
export function getNodeStyle(widget: ARElement): Promise<WidgetTextStyle | undefined | null>{
  return SARMap.getNodeStyle(widget)
}

export type ARWidgetStyle = ARBarChartStyle
                          | ARPieChartStyle
                          | NodeStyle

/** 柱状图风格 */
interface ARBarChartStyle {
  TextColor: string
  TextOpacity: number
  opacity: number
  fillColor: string
  TextSize: number
}

/** 饼图风格 */
interface ARPieChartStyle {
  TextColor: string
  TextOpacity: number
  fillColor: string
  TextSize: number
}

/** 其他风格 */
interface NodeStyle {
  TextSize: number
  TextRotation: number
  ButtonTextSize: number
  TextOpacity: number
  opacity: number
  borderWidth: number
}

/**
 * 获取小组件当前显示的风格
 * @param params 小组件对象
 * @returns 对应小组件当前显示的风格
 */
export function getCurrentNodeStyle(params: ARElement): Promise<ARWidgetStyle | undefined | null>{
  return SARMap.getCurrentNodeStyle(params)
}



// ************************************
// Animation 对象设置动画
// ************************************

/**
 * 添加动画到resource
 * @param param 动画参数
 * @returns 成功返回 resourceID，失败返回 -1
 * @platform android
 */
export async function addAnimation(param: ARModelAnimatorParameter | ARNodeAnimatorParameter): Promise<number> {
  if(Platform.OS !== 'android') return -1
  return await SARMap.addAnimation(param)
}

/**
 * 从resource中移除动画
 * @param id 动画的resourceID
 */
export async function removeAnimation(id: number): Promise<boolean> {
  return await SARMap.removeAnimation(id)
}

/**
 * 编辑动画
 * @param id 动画的resourceID
 * @param param 动画参数
 * @platform android
 */
export async function editAnimation(id: number, param: ARModelAnimatorParameter | ARNodeAnimatorParameter): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.editAnimation(id, param)
}

/**
 * 获取AR地图资源中所有的动画
 * @returns 所有动画参数
 * @platform android
 */
export async function getAnimations(): Promise<((ARModelAnimatorParameter & {id: number}) | (ARNodeAnimatorParameter & {id: number}))[]> {
  if(Platform.OS !== 'android') return []
  return await SARMap.getAnimations()
}

/**
 * 设置动画到AR对象
 * @param layerName AR对象所在图层
 * @param elementID AR对象id
 * @param animationID 动画的resourceID
 */
export async function setAnimation(layerName: string, elementID: number, animationID: number): Promise<boolean> {
  if(Platform.OS !== 'android') return false
  return await SARMap.setAnimation(layerName, elementID, animationID)
}

/**
 * 移除AR对象的动画
 * @param layerName AR对象所在图层
 * @param elementID AR对象id
 */
export function clearAnimation(layerName: string, elementID: number): Promise<boolean> {
  return SARMap.clearAnimation(layerName, elementID)
}

/** glb模型中的动画 */
export interface ModelAnimation {
  /** 动画id */
  id: number
  /** 动画名 */
  name: string
  /** 动画持续时间 */
  duration: number
}

/**
 * 获取模型自带动画列表
 * @param layerName 模型所在图层
 * @param modelID 模型对象id
 * @returns 模型中的动画列表
 */
export function getModelAnimation(layerName: string, modelID: number): Promise<ModelAnimation[]> {
  return SARMap.getModelAnimation(layerName, modelID)
}


/**
 * 添加模型动画到resource
 * 成功返回 resourceID
 * 失败返回 -1
 * @deprecated 使用 {@link addAnimation}
 * @platform ios
 */
export function addNodeAnimation(params: IAnimationParam): Promise<number> {
  return SARMap.addNodeAnimation(params)
}

/**
 * 重命名动画
 * @platform ios
 * @deprecated 使用 {@link editAnimation} 修改
*/
export async function renameAnimation(id: number, name: string): Promise<boolean> {
  return await SARMap.renameAnimation(id, name)
}

/**
 * 获取当前地图的动画列表
 * @deprecated 使用 {@link getAnimations}
 * @platform ios
*/
export function getAnimationList(): Promise<{id: number, name: string, type: 'rotation' | 'translation'}[]> {
  return SARMap.getAnimationList()
}
/**
 * 设置模型动画
 * @param animationID 动画id, -1 为取消动画
 * @deprecated 使用 {@link setAnimation}
 *