imobile_for_reactnative
Version:
iMobile for ReactNative，是SuperMap iMobile推出的一款基于React-Native框架的移动应用开发工具。基于该开发工具，用户可以使用JavaScript开发语言，开发出在Android和IOS操作系统下运行的原生移动GIS应用，入门门槛低，一次开发，处处运行。
2,073 lines (1,872 loc) • 77 kB
text/typescript
/*********************************************************************************
Copyright © SuperMap. All rights reserved.
Author: xiezhy
E-mail: xiezhiyan@supermap.com
Description:
/** 地图模块，负责地图显示环境的管理。
地图是对地理数据的可视化，通常由一个或多个图层组成。一个地图对象通常通过其图层集合对象 Layers 来管理其中的所有图层，
*/
import { NativeModules, NativeEventEmitter, Platform, EmitterSubscription } from 'react-native'
import { EventConst } from '../../constains/index'
import { DatasetCreateInfo, DatasetInfo, DatasetType, DatasourceConnectionInfo, EngineType, FieldInfo, FieldInfoValue, FieldType, GeoLine, Geometry, GeometryInfo, GeoPoint, GeoRegion, GeoTextStyle, LongitudeAndLatitude, Point2D, Rectangle2D, TDatasetType, TGeometryType } from '../data/SData'
import { AppInfo, SData } from '../../..'
import GeoStyle from 'imobile_for_reactnative/NativeModule/GeoStyle'
import FileTools from 'imobile_for_reactnative/NativeModule/utility/FileTools'
import { TThemeType } from './STheme'
import { MediaData } from '../collector/SMediaCollector'
const SMap = NativeModules.SMap
const LayerManager = NativeModules.SLayerManager
const SCartography = NativeModules.SCartography
const nativeEvt = new NativeEventEmitter(SMap)
/** 渐变模式类型常量 */
export interface FillGradientMode {
/**
* 无渐变。
* 当使用普通填充模式时，设置渐变模式为无渐变。
*/
FGM_NONE: 0,
/**
* 线性渐变。
* 从水平线段的起始点到终止点的渐变
*/
FGM_LINEAR: 1,
/**
* 辐射渐变。
* 以填充区域范围的中心点作为渐变填充的起始点，距离中心点最远的边界点作为终止点的圆形渐变。注意在同一个圆周上颜色不发生变化，不同的圆之间颜色发生渐变。
*/
FGM_RADIAL: 2,
/**
* 圆锥渐变。
* 从起始母线到终止母线，渐变在逆时针和顺时针两个方向发生渐变，都是从起始色渐变到终止色。注意填充区域范围中心点为圆锥的顶点，在圆锥的母线上颜色不发生变化。
*/
FGM_CONICAL: 3,
/**
* 四角渐变。
* 以填充区域范围的中心点作为渐变填充的起始点，以填充区域范围的最小外接矩形的较短边的中点为终止点的正方形渐变。注意在每个正方形上的颜色不发生变化, 不同的正方形之间颜色发生变化。
*/
FGM_SQUARE: 4,
}
export type TFillGradientMode = FillGradientMode[keyof FillGradientMode]
/** 图层样式 */
export interface LayerStyle {
/**
* 设置填充背景色
* @param r 范围为0-255
* @param g 范围为0-255
* @param b 范围为0-255
*/
FillBackColor: {r:number,g:number,b:number},
/** 设置当前填充背景是否不透明 */
FillBackOpaque: boolean,
/**
* 设置填充符号的前景色。当填充模式为渐变填充时，该颜色为渐变填充起始颜色
* @param r 范围为0-255
* @param r 范围为0-255
* @param b 范围为0-255
*/
FillForeColor: {r:number,g:number,b:number},
/**
* 设置渐变填充的旋转角度，以度为单位，精确到0.1度，逆时针方向为正方向。有关各渐变填充风格类型的定义.
* 对于不同的渐变填充，其旋转的后的效果各异，但都是以最小外接矩形的中心为旋转中心，逆时针旋转的。具体请参见 getFillGradientAngle() 方法。
*/
FillGradientAngle: number,
/**
* 设置渐变填充中心点相对于填充区域范围中心点的水平偏移百分比。
* 设填充区域范围中心点的坐标为（x0,y0），填充中心点的坐标为（x，y），填充区域范围的宽度为 a，水平偏移百分比为 dx，则x=x0 + a*dx/100
* 该百分比可以为负，当其为负时，填充中心点相对于填充区域范围中心点向 x 轴负方向偏移。该方法对辐射渐变、圆锥渐变、四角渐变和线性渐变填充有效。
*/
FillGradientOffsetRatioX: number,
/**
* 设置填充中心点相对于填充区域范围中心点的垂直偏移百分比。
* 设填充区域范围中心点的坐标为（x0,y0），填充中心点的坐标为（x，y），填充区域范围的高度为 b，垂直偏移百分比为 dy，则y=y0 + b*dy/100
* 该百分比可以为负，当其为负时，填充中心点相对于填充区域范围中心点向 y 轴负方向偏移。该方法对辐射渐变、圆锥渐变、四角渐变和线性渐变填充有效。
*/
FillGradientOffsetRatioY: number,
/**
* 设置渐变填充风格的渐变类型。
* 关于各渐变填充类型的定义，请参见 <FillGradientMode> 。
*/
FillGradientMode: TFillGradientMode,
/**
* 设置填充不透明度，合法值0-100的数值。
* 其值为0表示空填充；若其值为100表示完全不透明。赋值小于0时按照0处理，大于100时按照100处理。
*/
FillOpaqueRate: number,
/**
* 设置填充符号的编码。此编码用于唯一标识各普通填充风格的填充符号。
* 填充符号可以用户自定义，也可以使用系统自带的符号库。
*/
FillSymbolID: number,
/**设置线状符号型风格或点状符号的颜色。*/
LineColor: {r:number,g:number,b:number},
/**
* 设置线状符号的编码。此编码用于唯一标识各线状符号。
* 线状符号可以用户自定义，也可以使用系统自带的符号库。使用系统自带符号库时，其相应的的编码参见开发指南 SuperMap Objects 资源库一览。
*/
LineSymbolID: number,
/** 设置线状符号的宽度。单位为毫米，精度到0.1。*/
LineWidth: number,
/** 设置点状符号的旋转角度，以度为单位，精确到0.1度，逆时针方向为正方向。此角度可以作为普通填充风格中填充符号的旋转角度。*/
MarkerAngle: number,
/** 设置点状符号的大小，单位为毫米，精确到0.1毫米。其值必须大于等于0。如果为0，则表示不显示，如果是小于0，会抛出异常。*/
MarkerSize: {
width: number,
height: number,
},
/**
* 设置点状符号的编码。此编码用于唯一标识各点状符号。
* 点状符号可以用户自定义，也可以使用系统自带的符号库。
*/
MarkerSymbolID: number,
}
/** 栅格图层样式 */
export interface LayerGridStyle {
/** 图层显示的不透明度.不透明度为一个0-100之间的数值，0为透明，100为完全不透明。只对栅格图层有效 */
OpaqueRate: number,
/** 栅格图层的亮度，值域范围-100到100，增加亮度为正，降低亮度为负 */
Brightness: number,
/** 栅格图层的对比度，值域范围-100到100，增加对比度为正，降低对比度为负 */
Contrast: number,
/** 格图层当前指定的特殊值 */
SpecialValue: number,
/** 栅格图层当前指定特殊值对应的像元要显示颜色 */
SpecialValueColor: { r: number, g: number, b: number },
}
/**
* 图层信息类
*/
export interface LayerInfo {
/** 图层名 */
name?: string;
/** 图层标题 */
caption?: string;
/** 图层描述 */
description?: string;
/** 图层是否可编辑 */
isEditable?: boolean;
/** 图层是否可见 */
isVisible?: boolean;
/** 图层是否可选择 */
isSelectable?: boolean;
/** 图层是否可捕捉 */
isSnapable?: boolean;
/** 图层组名 */
groupName?: string;
/** 图层专题类型 */
themeType?: 0 | TThemeType;
/** 图层路径 */
path?: string;
/** 是否是热力图 */
isHeatmap?: boolean;
/** 热力图相关属性 */
layerHeatmap?: {
kernelRadius: number;
maxValue: number;
minValue: number;
fuzzyDegree: number;
intensity: number;
weightField: string;
gradientColorType: number;
};
/** 图层关联数据集类型 */
type?: TDatasetType | 'layerGroup';
/** 图层对应的数据集名 */
datasetName?: string;
/** 图层对应的数据集描述 */
datasetDescription?: string;
/** 图层对应数据集所在数据源的别名 */
datasourceAlias?: string;
/** 图层对应数据集所在数据源Server */
datasourceServer?: string;
/** 用于图层裁剪，裁剪的面几何对象数。*/
IsClipInRegion?: boolean;
/** 用于图层裁剪，是否擦除*/
IsErase?: boolean;
/** 用于图层裁剪，是否区域外裁剪*/
IsExactClip?: boolean;
/** 图层组的子图层集合 */
child?: Array<LayerInfo>;
}
interface IAction {
/**
* 空操作
*/
NONEACTION: 0
/**
* 地图漫游。在对地图进行漫游操作时，首先将显示窗口内的地图转换成位图，在操作过程中，使用位图显示，操作结束后，使用真实数据显示。这种漫游速度较快。
*/
PAN: 1
/**
* 在编辑模式下，长按选择对象，可对选中的对象进行编辑。
*/
SELECT: 8
/**
* 在可编辑图层中画点。
*/
CREATEPOINT: 16
/**
* 在可编辑图层中画折线。
*/
CREATEPOLYLINE: 17
/**
* 在可编辑图层中画多边形。
*/
CREATEPOLYGON: 27
/**
* 编辑对象的节点
*/
VERTEXEDIT: 54
/**
* 可编辑图层中添加节点
*/
VERTEXADD: 55
/**
* 可编辑图层中删除节点
*/
VERTEXDELETE: 56
/**
* 绘制线
*/
DRAWLINE: 100
/**
* 绘制面
*/
DRAWPLOYGON: 101
/**
* 自由绘制线
*/
FREEDRAW: 199
/**
* 擦除面对象
*/
ERASE_REGION: 201
/**
* 使用线切分
*/
SPLIT_BY_LINE: 202
/**
* 合并面对象
*/
UNION_REGION: 203
/**
* 组合面对象
*/
COMPOSE_REGION: 204
/**
* 切分岛洞对象(补充岛洞)
*/
PATCH_HOLLOW_REGION: 205
/**
* 求交面对象
*/
INTERSECT_REGION: 206
/**
* 填充岛洞对象
*/
FILL_HOLLOW_REGION: 207
/**
* 多对象补洞
*/
PATCH_POSOTIONAL_REGION: 208
/**
* 公共点编辑(协调编辑)
*/
MOVE_COMMON_NODE: 209
/**
* 公共边构面
*/
CREATE_POSITIONAL_REGION: 210
/**
* 手绘岛洞对象,原有对象上画面,生成一个岛洞对象,一个画面对象,一个原有对象
*/
DRAW_HOLLOW_REGION: 213
/**
* 平移对象
*/
MOVE_GEOMETRY: 301
/**
* 框选
*/
SELECT_BY_RECTANGLE: 302
/**
* 多选
*/
MULTI_SELECT: 305
/**
* 量算长度
*/
MEASURELENGTH: 1001
/**
* 量算面积
*/
MEASUREAREA: 1002
/**
* 量算角度
*/
MEASUREANGLE: 1003
/**
* 态势标绘
*/
CREATEPLOT: 3000
/**
* 面被线分割（手绘式）
*/
SPLIT_BY_DRAWLINE: 215
/**
* 手绘岛洞面（手绘式）
*/
DRAWREGION_HOLLOW_REGION: 216
/**
* 面被面擦除(手绘式)
*/
DRAWREGION_ERASE_REGION: 217
/**
* 面被面分割(手绘式)
*/
SPLIT_BY_DRAWREGION: 218
/**
* 卷帘状态
*/
SWIPE: 501
}
export type TAction = IAction[keyof IAction]
export const Action: IAction = NativeModules.JSAction
/** 地图颜色模式 */
interface IMapColorMode {
/** 默认色彩模式 */
DEFAULT: 0
/** 黑白模式 */
BLACKWHITE: 1
/** 灰度模式 */
GRAY: 2
/** 黑白反色模式 */
BLACK_WHITE_REVERSE: 3
/** 黑白反色，其他颜色不变 */
ONLY_BLACK_WHITE_REVERSE: 4
}
/** 专题图类型 */
export type TMapColorMode = IMapColorMode[keyof IMapColorMode]
export const MapColorMode: IMapColorMode = NativeModules.JSMapColorMode
/** AI配图颜色模式*/
export interface IFixColorMode {
/** 地图线对象色调 */
FCM_LH: 0,
/** 地图面对象色调 */
FCM_FH: 1,
/** 地图面轮廓对象色调 */
FCM_BH: 2,
/** 地图文本对象色调 */
FCM_TH: 3,
/** 地图线对象饱和度 */
FCM_LS: 4,
/** 地图面对象饱和度 */
FCM_FS: 5,
/** 地图面轮廓对象饱和度 */
FCM_BS: 6,
/** 地图文本对象饱和度 */
FCM_TS: 7,
/** 地图线对象亮度 */
FCM_LB: 8,
/** 地图面对象亮度 */
FCM_FB: 9,
/** 地图面轮廓对象亮度 */
FCM_BB: 10,
/** 地图文本对象亮度 */
FCM_TB: 11,
}
export type TFixColorMode = IFixColorMode[keyof IFixColorMode]
export const FixColorMode: IFixColorMode = NativeModules.FixColorMode
/** 地图上绘制临时对象样式 */
export interface MapConstrolStyle {
/** 绘制对象画笔宽度。 */
strokeWidth?: number,
/** 绘制对象画笔颜色。 */
strokeColor?: { r: number, g: number, b: number, a: number },
/** 绘制对象填充颜色*/
strokeFillColor?: { r: number, g: number, b: number, a: number },
/** 绘制对象节点大小 */
nodeSize?: number,
/** 绘制对象节点节点颜色 */
nodeColor?: { r: number, g: number, b: number, a: number },
/** 绘制对象节点几何风格 */
// nodeStyle?:string
}
/** 投影坐标系转换参数类 */
export interface CoordSysTransParameter {
/**
* @brief 获取或设置 X 轴的坐标偏移量。单位为米。
* <p> 默认值为 0。
* @return X 轴的坐标偏移量。
*/
translateX: number
/**
* @brief 获取或设置 Y 轴的坐标偏移量。单位为米。
* <p> 默认值为 0。
* @return Y 轴的坐标偏移量。
*/
translateY: number
/**
* @brief 获取或设置 Z 轴的坐标偏移量。单位为米。
* <p> 默认值为 0。
* @return Z 轴的坐标偏移量。
*/
translateZ: number
/**
*@brief 获取或设置 X 轴的旋转角度。用于不同大地参照系之间的转换。单位为弧度。
* <p> 默认值为 0。
* @return X 轴的旋转角度。
*/
rotateX: number
/**
* @brief 获取或设置 Y 轴的旋转角度。用于不同大地参照系之间的转换。单位为弧度。
* <p> 默认值为 0。
*@return Y 轴的旋转角度。
*/
rotateY: number
/**
* @brief 获取或设置 Z 轴的旋转角度。用于不同大地参照系之间的转换。单位为弧度。
* <p> 默认值为 0。
*@return Z 轴的旋转角度。
*/
rotateZ: number
/**
* @brief 获取或设置投影比例尺差。单位为百万分之一。用于不同大地参照系之间的转换。
* <p> 默认值为 0。
* @return 投影比例尺差。
*/
scaleDifference: number
}
/* ------------------------------------------------------地图回调相关接口-----------------------------------------------------------*/
let mapScaleChangeDelegate: EmitterSubscription | null | undefined
let mapBoundsChangeDelegate: EmitterSubscription | null | undefined
/**
* 设置地图参数变化监听
* @param handler 接收比例尺变化与中心点变化事件，设置null移除回调
*/
export function setMapParameterChangedListener(handler: {
scaleChanged?: (result: { scale: number }) => void,
boundsChanged?: (mapCenter: { x: number, y: number }) => void
} | null): void {
mapScaleChangeDelegate?.remove()
mapBoundsChangeDelegate?.remove()
mapScaleChangeDelegate = null
mapBoundsChangeDelegate = null
mapBoundsChangeDelegate = handler?.boundsChanged && nativeEvt.addListener(EventConst.MAP_BOUNDS_CHANGED, handler.boundsChanged)
mapScaleChangeDelegate = handler?.scaleChanged && nativeEvt.addListener(EventConst.MAP_SCALEVIEW_CHANGE, handler.scaleChanged)
}
let floorHiddenListener: EmitterSubscription | null | undefined
/**
* 设置楼层显隐监听
* @param handler 楼层控件变化事件，设置null移除回调
* @returns
*/
export function setFloorHiddenListener(handler: ((result: { currentFloorID: number }) => void) | null): void {
floorHiddenListener?.remove()
floorHiddenListener = null
floorHiddenListener = handler && nativeEvt.addListener(EventConst.IS_FLOOR_HIDDEN, handler)
}
let mapGeometryChangeListener: EmitterSubscription | null | undefined
/**
* 添加地图几何对象变化监听
* @param handler 图几何对象变化事件，设置null移除回调
* @returns { layerInfo: LayerInfo, geoID: number, type: 1|2|3 } 1:添加对象 2:编辑对象 3:删除对象
*/
export function setMapGeometryChangeListener(handler?: {
mapGeometryChange?: (result: { layerInfo: LayerInfo, geoID: number, type: 1 | 2 | 3 }) => void
} | null): void {
mapGeometryChangeListener?.remove()
mapGeometryChangeListener = null
mapGeometryChangeListener = handler?.mapGeometryChange && nativeEvt.addListener(EventConst.MAP_GEOMETRY_CHANGE, handler.mapGeometryChange)
}
let LegendListener: EmitterSubscription | null | undefined
/**
* 添加图例的监听事件，会返回相应的图例数据
* @param handler 接收图例变化事件，设置null移除回调
* @returns
*/
export function setLegendListener(handler?: {
legendContentChange?: (result: { image: string, title: string, type: string }) => void
} | null): void {
LegendListener?.remove()
LegendListener = null
LegendListener = handler?.legendContentChange && nativeEvt.addListener(EventConst.MAP_LEGEND_CONTENT_CHANGE, handler.legendContentChange)
}
let longPressDetector: EmitterSubscription | null | undefined
let singleTapDetector: EmitterSubscription | null | undefined
let doubleTapDetector: EmitterSubscription | null | undefined
let magnDetector: EmitterSubscription | null | undefined
/**
* 手势监听
* @param handler 接收地图手势变化事件，设置null移除回调
*/
export function setGestureDetector(handlers?: {
singleTapHandler?: () => void,
longPressHandler?: (res: { mapPoint: Point2D, screenPoint: Point2D, LLPoint: Point2D }) => void,
doubleTapHandler?: (res: { mapPoint: Point2D, screenPoint: Point2D, LLPoint: Point2D }) => void,
magnPressHandler?: (res: { mapPoint: Point2D, screenPoint: Point2D, LLPoint: Point2D }) => void,
} | null): void {
longPressDetector?.remove()
doubleTapDetector?.remove()
singleTapDetector?.remove()
magnDetector?.remove()
longPressDetector = doubleTapDetector = singleTapDetector = magnDetector = null
longPressDetector = handlers?.longPressHandler && nativeEvt.addListener(EventConst.MAP_LONG_PRESS, handlers.longPressHandler)
doubleTapDetector = handlers?.doubleTapHandler && nativeEvt.addListener(EventConst.MAP_DOUBLE_TAP, handlers.doubleTapHandler)
magnDetector = handlers?.magnPressHandler && nativeEvt.addListener(EventConst.MAP_LONG_PRESS_MAGN, handlers.magnPressHandler)
singleTapDetector = handlers?.singleTapHandler && nativeEvt.addListener(EventConst.MAP_SINGLE_TAP, handlers.singleTapHandler)
}
let geometrySelectedListener: EmitterSubscription | null | undefined
let geometryMultiSelectedListener: EmitterSubscription | null | undefined
/**
* 添加对象修改前监听器
* @param handler 接收对象选中事件，设置null移除回调
* @returns
*/
export const setGeometrySelectedListener = (handler: {
geometrySelected?: (res: { id: number, geometryType: TGeometryType, layerInfo: LayerInfo, fieldInfo: FieldInfoValue[] }) => void,
geometryMultiSelected?: (res: Array<{ id: number, geometryType: TGeometryType, layerInfo: LayerInfo }>) => void,
} | null) => {
geometrySelectedListener?.remove()
geometryMultiSelectedListener?.remove()
geometrySelectedListener = null
geometryMultiSelectedListener = null
geometrySelectedListener = handler?.geometrySelected && nativeEvt.addListener(EventConst.MAP_GEOMETRY_SELECTED, handler.geometrySelected)
geometryMultiSelectedListener = handler?.geometryMultiSelected && nativeEvt.addListener(EventConst.MAP_GEOMETRY_MULTI_SELECTED, handler.geometryMultiSelected)
}
let lengthMeasuredEmitter: EmitterSubscription | null | undefined
let areaMeasuredEmitter: EmitterSubscription | null | undefined
let angleMeasuredEmitter: EmitterSubscription | null | undefined
/**
* 添加地图量算的监听事件，会返回相应的量算数据【lengthMeasured,areaMeasured,angleMeasured为互斥事件，同时设置只有一个有效】
* @param handler 接收量算变化事件，设置null移除回调;
* @returns
*/
export function setMeasureListener(handler: {
lengthMeasured?: (res: { curResult: number, curPoint: Point2D, isUndoOrRedo: boolean }) => void,
areaMeasured?: (res: { curResult: number, curPoint: Point2D, isUndoOrRedo: boolean }) => void,
angleMeasured?: (res: { curAngle: number, curPoint: Point2D, isUndoOrRedo: boolean }) => void
} | null): void {
lengthMeasuredEmitter?.remove()
areaMeasuredEmitter?.remove()
angleMeasuredEmitter?.remove()
lengthMeasuredEmitter = areaMeasuredEmitter = angleMeasuredEmitter = null
if (handler?.lengthMeasured) {
SMap.setAction(Action.MEASURELENGTH)
lengthMeasuredEmitter = nativeEvt.addListener(EventConst.MEASURE_LENGTH, handler.lengthMeasured)
} else if (handler?.areaMeasured) {
SMap.setAction(Action.MEASUREAREA)
areaMeasuredEmitter = nativeEvt.addListener(EventConst.MEASURE_AREA, handler?.areaMeasured)
} else if (handler?.angleMeasured) {
SMap.setAction(Action.MEASUREANGLE)
angleMeasuredEmitter = nativeEvt.addListener(EventConst.MEASURE_ANGLE, handler?.angleMeasured)
}
}
/* ------------------------------------------------------地图相关接口-----------------------------------------------------------*/
/**
* 从工作空间打开本地地图
* @param strMapName 地图名
* @returns 地图打开成功返回true，否则返回false
*/
export function openMapName(strMapName: string): Promise<boolean> {
const res = SMap.openMapName(strMapName)
bEnableRotateTouch = false
bEnableSlantTouch = false
SMap.enableRotateTouch(false)
SMap.enableSlantTouch(false)
SMap.setMapAngle(0)
SMap.setMapSlantAngle(0)
return res
}
/**
* 以指定数据集打开地图，将指定数据集添加到地图显示
* @param params 数据源信息类
* @param value 数据集名称或索引
* @returns 打开成功返回true，否则返回false
*/
export function openMapWithDatasource(params: DatasourceConnectionInfo, value: string | number): Promise<string> {
let datasourceAlias
if (typeof value === 'number') {
datasourceAlias = SMap.openMapWithDatasourceByIndex(params, value)
} else {
datasourceAlias = SMap.openMapWithDatasourceByName(params, value)
}
bEnableRotateTouch = false
bEnableSlantTouch = false
SMap.enableRotateTouch(false)
SMap.enableSlantTouch(false)
SMap.setMapAngle(0)
SMap.setMapSlantAngle(0)
return datasourceAlias
}
/**
* 保存地图到工作空间（持久化）
* @param strMapAlians 保存的地图名称，可为空
* @returns 保存成功返回true，否则返回false
*/
export function saveMapToWorkspace(strMapAlians = ''): Promise<string> {
return SMap.saveMapToWorkspace(strMapAlians)
}
/**
* 保存地图(临时保存并未持久化)
* @returns 保存成功返回true，否则返回false
*/
export function saveMap(): Promise<boolean> {
return SMap.saveMap()
}
/**
* 关闭地图，同时关闭地图对应数据源
* @returns 关闭成功返回true，否则返回false
*/
export function exitMap(): Promise<boolean> {
return SMap.exitMap()
}
/**
* 返回此地图对象的XML字符串形式的描述
* @returns 地图的XML形式的描述
*/
export function mapToXml(): Promise<string> {
return SMap.mapToXml()
}
/**
* 将地图对象的XML字符串转为地图
* @param xml 地图对象的XML字符串
*/
export function mapFromXml(xml: string) {
return SMap.mapFromXml(xml)
}
/**
*以给定的二维点数组确定区域进行裁剪，给定的点数据必须可构成面，否则裁剪无效。【支持矢量和本地删格数据集】
* @param points 以该参数确定裁剪区域，点类型为地图点
* @param layersInfo 指定参与裁剪的图层（图层可以不参加裁剪，不参加裁剪即结果数据集中，该layer.dataset不变。但同一数据集的layer裁减参数一致，以第一个layer参数为准。
* @param mapName 裁剪结果保存的地图名
* @returns 裁剪成功返回true，否则返回false
*/
export function clipMap(points: Point2D[], layersInfo: LayerInfo[], mapName: string): Promise<boolean> {
return SMap.clipMap(points, layersInfo, mapName)
}
/**
* 获取工作空间中地图列表
* @returns {<Array<{title:string}>}
* @deprecated
*/
export function getMaps(): Promise<Array<{ title: string }>> {
return SMap.getMaps()
}
/**
* 返回一个布尔值指定当前地图是否被修改了
* @returns 地图被修改返回true，否则返回false
*/
export function isModified(): Promise<boolean> {
return SMap.isModified()
}
/**
* 设置地图控件中地图的当前操作状态。在 Action 类中定义了目前支持的所有的对地图的操作模式。
* @param actionType 地图操作状态
*/
export function setAction(actionType: TAction) {
return SMap.setAction(actionType)
}
/**
* 获取地图控件中地图的当前操作状态
* @returns 地图的当前操作状态
*/
export function getAction(): Promise<TAction> {
return SMap.getAction()
}
/**
* 将地图放大或缩小指定的比例。
* @description 缩放之后地图的比例尺=原比例尺 *scale，其中 scale 必须为正数，当 scale 大于1时地图被放大；当 scale 小于1时，地图被缩小。
* @param scale 缩放地图比例
* @returns 缩放成功返回true，否则返回false
*/
export function zoom(scale = 2): Promise<boolean> {
return SMap.zoom(scale)
}
let bShowLocation = true
/**
* 返回地图定位图标是否显示
*/
export function isShowLocation() {
return bShowLocation
}
/**
* 设置是否显示地图定位图标
* @param enable 布尔值，true为显示定位图标，false为不显示定位图标
*/
export function setShowLocation(enable: boolean) {
bShowLocation = enable
return SMap.setShowLocation(enable)
}
let bEnableRotateTouch = false
/**
* 返回地图手势旋转是否可用
*/
export function isEnableRotateTouch(): boolean {
return bEnableRotateTouch
}
/**
* 设置地图手势旋转是否可用
* @param enable 布尔值，true为开启地图手势旋转，false为关闭地图手势旋转
* @returns 设置成功返回true，否则返回false
*/
export function enableRotateTouch(enable: boolean): Promise<boolean> {
bEnableRotateTouch = enable
return SMap.enableRotateTouch(enable)
}
let bEnableSlantTouch = false
/**
* 返回地图手势俯仰是否可用
*/
export function isEnableSlantTouch(): boolean {
return bEnableSlantTouch
}
/**
* 设置地图手势俯仰是否可用
* @param enable 布尔值，true为开启地图手势俯仰，false为关闭地图手势俯仰
* @returns 设置成功返回true，否则返回false
*/
export function enableSlantTouch(enable: boolean): Promise<boolean> {
bEnableSlantTouch = enable
return SMap.enableSlantTouch(enable)
}
/**
* 获取当前打开的地图名称
* @returns 地图名称
*/
export function getMapName(): Promise<string> {
return SMap.getMapName()
}
/**
* 设置一个布尔值指定是否反走样地图。文本、线型被设置为反走样后，可以去除一些显示锯齿，使显示更加美观
* @param value 一个布尔值，用于指定是否反走样地图
* @returns 设置成功返回true，否则返回false
*/
export function setAntialias(value: boolean): Promise<boolean> {
return SMap.setAntialias(value)
}
/**
* 返回一个布尔值指定是否反走样地图
*/
export function isAntialias(): Promise<boolean> {
return SMap.isAntialias()
}
/**
* 设置是否使用固定比例尺来显示地图
* @param value 布尔值，true为使用固定比例尺来显示地图，false为不使用固定比例尺来显示地图
* @returns 设置成功返回true，否则返回false
*/
export function setVisibleScalesEnabled(value: boolean): Promise<boolean> {
return SMap.setVisibleScalesEnabled(value)
}
/**
* 返回是否固定比例尺显示地图
*/
export function isVisibleScalesEnabled(): Promise<boolean> {
return SMap.isVisibleScalesEnabled()
}
/**
* 获取是否显示压盖对象
*/
export function isOverlapDisplayed(): Promise<boolean> {
return SMap.isOverlapDisplayed()
}
/**
* 设置是否显示压盖对象（用于关闭／开启文字和点图层的自动避让）
* @param value 布尔值，true为显示压盖对象，false为不显示压盖对象
* @returns 设置成功返回true，否则返回false
*/
export function setOverlapDisplayed(value: boolean): Promise<boolean> {
return SMap.setOverlapDisplayed(value)
}
/**
* 获取当前地图的旋转角度。单位为度，精度到 0.1 度。逆时针方向为正方向
* @returns 当前地图的旋转角度
*/
export function getMapAngle(): Promise<number> {
return SMap.getMapAngle()
}
/**
* 设置当前地图的旋转角度
* @param value 单位为度，精度到 0.1 度。逆时针方向为正方向
* @returns 设置成功返回true，否则返回false
*/
export function setMapAngle(value: number): Promise<boolean> {
return SMap.setMapAngle(value)
}
/**
* 获取当前地图颜色模式，颜色模式有："默认色彩模式","黑白模式","灰度模式","黑白反色模式","黑白反色，其他颜色不变"
* @returns 当前地图颜色模式
*/
export function getMapColorMode(): Promise<TMapColorMode> {
return SMap.getMapColorMode()
}
/**
* 设置当前地图颜色模式，颜色模式有："默认色彩模式","黑白模式","灰度模式","黑白反色模式","黑白反色，其他颜色不变"
* @param value 地图颜色模式
* @returns 设置成功返回true，否则返回false
*/
export function setMapColorMode(value: TMapColorMode): Promise<boolean> {
return SMap.setMapColorMode(value)
}
/**
* 获取地图背景色，返回rgb值，未正确获取返回空
* @returns 地图背景色rgb值或空
*/
export async function getMapBackgroundColor(): Promise<{ r: number, g: number, b: number } | undefined> {
const hexColor = await SMap.getMapBackgroundColor()
return _translate16ToRgb(hexColor)
}
/**
* 设置地图背景色
* @param r 背景色r值
* @param g 背景色g值
* @param b 背景色b值
* @returns 设置成功返回true，否则返回false
*/
export function setMapBackgroundColor(r: number, g: number, b: number): Promise<boolean> {
return SMap.setMapBackgroundColor(r, g, b)
}
/**
* 设置是否固定文本角度
* @param value 是否固定文本角度
* @returns 设置成功返回true，否则返回false
*/
export function setTextFixedAngle(value: boolean): Promise<boolean> {
return SMap.setTextFixedAngle(value)
}
/**
* 获取是否固定文本角度
* @returns 布尔值，true为固定文本角度显示，false为不固定文本角度显示
*/
export function getTextFixedAngle(): Promise<boolean> {
return SMap.getTextFixedAngle()
}
/**
* 设置是否固定符号角度
* @param value 布尔值，true为固定符号角度显示，false为不固定符号角度显示
* @returns 设置成功返回true，否则返回false
*/
export function setMarkerFixedAngle(value: boolean): Promise<boolean> {
return SMap.setMarkerFixedAngle(value)
}
/**
* 获取是否固定符号角度
* @returns 是否固定符号角度
*/
export function getMarkerFixedAngle(): Promise<boolean> {
return SMap.getMarkerFixedAngle()
}
/**
* 获取是否固定文本方向
* @returns 是否固定文本方向
*/
export function getFixedTextOrientation(): Promise<boolean> {
return SMap.getFixedTextOrientation()
}
/**
* 设置是否固定文本方向
* @param value 布尔值，true为固定文本方向显示，false为不固定文本方向显示
* @returns 设置成功返回true，否则返回false
*/
export function setFixedTextOrientation(value: boolean): Promise<boolean> {
return SMap.setFixedTextOrientation(value)
}
/**
* 获取当前地图放大镜是否已开启
* @returns 当前地图放大镜是否已开启
*/
export function isMagnifierEnabled(): Promise<boolean> {
return SMap.isMagnifierEnabled()
}
/**
* 设置当前地图是否启用放大镜功能，默认不启动。
* @param enable 布尔值，true为启用当前地图放大镜功能，false为启用当前地图放大镜功能
* @returns 设置成功返回true，否则返回false
*/
export function setIsMagnifierEnabled(enable: boolean): Promise<boolean> {
return SMap.setIsMagnifierEnabled(enable)
}
/**
* 获取当前地图中心点
* @returns 当前地图中心点
*/
export function getMapCenter(): Promise<Point2D> {
return SMap.getMapCenter()
}
/**
* 设置当前地图中心点
* @param x 中心点x坐标
* @param y 中心点y坐标
* @returns 设置成功返回true，否则返回false
*/
export function setMapCenter(center: Point2D): Promise<boolean> {
return SMap.setMapCenter(center)
}
/**
* 获取当前地图比例尺
* @returns 地图比例尺的比值。如比例为 1:100,则返回 0.01
*/
export function getMapScale(): Promise<number> {
return SMap.getMapScale()
}
/**
* 设置当前地图比例尺
* @param value 比例的比值。如比例为 1: 100, 则 value 为 1/100 或 0.01
* @returns 设置成功返回true，否则返回false
*/
export function setMapScale(value: number): Promise<boolean> {
return SMap.setMapScale(value)
}
/**
* 设置当前地图最大比例尺
* @param value 比例的比值。如比例为 1: 100, 则 value 为 1/100 或 0.01
* @returns 设置成功返回true，否则返回false
*/
export function setMapMaxScale(value: number): Promise<boolean> {
return SMap.setMapMaxScale(value)
}
/**
* 设置当前地图最小比例尺
* @param value 比例的比值。如比例为 1: 100, 则 value 为 1/100 或 0.01
* @returns 设置成功返回true，否则返回false
*/
export function setMapMinScale(value: number): Promise<boolean> {
return SMap.setMapMinScale(value)
}
/**
* 获取地图可见范围
* @returns 当前地图的可见范围
*/
export function getMapViewBounds(): Promise<Rectangle2D|null> {
return SMap.getMapViewBounds()
}
/**
* 设置地图可见范围
* @param bounds 当前地图的可见范围
* @returns 设置成功返回true，否则返回false
*/
export function setMapViewBounds(bounds: Rectangle2D): Promise<boolean> {
return SMap.setMapViewBounds(bounds)
}
/**
* 获取当前地图坐标系XML字符串形式的描述
* @returns 当前地图坐标系XML字符串形式的描述
*/
export function getPrjCoordSys(): Promise<string> {
return SMap.getPrjCoordSys()
}
/**
* 设置当前地图地理坐标系，通过坐标系XML字符串形式的描述设置
* @param xml 地图坐标系XML字符串形式的描述
* @returns 设置成功返回true，否则返回false
*/
export function setPrjCoordSys(xml: string): Promise<boolean> {
return SMap.setPrjCoordSys(xml)
}
/**
* 获取地图动态投影时所使用的投影算法，在不同椭球体时需要设置。默认值为：MTH_GEOCENTRIC_TRANSLATION
* @returns {9603|9604|9605|9606|9607|9608}
* 9603:基于地心的三参数转换法。
* 9604:莫洛金斯基（Molodensky）转换法。
* 9605:简化的莫洛金斯基转换法。
* 9606:位置矢量法。
* 9607:基于地心的七参数转换法。
* 9608:布尔莎方法。
*/
export function getMapCoordSysTransMethod(): Promise<9603 | 9604 | 9605 | 9606 | 9607 | 9608> {
return SMap.getMapCoordSysTransMethod()
}
/**
* 设置地图动态投影时所使用的投影算法，在不同椭球体时需要设置。默认值为：MTH_GEOCENTRIC_TRANSLATION
* @param metod 动态投影时所使用的投影算法
* 9603:基于地心的三参数转换法。
* 9604:莫洛金斯基（Molodensky）转换法。
* 9605:简化的莫洛金斯基转换法。
* 9606:位置矢量法。
* 9607: 基于地心的七参数转换法。
* 9608:布尔莎方法。
* @returns 设置成功返回true，否则返回false
*/
export function setMapCoordSysTransMethod(metod: 9603 | 9604 | 9605 | 9606 | 9607 | 9608): Promise<boolean> {
return SMap.setMapCoordSysTransMethod(metod)
}
/**
* 设置地图动态投影时所使用的参数，默认7个参数全为0
* @param param 设置地图动态投影时所使用的参数
* @returns 设置成功返回true，否则返回false
*/
export function setMapCoordSysTransParameter(param: CoordSysTransParameter): Promise<boolean> {
return SMap.setMapCoordSysTransParameter(param)
}
/**
* 设置是否允许地图动态投影显示。地图动态投影显示是指如果当前地图窗口中地图的投影信息与数据源的投影信息不同，利用地图动态投影显示可以将当前地图的投影信息转换为数据源的投影信息。
* @returns 设置成功返回true，否则返回false
*/
export function setDynamicProjection(): Promise<boolean> {
return SMap.setDynamicProjection()
}
/**
* 获取当前地图动态投影是否已开启
* @returns 当前地图动态投影已开启返回true，否则返回false
*/
export function getDynamicProjection(): Promise<boolean> {
return SMap.getDynamicProjection()
}
/**
* 获取当前位置,返回经纬度坐标
* @returns 当前位置经纬度坐标对象
*/
export function getCurrentLocation(): Promise<LongitudeAndLatitude|null> {
return SMap.getCurrentLocation()
}
/**
* 将地图中心点移动到当前定位点，若定位点不在地图范围内，则移动到地图默认点
* @returns 设置成功返回true，否则返回false
*/
export function moveToCurrent(): Promise<boolean> {
return SMap.moveToCurrent()
}
/**
* 移动地图中心点到指定位置
* @param point 指定点为经纬度坐标点
* @returns 设置成功返回true，否则返回false
*/
export function moveToPoint(point: Point2D): Promise<boolean> {
return SMap.moveToPoint(point)
}
/**
* 刷新地图,地图发生变化时调用
* @returns 成功返回true，否则返回false
*/
export function refreshMap(): Promise<boolean> {
return SMap.refreshMap()
}
/**
* 全幅显示地图
* @returns 设置成功返回true，否则返回false
*/
export function viewEntire(): Promise<boolean> {
return SMap.viewEntire()
}
/**
* 提交地图编辑对象
* @returns 成功返回true，否则返回false
*/
export function submit(): Promise<boolean> {
return SMap.submit()
}
/**
* 取消地图编辑对象
* @returns 成功返回true，否则返回false
*/
export function cancel(): Promise<boolean> {
return SMap.cancel()
}
/**
* 指定当前编辑的几何对象
* @param geoID 要编辑的几何对象的ID
* @param layerName 要编辑的几何对象所属的图层名称
* @returns 设置成功返回true，否则返回false
*/
export function appointEditGeometry(geoID: number, layerName: string): Promise<boolean> {
return SMap.appointEditGeometry(geoID, layerName)
}
/**
* 获取当前编辑的几何对象
* @returns 几何对象基本信息对象，不存在时返回空
*/
export function getCurrentEditGeometry(): Promise<GeometryInfo | null | undefined> {
return SMap.getCurrentEditGeometry()
}
/**
* 在地图指定位置显示一个marker
* @param longitude 经度
* @param latitude 纬度
* @param tag 标签
* @return
* @deprecated
*/
export function showMarker(longitude: number, latitude: number, tag = 1001): Promise<boolean> {
return SMap.showMarker(longitude, latitude, tag)
}
/**
* 删除地图地图上指定marker
* @deprecated
*/
export function deleteMarker(tag = 1001): Promise<boolean> {
return SMap.deleteMarker(tag)
}
let matchPictureListener: EmitterSubscription | null
/**
* 智能配图,根据传入的图片,自动将地图风格配置为相应风格
* @param picPath 传入图片路径
* @param handler 接收配图接口监听
* @returns 配图成功返回true，否则返回false
*/
export function AIMatchPictureMap(picPath: string, handler: (res: { result: boolean, image: string, error: string }) => void): Promise<boolean> {
matchPictureListener?.remove()
matchPictureListener = nativeEvt.addListener(EventConst.MATCH_IMAGE_RESULT, handler)
return SMap.AIMatchPictureMap(picPath)
}
/**
* 设置AI配图后的风格，包括亮度、饱和度、色调的设置
* @param mode 设置类型：亮度/饱和度/色调
* @param value 设置的值，范围(-100 - 100)
* @returns 设置成功返回true，否则返回false
*/
export function setAIMapFixColorsMode(mode: TFixColorMode, value: number): Promise<boolean> {
return SMap.setAIMapFixColorsMode(mode, value)
}
/**
* 获取AI配图风格值，包括亮度/饱和度/色调
* @param mode 获取的类型：亮度/饱和度/色调
* @returns 风格值
*/
export function getAIMapFixColorsModeValue(mode: TFixColorMode): Promise<number> {
return SMap.getAIMapFixColorsModeValue(mode)
}
/**
* 重置智能配图 亮度、饱和度、色调的值
* @param isRest 一个布尔值，指定是否重置地图，默认为false-不重置
*/
export function resetAIMapFixColorsModeValue(isRest = false) {
return SMap.resetAIMapFixColorsModeValue(isRest)
}
/**
* 把指定地图中的所有图层添加到当前打开地图中
* @param srcMapName 指定的地图名称
* @returns 添加成功返回true，否则返回false
*/
export function addMap(srcMapName: string): Promise<boolean> {
return SMap.addMap(srcMapName)
}
/************************************** 地图编辑历史操作 ****************************************/
/**
* 地图撤销
* @returns 撤销成功返回true，否则返回false
*/
export function undo(): Promise<boolean> {
return SMap.undo()
}
/**
* 地图恢复
* @returns 恢复成功返回true，否则返回false
*/
export function redo(): Promise<boolean> {
return SMap.redo()
}
/**
* 把对图层数据的操作记录到历史
* @param layerPath 图层名,如果有分组则为group/layerName
* @param ids 几何对象ID数组
* @param type 几何对象操作事件。0:新增 1:修改 2:删除 3:自定义
* @returns 记录成功返回true，否则返回false
*/
export function addDataToMapHistory(layerPath: string, ids: number[], type = 0 | 1 | 2 | 3): Promise<boolean> {
return SMap.addDataToMapHistory(layerPath, ids, type)
}
/**
* 把对地图风格操作记录到历史
* @returns 记录成功返回true，否则返回false
*/
export function addMapHistory(): Promise<boolean> {
return SMap.addMapHistory()
}
/**
* 获取地图操作记录数量
* @returns 地图操作记录数量
*/
export function getMapHistoryCount(): Promise<number> {
return SMap.getMapHistoryCount()
}
/**
* 获取当前地图操作记录索引
* @returns 当前地图操作记录索引
*/
export function getMapHistoryCurrentIndex(): Promise<number> {
return SMap.getMapHistoryCurrentIndex()
}
//********************************** callout ************************************************
type CalloutType = 'image' | 'text' | 'media'
type Callout = ImageCallout
// | TextCallout
| MediaCallout
interface CalloutBase {
type: CalloutType
size?: number
}
interface ImageCallout extends CalloutBase {
type: 'image'
/** 内置的图片资源路径 */
resource?: string
/** 多媒体文件路径，与resource互斥 */
mediaPath?: string,
}
/** 多媒体callout，支持视频/图片/gif等 */
interface MediaCallout extends MediaData {
type: 'media'
size?: number
}
// interface TextCallout extends CalloutBase {
// type: 'text'
// text: string
// }
/**
* 添加一个callout对象
* @param tag callout对象的标签
* @param point callout对象的添加位置
* @param callout callout对象
* @returns 添加成功返回true，否则返回false
*/
export function addCallout(tag: string, point: Point2D, callout: Callout): Promise<boolean> {
return SMap.addCallout(tag, point, callout)
}
/**
* 更新callout位置
* @param tag callout对象的标签
* @param point callout对象的位置
* @returns 更新成功返回true，否则返回false
*/
export function updateCallout(tag: string, point: Point2D): Promise<boolean> {
return SMap.updateCallout(tag, point)
}
/**
* 通过callout对象标签移除对应callout对象
* @param tag 要移除的callout对象的标签
* @returns 移除成功返回true，否则返回false
*/
export function removeCallout(tag: string): Promise<boolean> {
return SMap.removeCallout(tag)
}
/**
* 移除当前地图上的所有callout对象
* @returns 移除成功返回true，否则返回false
*/
export function removeAllCallouts(): Promise<boolean> {
return SMap.removeAllCallouts()
}
/* ------------------------------------------------------图层相关接口-----------------------------------------------------------*/
/**
* 获取图层最小可见比例尺
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 图层最小可见比例尺范围
*/
export function getLayerMinVisibleScale(layerPath: string): Promise<number> {
return SMap.getLayerMinVisibleScale(layerPath)
}
/**
* 设置图层最小比例尺,最小可见比例尺不可为负。当地图的当前显示比例尺小于图层最小可见比例尺时，此图层将不显示。
* @param layerPath 图层名,如果有分组则为group/layerName
* @param value 图层最小可见比例尺
* @returns 设置成功返回true，否则返回false
*/
export function setLayerMinVisibleScale(layerPath: string, value: number): Promise<boolean> {
return SMap.setLayerMinVisibleScale(layerPath, value)
}
/**
* 获取图层最大可见比例尺
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 图层最大可见比例尺
*/
export function getLayerMaxVisibleScale(layerPath: string): Promise<number> {
return SMap.getLayerMaxVisibleScale(layerPath)
}
/**
* 设置图层最大可见比例尺,最大可见比例尺不可为负，当地图的当前显示比例尺大于或等于图层最大可见比例尺时，此图层将不显示。
* @param layerPath 图层名,如果有分组则为group/layerName
* @param value 图层最大可见比例尺
* @returns 设置成功返回true，否则返回false
*/
export function setLayerMaxVisibleScale(layerPath: string, value: number): Promise<boolean> {
return SMap.setLayerMaxVisibleScale(layerPath, value)
}
/**
* 设置全副显示图层
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 设置成功返回true，否则返回false
*/
export function setLayerFullView(layerPath: string): Promise<boolean> {
return SMap.setLayerFullView(layerPath)
}
/**
* 根据图层路径，获取图层信息
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 图层信息对象，未获取到返回空
*/
export function getLayerInfo(layerPath: string): Promise<LayerInfo | null> {
return LayerManager.getLayerInfo(layerPath)
}
/**
* 获取当前地图中，指定类型图层的图层信息
* @param type 指定类型图层,-1返回所有类型图层信息
* @returns 图层信息对象列表
*/
export function getLayersInfo(type: TDatasetType | -1 = -1): Promise<LayerInfo[]> {
return LayerManager.getLayersInfo(type)
}
/**
* 获取图层分组下图层信息
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 图层信息对象列表
*/
export function getLayersByGroupPath(layerPath: string): Promise<LayerInfo[]> {
return LayerManager.getLayersByGroupPath(layerPath)
}
/**
* 设置指定名称图层是否可见
* @param layerPath 图层名,如果有分组则为group/layerName
* @param value 一个布尔值，指定图层是否可见
* @returns 设置成功返回true，否则返回false
*/
export function setLayerVisible(layerPath: string, value: boolean): Promise<boolean> {
return LayerManager.setLayerVisible(layerPath, value)
}
/**
* 获取指定名称图层是否可见
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 设置成功返回true，否则返回false
*/
export function getLayerVisible(layerPath: string): Promise<boolean> {
return LayerManager.getLayerVisible(layerPath)
}
/**
* 设置指定名称图层是否可编辑
* @param layerPath 图层名,如果有分组则为group/layerName
* @param value 一个布尔值，指定图层是否可编辑
* @returns 设置成功返回true，否则返回false
*/
export function setLayerEditable(layerPath: string, value: boolean): Promise<boolean> {
return LayerManager.setLayerEditable(layerPath, value)
}
/**
* 获取指定名称图层是否可编辑
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 设置成功返回true，否则返回false
*/
export function getLayerEditable(layerPath: string): Promise<boolean> {
return LayerManager.getLayerEditable(layerPath)
}
/**
* 设置指定图层的描述信息
* @param layerPath 图层名,如果有分组则为group/layerName
* @param value 图层的描述信息
* @returns 设置成功返回true，否则返回false
*/
export function setLayerDescription(layerPath: string, value: string): Promise<boolean> {
return LayerManager.setLayerDescription(layerPath, value)
}
/**
* 设置图层是否可选择【只对矢量图层生效】
* @param layerPath 图层名,如果有分组则为group/layerName
* @param selectable 一个布尔值，指定图层是否可选择
* @returns 设置成功返回true，否则返回false
*/
export function setLayerSelectable(layerPath: string, selectable: boolean): Promise<boolean> {
return LayerManager.setLayerSelectable(layerPath, selectable)
}
/**
* 设置图层是否可选择【只对矢量图层生效】
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 设置成功返回true，否则返回false
*/
export function getLayerSelectable(layerPath: string): Promise<boolean> {
return LayerManager.getLayerSelectable(layerPath)
}
/**
* 设置图层是否可捕捉【只对矢量图层生效】
* @param layerPath 图层名,如果有分组则为group/layerName
* @param snapable 一个布尔值，指定图层是否可捕捉
* @returns 设置成功返回true，否则返回false
*/
export function setLayerSnapable(layerPath: string, snapable: boolean): Promise<boolean> {
return LayerManager.setLayerSnapable(layerPath, snapable)
}
/**
* 获取图层是否可捕捉【只对矢量图层生效】
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 设置成功返回true，否则返回false
*/
export function getLayerSnapable(layerPath: string): Promise<boolean> {
return LayerManager.getLayerSnapable(layerPath)
}
/**
* 设置影像显示模式【只对影像图层生效】
* @description 默认值与数据集波段数保持一致，如果数据集为多波段，则默认为组合模式，否则，默认为拉伸模式
* @param layerPath 图层名,如果有分组则为group/layerName
* @param mode 显示模式。0:组合显示模式,1:拉伸显示模式
* @returns 设置成功返回true，否则返回false
*/
export function setImageDisplayMode(layerPath: string, mode: 0 | 1): Promise<boolean> {
return LayerManager.setImageDisplayMode(layerPath, mode)
}
/**
* 获取影像显示模式【只对影像图层生效】
* @description 默认值与数据集波段数保持一致，如果数据集为多波段，则默认为组合模式，否则，默认为拉伸模式
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 影像显示模式。0:组合显示模式,1:拉伸显示模式
*/
export function getImageDisplayMode(layerPath: string): Promise<0 | 1> {
return LayerManager.getImageDisplayMode(layerPath)
}
/**
* 设置影像拉伸类型【只对影像图层生效】
* @param layerPath 图层名,如果有分组则为group/layerName
* @param type 影像拉伸类型。0:无拉伸,1:标准差拉伸,2:最值拉伸,3:直方图均衡,4:直方图规定化,5:高斯对比度拉伸
* @returns 设置成功返回true，否则返回false
*/
export function setImageStretchType(layerPath: string, type: 0 | 1 | 2 | 3 | 4 | 5): Promise<boolean> {
return LayerManager.setImageStretchType(layerPath, type)
}
/**
* 获取影像拉伸类型【只对影像图层生效】
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 影像拉伸类型。0:无拉伸,1:标准差拉伸,2:最值拉伸,3:直方图均衡,4:直方图规定化,5:高斯对比度拉伸
*/
export function getImageStretchType(layerPath: string) {
return LayerManager.getImageStretchType(layerPath)
}
/**
* 获取图层选择集中对象的字段值
* @param path 图层名,如果有分组则为group/layerName
* @returns 对象的字段值列表
*/
export function getLayerSelectionAttribute(path: string, filterKey = ""): Promise<FieldInfoValue[]> {
return LayerManager.getLayerSelectionAttribute(path, filterKey)
}
/**
* 删除图层选择集中对象
* @param path 图层名,如果有分组则为group/layerName
* @param index 被删除对象在选择集中的索引
* @returns 删除成功返回true，否则返回false
*/
export function deleteByLayerSelectionIndex(path: string, index: number): Promise<boolean> {
return LayerManager.deleteByLayerSelectionIndex(path, index)
}
/**
* 向图层选择集中加入几何对象
* @param layerPath 图层名,如果有分组则为group/layerName
* @param ids 几何对象ID数组
*/
export function addToLayerSelection(layerPath: string, ids: number[]) {
return LayerManager.addToLayerSelection(layerPath, ids)
}
/**
* 清空图层选择集
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 成功返回true，否则返回false
*/
export function clearLayerSelection(layerPath: string): Promise<boolean> {
return SMap.clearLayerSelection(layerPath)
}
/**
* 设置图层选择集样式
* @param layerPath 图层名,如果有分组则为group/layerName
* @param style 图层风格
* @returns 设置成功返回true，否则返回false
*/
export function setLayerSelectionStyle(layerPath: string, style: GeoStyle): Promise<boolean> {
return SMap.setLayerSelectionStyle(layerPath, JSON.stringify(style))
}
/**
* 图层对应数据集信息类
*/
interface LayerDatasetInfo {
/** 数据源别名或索引 */
datasource: number | string
/** 数据集名称或索引 */
dataset: number | string
/** 是否添加矢量数据集的子数据集 */
addChild?: boolean
}
/**
* 添加数据集到地图，作为一个普通图层显示
* @param datasetInfo 数据集信息对象
* @param toHead 是否添加到最顶层,默认true
* @returns 返回图层信息对象，未成功添加返回空
*/
export function addLayer(datasetInfo: LayerDatasetInfo, toHead = true): Promise<LayerInfo | null | undefined> {
return LayerManager.addLayer(datasetInfo, toHead)
}
/**
* 批量添加数据集到地图，作为普通图层显示
* @param datasetNames 数据集名称列表
* @param datasourceName 数据集所在数据源名称
* @returns 添加的图层信息对象列表
*/
export function addLayers(datasetNames: string[], datasourceName: string): Promise<LayerInfo[]> {
return SMap.addLayers(datasetNames, datasourceName)
}
/**
* 根据图层名，获取图层XML字符串形式的描述
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 图层XML字符串形式的描述
*/
export function getLayerAsXML(layerPath: string): Promise<string> {
return LayerManager.getLayerAsXML(layerPath)
}
/**
* 根据图层名，获取专题图层XML字符串形式的描述
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 专题图层XML字符串形式的描述
*/
export function getLayerThemeXML(layerPath: string): Promise<string> {
return SMap.getLayerThemeXML(layerPath)
}
/**
* 更新专题图
* @param layerPath 图层名,如果有分组则为group/layerName
* @param theme 专题图层XML字符串形式的描述
*/
export function setLayerThemeFromXML(layerPath: string, theme: string) {
return SMap.setLayerThemeFromXML(layerPath, theme)
}
/**
* 通过图层XML字符串形式的描述插入图层
* @param index 插入图层的索引
* @param xml 图层XML字符串形式的描述
* @returns 插入成功返回true，否则返回false
*/
export function insertLayerFromXml(index: number, xml: string): Promise<boolean> {
return LayerManager.insertLayerFromXml(index, xml)
}
/**
* 移除所有图层
* @returns 移除成功返回true，否则返回false
*/
export function removeAllLayer(): Promise<boolean> {
return LayerManager.removeAllLayer()
}
/**
* 通过图层索引移除指定图层
* @param index 图层索引
* @returns 移除成功返回true，否则返回false
*/
export function removeLayer(index: number): Promise<boolean>
/**
* 通过图层名称移除指定图层
* @param layerName 图层名称
* @returns 移除成功返回true，否则返回false
*/
export function removeLayer(layerName: string): Promise<boolean>
/**
* 通过数据源数据集信息移除指定图层
* @param datasetInfo 图层关联数据源数据集信息
* @returns 移除成功返回true，否则返回false
*/
export function removeLayer(datasetInfo: { datasourceAlias: string, datasetName: string }): Promise<boolean>
export function removeLayer(value: number | string | { datasourceAlias: string, datasetName: string }): Promise<boolean> {
if (typeof value === 'number') {
return LayerManager.removeLayerWithIndex(value)
} else if (typeof value === 'string') {
return LayerManager.removeLayerWithName(value)
} else {
return LayerManager.removeLayerWithDatasetInfo(value)
}
}
/**
* 重命名图层
* @param oldName 原图层名
* @param newName 新图层名
* @returns 重命名成功返回true，否则返回false
*/
export function renameLayer(oldName: string, newName: string): Promise<boolean> {
return LayerManager.renameLayer(oldName, newName)
}
/**
* 向上移动图层
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 移动成功返回true，否则返回false
*/
export function moveUpLayer(layerPath: string): Promise<boolean> {
return LayerManager.moveUpLayer(layerPath)
}
/**
* 向下移动图层
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 移动成功返回true，否则返回false
*/
export function moveDownLayer(layerPath: string): Promise<boolean> {
return LayerManager.moveDownLayer(layerPath)
}
/**
* 置顶图层
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 置顶成功返回true，否则返回false
*/
export function moveToTop(layerPath: string): Promise<boolean> {
return LayerManager.moveToTop(layerPath)
}
/**
* 置底图层
* @param layerPath 图层名,如果有分组则为group/layerName
* @returns 置底成功返回true，否则返回false
*/
export function moveToBottom(layerPath: string): Promise<boolean> {
return LayerManager.moveToBottom(layerPath)
}
/**
* 添加对象到追踪层
* @param datasetInfo 数据集信息类对象
* @param ids 几何对象ID数组
* @param style 几何对象风格
* @returns 添加成功返回true，否则返回false
*/
export function addGeometryToTrackingLayerByIDs(datasetInfo: DatasetInfo, ids: number[], style: GeoStyle): Promise<boolean> {
return LayerManager.addGeometryToTrackingLayerByIDs(datasetInfo, ids, JSON.stringify(style))
}
/**
* 清除追踪层对象
* @returns 清除成功返回true，否则返回false
*/
export function clearTrackingLayer(): Promise<boolean> {
return LayerManager.clearTrackingLayer()
}
/**
* 向当前追踪层中添加一个几何对象，并给出该几何对象的标签信息。
* @param geo 几何对象
* @param tag 要添加的几何对象的标签信息。
* @param style 几何对象风格
* @returns 添加成功返回true，否则返回false
*/
export function addGeometryToTrackingLayer(geo: Geometry, tag: string, style?: GeoStyle): Promise<boolean> {
return LayerManager.addGeometryToTrackingLayer(geo, tag, JSON.stringify(style))
}
/**
* 删除当前追踪图层中指定标签的几何对象
* @param tag 要删除的几何对象的标签
* @returns 删除成功返回true，否则返回false
*/
export function removeGeometryFromTrackingLayer(tag: string): Promise<boolean> {
return LayerManager.removeGeometryFromTrackingLayer(tag)
}
/**
* 设置MapControl风格,针对地图临时几何对象
* @param style 地图临时对象风格
* @returns 设置成功返回true，否则返回false
*/
export function setMapControlStyle(style: MapConstrolStyle): Promise<boolean> {
return SMap.setMapControlStyle(style)
}
/**
* 屏幕坐标点转地图坐标点
* @param point 屏幕坐标点
* @returns 地图坐标点
*/
export function pixelToMap(point: Point2D): Promise<Point2D> {
return SMap.pixelToMap(point)
}
/**
* 地图坐标点转屏幕坐标点
* @param point 地图坐标点
* @returns 屏幕坐标点
*/
export function mapToPixel(point: Point2D): Promise<Point2D> {
return SMap.mapToPixel(point)
}
/************************************** 图层风格相关接口 ****************************************/
/**
* 获取图层风格XML字符串形式的描述
* @param layerName 图层名
* @returns 图层风格XML字符串形式的描述
*/
export function getLayerStyleXml(layerName: string): Promise<string> {
return SCartography.getLayerStyleXml(layerName)
}
/**
* 通过图层风格XML字符串形式的描述设置图层风格
* @param layerName 图层名
* @param style 图层风格XML字符串形式的描述
* @returns 设置成功返回true，否则返回false
*/
export function setLayerStyleXml(layerName: string, style: string): Promise<boolean> {
return SCartography.setLayerStyleXml(layerName, style)
}
/**
* 获取图层风格对象
* @param layerName 图层名
* @returns 图层风格对象
*/
export function getLayerStyle(layerName: string): Promise<LayerStyle|null> {
return SCartography.getLayerStyle(layerName)
}
/**
* 设置图层风格
* @param layerName 图层名
* @param style 图层风格对象
* @returns 设置成功返回true，否则返回false
*/
export function setLayerStyle(layerName: string, style: Partial<LayerStyle>): Promise<boolean> {
return SCartography.setLayerStyle(layerName, style)
}
/**
* 获取栅格图层风格对象
* @param layerName 图层名
* @returns 栅格图层风格对象
*/
export function getLayerGridStyle(layerName: string): Promise<LayerGridStyle|null> {
return SCartography.getLayerGridStyle(layerName)
}
/**
* 设置栅格图层风格
* @param layerName 图层名
* @param style 图层风格对象
* @returns 设置成功返回true，否则返回false
*/
export function setLayerGridStyle(layerName: string, style: Partial<LayerGridStyle>): Promise<boolean> {
return SCartography.setLayerGridStyle(layerName, style)
}
/**
* 设置文本图层风格
* @param layerName 图层名
* @param style 文本风格。
* @returns 设置成功返回true，否则返回false
*/
export function setLayerTextStyle(layerName: string, style: Partial<GeoTextStyle>): Promise<boolean> {
return SCartography.setLayerTextStyle(layerName, style)
}
/**
* 设置文本对象的角度(设置图层中所有对象的第一个子对象)
* @param geoID 文本对象ID
* @param rotation 要旋转的角度，逆时针旋转
* @returns 是否成功
*/
export function setLayerTextRotation(layerName: string, rotation: number): Promise<boolean> {
return SCartography.setLayerTextRotation(layerName, rotation)
}
/**
* 获取文本图层风格对象
* @param layerName 图层名
* @returns 文本图层风格对象
*/
export function getLayerTextStyle(layerName: string): Promise<GeoTextStyle | null | undefined> {
return SCartography.getLayerTextStyle(layerName)
}
//********************************** 废弃接口 ************************************************
/**
* 移除当前搜有搜索出的结果
* @returns {*|void}
* @deprecated
*/
export async function _removeAllCallout() {
try {
return SMap.removeAllCallout()
} catch (e) {
console.error(e)
}
}
/**
* 设置当前选中callout
* @param item
* @returns {*}
* @deprecated
*/
export function setCenterCallout(item) {
try {
return SMap.setCenterCallout(item)
} catch (e) {
console.error(e)
}
}
/**
* 协作消息callout
* @deprecated
*/
export function addMessageCallout(layerPath, geoId, geoUserID, userName, msgId) {
try {
return SMap.addMessageCallout(layerPath, geoId, geoUserID, userName, msgId)
} catch (e) {
console.error(e)
}
}
let messageListener
/**
* 协作消息callout
* @deprecated
*/
export function addMessageCalloutListener(handler) {
messageListener?.remove()
messageListener = nativeEvt.addListener(EventConst.USER_MESSAGE_CALLOUT_TAP, function (e) {
handler(e)
})
}
/**
* 协作消息callout
* @deprecated
*/
export function removeMessageCalloutListener() {
messageListener?.remove()
}
/**
* 协作消息callout
* @deprecated
*/
export function addLocationCallout(x, y, userName, userID, initial = '') {
try {
return SMap.addLocationCallout(x, y, userName, userID, initial)
} catch (e) {
console.error(e)
}
}
/**
* 协作消息callout
* @deprecated
*/
export function removeMessageCallout(msgId) {
try {
return SMap.removeMessageCallout(msgId)
} catch (e) {
console.error(e)
}
}
/**
* 协作消息callout
* @deprecated
*/
export function removeLocationCallout(userID) {
try {
return SMap.removeLocationCallout(userID)
} catch (e) {
console.error(e)
}
}
/**
* 协作消息callout
* @deprecated
*/
export function removeUserCallout() {
try {
return SMap.removeUserCallout()
} catch (e) {
console.error(e)
}
}
/**
* 协作消息callout
* @deprecated
*/
export function addUserTrack(x, y, userID) {
try {
return SMap.addUserTrack(x, y, userID)
} catch (e) {
console.error(e)
}
}
/**
* 协作消息callout
* @deprecated
*/
export function hideUserTrack(userID) {
try {
return SMap.hideUserTrack(userID)
} catch (e) {
console.error(e)
}
}
/**
* 协作消息callout
* @deprecated
*/
export function showUserTrack(userID) {
try {
return SMap.showUserTrack(userID)
} catc