/**
* @content 地图视图功能组件
* @author fjl 2019-6-14 下午2:52:36
*/
import { NativeModules } from 'react-native';
let MV = NativeModules.JSMapView;
import Dot from './Dot.js';
import PointF from './PointF.js';
import Rect from './Rect.js';
import Map from './Map.js';
import GraphicsOverlay from './GraphicsOverlay.js';
import GraphicsOverlays from './GraphicsOverlays.js';
import MapPosition from './MapPosition';
import Graphic from './Graphic.js';
import ModelsOverlay from './ModelsOverlay.js';
import Model from './Model.js';
import Image from "./Image.js"
import AnnotationsOverlay from "./AnnotationsOverlay.js"
/**
* @class MapView
* @description 地图显示控件容器类。
*/
export default class JSMapView {
/**
* 设置视图背景色
* @memberOf MapView
* @param {String} color 地图视图的背景颜色 eg:'rgba(128, 128, 128, 0.5)'
* @returns {Promise<void>}
*/
async setBackGroundColor(color) {
try {
await MV.setBackGroundColor(this._MGMapViewId, color);
} catch (e) {
console.error(e);
}
}
/**
* 获取视图背景色
* @memberOf MapView
* @returns {Promise<Number>} 获取到的地图视图背景色。
*/
async getBackGroundColor() {
try {
var { color } = await MV.getBackGroundColor(this._MGMapViewId);
return color;
} catch (e) {
console.error(e);
}
}
/**
* 设置背景图像,传null将取消背景图片显示
*
* @memberof MapView
* @param {Object} image 背景图片---Image.js类生成的对象
* @returns {Promise<Void>}
*/
async setBackGroundImage(image) {
try {
if(image !== null){
await MV.setBackGroundImage(this._MGMapViewId, image._MGImageId);
}else{
await MV.setBackGroundImage(this._MGMapViewId, null);
}
} catch (e) {
console.error(e);
}
}
/**
* 加载地图
* @memberOf MapView
* @param {String} strMapPath docPath 地图文档全路径
* @returns {Promise<Number>} 加载成功，返回值>0，失败，返回<=0
*/
async loadFromFile(strMapPath) {
try {
let result = await MV.loadFromFile(this._MGMapViewId, strMapPath);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 加载地图，异步方法，可通过MapViewMapLoadListener来监听加载状态
* @memberOf MapView
* @param {String} strMapPath 地图文档全路径
* @returns {Promise<void>}
*/
async loadFromFileAsync(strMapPath) {
try {
await MV.loadFromFileAsync(this._MGMapViewId, strMapPath);
} catch (e) {
console.error(e);
}
}
/**
* 加载文档中对应索引的地图，同步方法
* @memberOf MapView
* @param {object} doc 地图文档对象
* @param {number} indexOfMap 文档中map序号
* @returns {Promise<Number>} 加载成功，返回值>0，失败，返回<=0
*/
async loadFromDocument(doc, indexOfMap) {
try {
let { result } = await MV.loadFromDocument(
this._MGMapViewId,
doc._MGDocumentId,
indexOfMap
);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 加载文档中对应索引的地图，异步方法
* @memberOf MapView
* @param {object} doc 地图文档对象
* @param {number} indexOfMap indexOfMap 文档中map序号
* @returns {Promise<void>}
*/
async loadFromDocumentAsync(doc, indexOfMap) {
try {
await MV.loadFromDocumentAsync(
this._MGMapViewId,
doc._MGDocumentId,
indexOfMap
);
} catch (e) {
console.error(e);
}
}
/**
* 设置地图对象，同步方法
* @memberOf MapView
* @param {object} map 地图对象
* @returns {Promise<Number>} 设置成功，返回值>0，设置失败，返回值<=0
*/
async setMap(map) {
try {
let { result } = await MV.setMap(this._MGMapViewId, map._MGMapId);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 设置地图对象，异步方法
* @memberOf MapView
* @param {object} map 地图对象
* @returns {Promise<void>}
*/
async setMapAsync(map) {
try {
let isFinish = await MV.setMapAsync(this._MGMapViewId, map._MGMapId);
return isFinish;
} catch (e) {
console.error(e);
}
}
/**
* 获取地图对象
* @memberOf MapView
* @returns {Promise<Map>} 成功返回地图对象,失败返回空
*/
async getMap() {
try {
var { mapID } = await MV.getMap(this._MGMapViewId);
var map = new Map();
map._MGMapId = mapID;
return map;
} catch (e) {
console.error(e);
}
}
/**
* 地图刷新
* @memberOf MapView
* @returns {Promise<void>}
*/
async refresh() {
try {
await MV.refresh(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 地图强制刷新
* @memberOf MapView
* @returns {Promise<void>}
*/
async forceRefresh() {
try {
await MV.forceRefresh(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 停止当前的获取数据的请求(从服务器请求或从本地请求)
* @memberOf MapView
* @returns {Promise<void>}
*/
async stopCurRequest() {
try {
await MV.stopCurRequest(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 地图坐标转视图坐标
* @memberOf MapView
* @param {object} dot 地图坐标
* @returns {Promise<PointF>} 视图坐标
*/
async mapPointToViewPoint(dot) {
try {
var { pointFId, x, y } = await MV.mapPointToViewPoint(
this._MGMapViewId,
dot._MGDotId
);
var pointF = new PointF();
pointF._MGPointFId = pointFId;
pointF.x = x;
pointF.y = y;
return pointF;
} catch (e) {
console.error(e);
}
}
/**
* 视图坐标转地图坐标
* @memberOf MapView
* @param {object} pointF 视图坐标
* @returns {Promise<Dot>} 地图坐标
*/
async viewPointToMapPoint(pointF) {
try {
var { dotID, x, y } = await MV.viewPointToMapPoint(
this._MGMapViewId,
pointF._MGPointFId
);
var dot = new Dot();
dot._MGDotId = dotID;
dot.x = x;
dot.y = y;
return dot;
} catch (e) {
console.error(e);
}
}
async mapPointToGLPoint(point) {
try {
var { dotID, x, y } = await MV.mapPointToGLPoint(
this._MGMapViewId,
point._MGDotId
);
var dot = new Dot();
dot._MGDotId = dotID;
dot.x = x;
dot.y = y;
return dot;
} catch (e) {
console.error(e);
}
}
/**
*获取地图分辨率
* @memberOf MapView
* @returns {Promise<double>} 分辨率信息
*/
async getResolution() {
try {
var { resolution } = await MV.getResolution(this._MGMapViewId);
return resolution;
} catch (e) {
console.error(e);
}
}
/**
* 获取最大分辨率
* @memberOf MapView
* @returns {Promise<Dot.resolution>}
*/
async getMaxResolution() {
try {
var { maxResolution } = await MV.getMaxResolution(this._MGMapViewId);
return maxResolution;
} catch (e) {
console.error(e);
}
}
/**
* 获取最小分辨率
* @memberOf MapView
* @returns {Promise<Dot.resolution>} 分辨率信息
*/
async getMinResolution() {
try {
var { minResolution } = await MV.getMinResolution(this._MGMapViewId);
return minResolution;
} catch (e) {
console.error(e);
}
}
/**
* 获取地图中心点
* @memberOf MapView
* @returns {Promise<Dot>} 中心点的坐标
*/
async getCenterPoint() {
try {
var { dotID, x, y } = await MV.getCenterPoint(this._MGMapViewId);
var dot = new Dot();
dot._MGDotId = dotID;
dot.x = x;
dot.y = y;
return dot;
} catch (e) {
console.error(e);
}
}
/**
* 获取当前显示地图的显示范围
* @memberOf MapView
* @returns {Promise<Rect>} 地图范围
*/
async getDispRange() {
try {
var { rectId } = await MV.getDispRange(this._MGMapViewId);
var rect = new Rect();
rect._MGRectId = rectId;
return rect;
} catch (e) {
console.error(e);
}
}
/**
* 平移地图到视图中心(视图高宽1/2处，绝对中心)
* @memberOf MapView
* @param mapCenterPoint 中心坐标
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async panToCenter(mapCenterPoint, animated) {
try {
await MV.panToCenter(
this._MGMapViewId,
mapCenterPoint._MGDotId,
animated
);
} catch (e) {
console.error(e);
}
}
/**
* 平移地图到自定义视图中心(视图高宽1/2处，绝对中心)
* @memberOf MapView
* @param mapCenterPoint 中心坐标
* @param viewCenterPoint 自定义视图中心
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async panToCenterWithView(mapCenterPoint, viewCenterPoint, animated) {
try {
await MV.panToCenterWithView(
this._MGMapViewId,
mapCenterPoint._MGDotId,
viewCenterPoint._MGPointFId,
animated
);
} catch (e) {
console.error(e);
}
}
/**
* * 移动地图（单位像素） 如果传入的mx = 5 、 my = 0，则系统将可视区域向右移动，所以地图将显示为向左移动5 个像素。 如果传入的mx =
* 0 、 my = 5，则系统将可视区域向下移动，所以地图显示为向上移动了5 个像素。
* @memberOf MapView
* @param mx 水平方向移动的像素大小，正值代表可视区域向右移动，负值代表可视区域向左移动
* @param my 垂直方向移动的像素大小，正值代表可视区域向下移动，负值代表可视区域向上移动
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async moveMap(mx, my, animated) {
try {
await MV.moveMap(this._MGMapViewId, mx, my, animated);
} catch (e) {
console.error(e);
}
}
/**
* 缩放地图到指定分辨率并将指定坐标点移动到视图中心(视图高宽1/2处，绝对中心)
* @memberOf MapView
* @param mapCenterPoint 中心坐标
* @param resolution 分辨率
* @param animated 是否启用动画
* @returns {Promise<void>}
*/
async zoomToCenter(mapCenterPoint, resolution, animated) {
try {
await MV.zoomToCenter(
this._MGMapViewId,
mapCenterPoint._MGDotId,
resolution,
animated
);
} catch (e) {
console.error(e);
}
}
/**
* 缩放地图到指定级别并将指定坐标点移动到自定义视图中心
* @memberOf MapView
*
* @param mapCenterPoint 中心坐标
* @param viewCenterPoint 自定义视图中心
* @param resolution 分辨率
* @param animated 是否启用动画
*/
async zoomToCenterWithView(
mapCenterPoint,
viewCenterPoint,
resolution,
animated
) {
try {
await MV.zoomToCenterWithView(
this._MGMapViewId,
mapCenterPoint._MGDotId,
viewCenterPoint._MGPointFId,
resolution,
animated
);
} catch (e) {
console.error(e);
}
}
/**
* 放缩地图到指定范围
* @memberOf MapView
* @param dispRange 新的视图范围
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async zoomToRange(dispRange, animated) {
try {
await MV.zoomToRange(this._MGMapViewId, dispRange._MGRectId, animated);
} catch (e) {
console.error(e);
}
}
/**
* 地图放大一级
* @memberOf MapView
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async zoomIn(animated) {
try {
await MV.zoomIn(this._MGMapViewId, animated);
} catch (e) {
console.error(e);
}
}
/**
* 地图缩小一级
* @memberOf MapView
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async zoomOut(animated) {
try {
await MV.zoomOut(this._MGMapViewId, animated);
} catch (e) {
console.error(e);
}
}
/**
* 地图复位
* @memberOf MapView
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async restore(animated) {
try {
await MV.restore(this._MGMapViewId, animated);
} catch (e) {
console.error(e);
}
}
/**
*设置当前地图的旋转中心和旋转角
* @memberOf MapView
* @param rotateCenter 旋转中心点坐标
* @param rotateAngle 旋转角度（单位为角度制，逆时针为正）
* @param animated 是否开启动画模式
* @returns {Promise<void>}
*/
async setRotateCenterAndAngle(rotateCenter, rotateAngle, animated) {
try {
await MV.setRotateCenterAndAngle(
this._MGMapViewId,
rotateCenter._MGDotId,
rotateAngle,
animated
);
} catch (e) {
console.error(e);
}
}
/**
*设置地图的旋转中心
* @memberOf MapView
* @param rotateCenter 地图的旋转中心
* @returns {Promise<void>}
*/
async setRotateCenter(rotateCenter) {
try {
await MV.setRotateCenter(this._MGMapViewId, rotateCenter);
} catch (e) {
console.error(e);
}
}
/**
*设置地图的旋转角
* @memberOf MapView
* @param rotateAngle 旋转角（单位为角度制，逆时针为正）
* @param animated 是否启用动画
* @returns {Promise<void>}
*/
async setRotateAngle(rotateAngle, animated) {
try {
await MV.setRotateAngle(this._MGMapViewId, rotateAngle, animated);
} catch (e) {
console.error(e);
}
}
/**
*绕视图坐标旋转
* @memberOf MapView
* @param rotation 旋转增量（单位为角度制，逆时针为正）
* @param pivotX 视图旋转中心X坐标
* @param pivotY 视图旋转中心Y坐标
* @param animated 是否启用动画
* @returns {Promise<void>}
*/
async rotate(rotation, pivotX, pivotY, animated) {
try {
await MV.rotate(this._MGMapViewId, rotation, pivotX, pivotY, animated);
} catch (e) {
console.error(e);
}
}
/**
* 获取地图的旋转中心
* @memberOf MapView
* @returns {Promise<Dot>} 旋转中心的坐标
*/
async getRotateCenter() {
try {
var { dotID, x, y } = await MV.getRotateCenter(this._MGMapViewId);
var dot = new Dot();
dot._MGDotId = dotID;
dot.x = x;
dot.y = y;
return dot;
} catch (e) {
console.error(e);
}
}
/**
* 获取当前地图的旋转角
* @memberOf MapView
* @returns {Promise<Dot.rotateAngle>} 旋转角
*/
async getRotateAngle() {
try {
var { rotateAngle } = await MV.getRotateAngle(this._MGMapViewId);
return rotateAngle;
} catch (e) {
console.error(e);
}
}
/**
* 设置当前地图的倾斜角,并将地图按该角度进行倾斜
* @memberOf MapView
* @param slopeAngle 倾斜角度(单位为角度制,0到45度,当天空场景启用后,角度范围为0到65度）
* @param animated 是否开启动画
* @returns {Promise<void>}
*/
async setSlopeAngle(slopeAngle, animated) {
try {
await MV.setSlopeAngle(this._MGMapViewId, slopeAngle, animated);
} catch (e) {
console.error(e);
}
}
/**
* 获取当前地图的倾斜角
* @memberOf MapView
* @returns {Promise<float>} 当前地图的倾斜角
*/
async getSlopeAngle() {
try {
var { slopeAngle } = await MV.getSlopeAngle(this._MGMapViewId);
return slopeAngle;
} catch (e) {
console.error(e);
}
}
/**
* 更新位置(中心点为视图的绝对中心)
* @memberOf MapView
* @param postion 要更新到的位置
* @param animated 是否开启动画
* @returns {Promise<void>}
*/
async updatePosition(postion, animated) {
try {
await MV.updatePosition(
this._MGMapViewId,
postion._MMapPosition,
animated
);
} catch (e) {
console.error(e);
}
}
/**
* 更新位置(中心点为视图的指定中心)
*
* @param postion 要更新到的位置
* @param viewCenterPoint 自定义视图中心
* @param animated 是否开启动画
* @returns {Promise<void>}
*/
async updatePositionbyViewPoint(postion, viewCenterPoint, animated) {
try {
await MV.updatePosition(
this._MGMapViewId,
postion._MMapPosition,
viewCenterPoint._MGPointFId,
animated
);
} catch (e) {
console.error(e);
}
}
/**
* 动画到指定位置(中心点为视图的绝对中心)
*
* @param postion 要动画到的位置
* @param duration 持续时间(单位毫秒)
* @returns {Promise<void>}
*/
async animatePosition(postion, duration) {
try {
await MV.animatePosition(
this._MGMapViewId,
postion._MMapPosition,
duration
);
} catch (e) {
console.error(e);
}
}
/**
* 动画到指定位置(中心点为视图的指定中心)
* @memberOf MapView
* @param postion 要动画到的位置
* @param viewCenterPoint 自定义视图中心
* @param duration 持续时间(单位毫秒)
* @returns {Promise<void>}
*/
async animatePositionByViewPoint(postion, viewCenterPoint, duration) {
try {
await MV.animatePositionByViewPoint(
this._MGMapViewId,
postion._MMapPosition,
viewCenterPoint._MGPointFId,
duration
);
} catch (e) {
console.error(e);
}
}
/**
* 停止动画效果
* @memberOf MapView
* @returns {Promise<void>}
*/
async stopAnimation() {
try {
await MV.stopAnimation(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 获取当前位置
* @memberOf MapView
* @returns {Promise<MapPosition>} 当前地图的位置
*/
async getPosition() {
try {
var { mapPositionID } = await MV.getPosition(this._MGMapViewId);
var mapPosition = new MapPosition();
mapPosition._MMapPosition = mapPositionID;
return mapPosition;
} catch (e) {
console.error(e);
}
}
/**
* 获取地图标记层
* @memberOf MapView
* @returns {Promise<AnnotationsOverlay>} 标记层
*/
async getAnnotationsOverlay()
{
try {
var {AnnotationsOverlayId} = await MV.getAnnotationsOverlay(
this._MGMapViewId
);
var annotationsOverlay = new AnnotationsOverlay();
annotationsOverlay._MGAnnotationsOverlayId = AnnotationsOverlayId;
return annotationsOverlay;
} catch (e) {
console.error(e);
}
}
/**
* 获取缺省的图形覆盖物列表
* @memberOf MapView
* @returns {Promise<GraphicsOverlay>} 缺省的图形覆盖物列表
*/
async getGraphicsOverlay() {
try {
var { GraphicsOverlayId } = await MV.getGraphicsOverlay(
this._MGMapViewId
);
var graphicsOverlay = new GraphicsOverlay();
graphicsOverlay._MGGraphicsOverlayId = GraphicsOverlayId;
return graphicsOverlay;
} catch (e) {
console.error(e);
}
}
/**
* 获取图形覆盖物列表的集合
* @memberOf MapView
* @returns {Promise<GraphicsOverlays>} 图形覆盖物列表的集合
*/
async getGraphicsOverlays() {
try {
var { GraphicsOverlaysId } = await MV.getGraphicsOverlays(
this._MGMapViewId
);
var graphicsOverlays = new GraphicsOverlays();
graphicsOverlays._MGGraphicsOverlaysId = GraphicsOverlaysId;
return graphicsOverlays;
} catch (e) {
console.error(e);
}
}
/**
* 图形覆盖物点击测试
* @memberOf MapView
* @param graphicsOverlay
* @param viewPoint
* @returns {Promise<Graphic>} 被选中的图形覆盖物
*/
async graphicsOverlayHitTest(graphicsOverlay, viewPoint) {
try {
var { GraphicID } = await MV.graphicsOverlayHitTest(
this._MGMapViewId,
graphicsOverlay._MGGraphicsOverlayId,
viewPoint._MGPointFId
);
var graphic = new Graphic();
graphic._MGGraphicId = GraphicID;
return graphic;
} catch (e) {
console.error(e);
}
}
/**
* 图形点击测试
* @memberOf MapView
* @param graphic
* @param viewPoint
* @returns {Promise<Boolean>} 是否被选中
*/
async graphicHitTest(graphic, viewPoint) {
try {
var { bHit } = await MV.graphicHitTest(
this._MGMapViewId,
graphic._MGGraphicId,
viewPoint._MGPointFId
);
return bHit;
} catch (e) {
console.error(e);
}
}
/**
* 获取模型覆盖物列表
* @memberOf MapView
* @returns {Promise<ModelsOverlay>} 模型覆盖物列表
*/
async getModelsOverlay() {
try {
var { ModelsOverlayID } = await MV.getModelsOverlay(this._MGMapViewId);
var modelsOverlay = new ModelsOverlay();
modelsOverlay._MGModelsOverlayID = ModelsOverlayID;
return modelsOverlay;
} catch (e) {
console.error(e);
}
}
/**
* 模型覆盖物点击测试
* @memberOf MapView
* @param viewPoint
* @returns {Promise<Model>} 被选中的模型覆盖物
*/
async modelsOverlayHitTest(viewPoint) {
try {
var { ModelId } = await MV.modelsOverlayHitTest(
this._MGMapViewId,
viewPoint._MGPointFId
);
var model = new Model();
model._MGModelId = ModelId;
return model;
} catch (e) {
console.error(e);
}
}
/**
* 模型层点击测试
* @summary 点击选中的模型可以将其添加到ModelsOverlay中,然后进行参数的修改,最后再通过SimpleModelLayerUtil更新回modelLayer
* @memberOf MapView
* @param modelLayer
* @param viewPoint
* @returns {Promise<Model>}
*/
async modelLayerHitTest(modelLayer, viewPoint) {
try {
var { ModelId } = await MV.modelLayerHitTest(
this._MGMapViewId,
modelLayer._MGSimpleModelLayerId,
viewPoint._MGPointFId
);
var model = new Model();
model._MGModelId = ModelId;
return model;
} catch (e) {
console.error(e);
}
}
/**
* 设置纹理缓存的最大限额（单位为字节）
* @memberOf MapView
* @returns {Promise<void>}
*/
async setMaxTextureCacheSize(size) {
try {
await MV.setMaxTextureCacheSize(this._MGMapViewId, size);
} catch (e) {
console.error(e);
}
}
/**
* 获取纹理缓存的最大限额（单位为字节）
* @memberOf MapView
* @returns {Promise<Number>} 设定的纹理缓存的最大限额
*/
async getMaxTextureCacheSize() {
try {
var { MaxTextureCacheSize } = await MV.getMaxTextureCacheSize(
this._MGMapViewId
);
return MaxTextureCacheSize;
} catch (e) {
console.error(e);
}
}
/**
* 清除纹理缓存
* @memberOf MapView
* @returns {Promise<void>}
*/
async clearTextureCache() {
try {
await MV.clearTextureCache(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 设置支持任意透明度
* @memberOf MapView
*
* @param support true(支持矢量数据或者瓦片数据中的任意透明度值) false(仅支持全透)
* @returns {Promise<void>}
*/
async setSupportTransparency(support) {
try {
await MV.setSupportTransparency(this._MGMapViewId, support);
} catch (e) {
console.error(e);
}
}
/**
* 是否支持任意透明度
* @memberOf MapView
* @returns {Promise<boolean>}
*/
async isSupportTransparency() {
try {
var { isSupportTransparency } = await MV.isSupportTransparency(
this._MGMapViewId
);
return isSupportTransparency;
} catch (e) {
console.error(e);
}
}
/**
* 设置自定义的地图工具
* @memberOf MapView
* @returns {Promise<void>}
*/
async setMapTool() {
try {
await MV.setMapTool(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 获取地图视图测量宽度
* @memberOf MapView
* @returns {Promise<Number>} 返回测量宽度
*/
async getMeasuredWidth(){
try {
return await MV.getMeasuredWidth(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 获取地图视图测量高度
* @memberOf MapView
* @returns {Promise<Number>} 返回测量高度
*/
async getMeasuredHeight(){
try {
return await MV.getMeasuredHeight(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 获取地图视图宽度
* @memberOf MapView
* @returns {Promise<Number>} 返回宽度
*/
async getWidth(){
try {
return await MV.getWidth(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 获取地图视图高度
* @memberOf MapView
* @returns {Promise<Number>} 返回高度
*/
async getHeight(){
try {
return await MV.getHeight(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 获取当前地图视图的快照（截图）并返回图片路径
* @memberOf MapView
* @param path 截图存储的文件夹路径
* @returns {Promise<String>} 成功--图片路径不为“”， 失败---图片路径为“”
*/
async getScreenSnapshot(path) {
try {
let bitmapPath = MV.getScreenSnapshot(this._MGMapViewId, path);
return bitmapPath;
} catch (e) {
console.error(e);
}
}
/**
* 获取当前地图视图指定区域的快照（截图）,视图区域的指定采用视图坐标系,通过左上角点的坐标和区域的宽高来确定,视图左上角坐标为(0, 0)<br>
* 如果指定区域超出视图范围,则超出部分以透明色填充
* @memberOf MapView
* @param path 截图的存储文件夹路径
* @param left 指定视图区域的左上角点的x坐标
* @param top 指定视图区域的左上角点的y坐标
* @param width 指定视图区域的宽度
* @param height 指定视图区域的高度
* @returns {Promise<Object>} 返回的是包含left, top ,width, height, bitmapPath的Object，若bitmapPath为“”，表示截屏失败
*/
async getScreenSnapshotByParam(path, left, top, width, height) {
try {
let result = await MV.getScreenSnapshotByParam(this._MGMapViewId, path, left, top, width, height);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 根据指定的地图范围绘制地图，将绘制返回的图片存储在指定文件夹下.
* <p>
* 详细说明:<br>
* 地图范围的指定采用地图坐标,成生的图像的宽高由用户在构造Bitmap对象时指定.<br>
* 生成的图像不包含地图视图的背景色.<br>
* 生成的图像含有透明通道,在视图上显示时,需要设置视图的背景颜色.如:可以设为地图视图的背景色.<br>
* 特别说明:<br>
* 用户构造的Bitmap像素格式必须为ARGB_8888<br>
* 示例代码:<br>
* 无<br>
* </p>
* @memberOf MapView
* @param dispRange 指定的出图范围
* @param path 图片存储的文件夹路径
* @params params Object
* width int
* height int
* type string png, jpg/jpeg, webp
* @returns {Promise.<String>} 返回的是图片存储路径，若路径为“”，表示出图失败
*/
async getBitmap(dispRange, path, params = {}) {
try {
let paramss = {
width: 2000,
height: 2000,
type: 'png',
dispRange: dispRange,
path: path,
};
Object.assign(paramss, params);
let bitmapPath = await MV.getBitmap(
this._MGMapViewId,
paramss.dispRange._MGRectId,
paramss.path,
paramss.width,
paramss.height,
paramss.type
);
return bitmapPath;
} catch (e) {
console.error(e);
}
}
/**
* 根据传入的参数生成，对应路口的放大图<br>
* 用户构造的Bitmap像素格式必须为ARGB_8888
* @memberOf MapView
* @param seg1 路口前一段路的地图坐标
* @param seg2 路口后一段路的地图坐标
* @param seg3 如果路口是环岛，则需要传入环岛下一段路的地图坐标
* @params params Object
* width int
* height int
* quality int 0 - 100
* type string png, jpg/jpeg, webp
* @returns {Promise.<{result: Promise.result, uri: Promise.uri}>}
*/
async getCrossBitmap(seg1, seg2, seg3, params = {}) {
try {
let paramss = {
width: 2000,
height: 2000,
quality: 60,
type: 'png',
seg1: seg1,
seg2: seg2,
seg3: seg3,
};
Object.assign(paramss, params);
let { result, uri } = await MV.getCrossBitmap(
this._MGMapViewId,
paramss.seg1,
paramss.seg2,
paramss.seg3,
paramss.width,
paramss.height,
paramss.quality,
paramss.type
);
return { result, uri };
} catch (e) {
console.error(e);
}
}
/**
* 显示放大镜.放大地图视图上指定区域的内容
* @memberOf MapView
* @param viewPointF 放大区域的中心点
* @param option 放大镜选项
* @returns {Promise<void>}
*/
async showMagnifier(viewPointF, option) {
try {
await MV.showMagnifier(
this._MGMapViewId,
viewPointF._MGPointFId,
option._MGMagnifierOptionId
);
} catch (e) {
console.error(e);
}
}
/**
* 隐藏放大镜
* @memberOf MapView
* @returns {Promise<void>}
*/
async hideMagnifier() {
try {
await MV.hideMagnifier(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 打开放大镜功能 .当手指在屏幕上移动时，可自动放大手指所在位置的内容
* @memberOf MapView
* @param magnifierOption 放大镜选项
* @returns {Promise<void>}
*/
async turnOnMagnifier(magnifierOption) {
try {
await MV.turnOnMagnifier(
this._MGMapViewId,
magnifierOption._MGMagnifierOptionId
);
} catch (e) {
console.error(e);
}
}
/**
* 关闭放大镜功能
* @memberOf MapView
* @returns {Promise<void>}
*/
async turnOffMagnifier() {
try {
await MV.turnOffMagnifier(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 设置是否显示指北针图标
* @memberOf MapView
*
* @param {Boolean} show的值为true时显示指北针图标，反正不显示指北针图标
* @returns {Promise<void>}
*/
async setShowNorthArrow(show) {
try {
await MV.setShowNorthArrow(this._MGMapViewId, show);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否显示指北针图标
* @memberOf MapView
* @returns {Promise<Boolean>} 返回值为true时，显示指北针图标。反之，没有显示指北针图标
*/
async isShowNorthArrow() {
try {
var { isShowNorthArrow } = await MV.isShowNorthArrow(this._MGMapViewId);
return isShowNorthArrow;
} catch (e) {
console.error(e);
}
}
/**
* 设置指北针图标在地图视图中的显示位置
* @memberOf MapView *
* @param point 指北针图标的中心在地图视图中的坐标
* @returns {Promise<void>}
*/
async setNorthArrowPosition(point) {
try {
await MV.setNorthArrowPosition(this._MGMapViewId, point._MGPointFId);
} catch (e) {
console.error(e);
}
}
/**
* 获取指北针图标中心点在地图视图中的显示位置
* @memberOf MapView
* @returns {Promise<PointF>}
*/
async getNorthArrowPosition() {
try {
var { pointFId, x, y } = await MV.getRotateCenter(this._MGMapViewId);
var pointf = new PointF();
pointf._MGDotId = pointFId;
pointf.x = x;
pointf.y = y;
return pointf;
} catch (e) {
console.error(e);
}
}
/**
* 设置指北针图标
* @memberOf MapView
* @param image 指北针图标位图
* @returns {Promise<void>}
*/
async setNorthArrowImage(image) {
try {
await MV.setNorthArrowImage(this._MGMapViewId, image._MGImageId);
} catch (e) {
console.error(e);
}
}
/**
* 设置是否显示中地公司logo
* @memberOf MapView *
* @param show 值为true时显示，反之，不显示
* @returns {Promise<void>}
*/
async setShowLogo(show) {
try {
await MV.setShowLogo(this._MGMapViewId, show);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否显示中地公司logo
* @memberOf MapView
* @returns {Promise<Boolean>} 值为true时显示，反之，没显示
*/
async isShowLogo() {
try {
var { isShowLogo } = await MV.isShowLogo(this._MGMapViewId);
return isShowLogo;
} catch (e) {
console.error(e);
}
}
/**
* 设置中地公司logo在地图视图中显示的位置
* @memberOf MapView
* @param position logo的方位
* @see LOGO_POSITION_BOTTOM_LEFT等
* @returns {Promise<void>}
*/
async setLogoPoistion(position) {
try {
await MV.setShowLogo(this._MGMapViewId, position);
} catch (e) {
console.error(e);
}
}
/**
* 获取中地公司logo在地图视图中的显示位置
* @memberOf MapView
* @returns {Promise<int>} 中地公司logo在地图视图中的显示位置
* @see LOGO_POSITION_BOTTOM_LEFT等
*/
async getLogoPoistion() {
try {
var { LogoPoistion } = await MV.getLogoPoistion(this._MGMapViewId);
return LogoPoistion;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否显示比例尺
* @memberOf MapView
* @param show 值为true时显示，反之，不显示
* @returns {Promise<void>}
*/
async setShowScaleBar(show) {
try {
await MV.setShowScaleBar(this._MGMapViewId, show);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否显示比例尺
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时显示，反之，没显示
*/
async isShowScaleBar() {
try {
var { isShowScaleBar } = await MV.isShowScaleBar(this._MGMapViewId);
return isShowScaleBar;
} catch (e) {
console.error(e);
}
}
/**
* 设置比例尺在地图视图中显示的位置
* @memberOf MapView
* @param point 视图坐标
* @returns {Promise<void>}
*/
async setScaleBarPoistion(pointf) {
try {
await MV.setShowScaleBar(this._MGMapViewId, pointf._MGPointFId);
} catch (e) {
console.error(e);
}
}
/**
* 获取比例尺在地图视图中的显示位置
* @memberOf MapView
* @returns {Promise<PointF>} 比例尺在地图视图中的显示位置
*/
async getScaleBarPoistion() {
try {
var { pointFId, x, y } = await MV.getScaleBarPoistion(this._MGMapViewId);
var pointf = new PointF();
pointf._MGDotId = pointFId;
pointf.x = x;
pointf.y = y;
return pointf;
} catch (e) {
console.error(e);
}
}
/**
* 设置天空图片
* @memberOf MapView
* @param image 天空图片
* @returns {Promise<void>}
*/
async setSkyImage(image) {
try {
await MV.setSkyImage(this._MGMapViewId, image._MGImageId);
} catch (e) {
console.error(e);
}
}
/**
* 设置天空场景是否启用,天空场景启用后,倾斜角可以加大到65度,默认情况下,天空场景处于启用状态
* @memberOf MapView
* @param enabled 天空场景是否启用
* @returns {Promise<void>}
*/
async setSkySceneEnabled(enabled) {
try {
await MV.setSkySceneEnabled(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取天空场景是否启用的标志
* @memberOf MapView
* @returns {Promise<boolean>} 天空场景是否启用的标志
*/
async isSkySceneEnabled() {
try {
var { isSkySceneEnabled } = await MV.isSkySceneEnabled(this._MGMapViewId);
return isSkySceneEnabled;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否启用MapView内置的地图放大、缩小按钮。通过内置的缩放按钮，可实现对地图的放大和缩小
* @memberOf MapView
* @param enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setZoomControlsEnabled(enabled) {
try {
await MV.setZoomControlsEnabled(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 设置缩放按钮的位置
*
* @memberof MapView
* @param {PointF} pointF 位置点
* @returns {Promise<void>}
*/
async setZoomControlPosition(pointF){
try {
await MV.setZoomControlPosition(this._MGMapViewId, pointF._MGPointFId);
} catch (e) {
console.error(e);
}
}
/**
* 获取缩放按钮的位置
*
* @memberof MapView
* @returns {Promise<PointF>} 缩放按钮的位置
*/
async getZoomControlPosition(pointF){
try {
let pointFId = await MV.getZoomControlPosition(this._MGMapViewId);
let pointF = null;
if(pointFId !== null){
pointF = new PointF();
pointF._MGPointFId = pointFId;
}
return pointF;
} catch (e) {
console.error(e);
}
}
/**
* 获取是否启用了内置的缩放按钮
* @memberOf MapView
* @returns {Promise<boolean>} 缩放按钮是否启用
*/
async isZoomControlsEnabled() {
try {
var { isZoomControlsEnabled } = await MV.isZoomControlsEnabled(
this._MGMapViewId
);
return isZoomControlsEnabled;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否启用地图平移手势
* @memberOf MapView
* @param enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setMapPanGesturesEnabled(enabled) {
try {
await MV.setMapPanGesturesEnabled(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否启用了平移手势
* @memberOf MapView
* @returns {Promise<boolean>} 是否启用了平移手势
*/
async isMapPanGesturesEnabled() {
try {
var { isMapPanGesturesEnabled } = await MV.isMapPanGesturesEnabled(
this._MGMapViewId
);
return isMapPanGesturesEnabled;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否启用地图缩放手势
* @memberOf MapView
* @param enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setMapZoomGesturesEnabled(enabled) {
try {
await MV.setMapZoomGesturesEnabled(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否启用了地图缩放手势
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时启用，反之，不启用
*/
async isMapZoomGesturesEnabled() {
try {
var { isMapZoomGesturesEnabled } = await MV.isMapZoomGesturesEnabled(
this._MGMapViewId
);
return isMapZoomGesturesEnabled;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否启用地图旋转手势
* @memberOf MapView *
* @param enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setMapRotateGesturesEnabled(enabled) {
try {
await MV.setMapRotateGesturesEnabled(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否启用了地图旋转手势
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时启用，反之，不启用
*/
async isMapRotateGesturesEnabled() {
try {
var { isMapRotateGesturesEnabled } = await MV.isMapRotateGesturesEnabled(
this._MGMapViewId
);
return isMapRotateGesturesEnabled;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否启用地图倾斜手势
* @memberOf MapView
* @param enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setMapSlopeGesturesEnabled(enabled) {
try {
await MV.setMapSlopeGesturesEnabled(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否启用了地图倾斜手势
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时启用，反之，不启用
*/
async isMapSlopeGesturesEnabled() {
try {
var { isMapSlopeGesturesEnabled } = await MV.isMapSlopeGesturesEnabled(
this._MGMapViewId
);
return isMapSlopeGesturesEnabled;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否双击放大地图
* @memberOf MapView
* @param {Boolean} enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setDoubleTapZooming(enabled) {
try {
await MV.setDoubleTapZooming(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否双击放大地图
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时启用，反之，不启用
*/
async isDoubleTapZooming() {
try {
var { isDoubleTapZooming } = await MV.isDoubleTapZooming(
this._MGMapViewId
);
return isDoubleTapZooming;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否双指单击缩小地图
* @memberOf MapView
* @param {Boolean} enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setTwoFingerTapZooming(enabled) {
try {
await MV.setTwoFingerTapZooming(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否双指单击缩小地图
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时启用，反之，不启用
*/
async isTwoFingerTapZooming() {
try {
var { isTwoFingerTapZooming } = await MV.isTwoFingerTapZooming(
this._MGMapViewId
);
return isTwoFingerTapZooming;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否启用平移结束后的动画
* @memberOf MapView
* @param enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setPanEndAnimating(enabled) {
try {
await MV.setPanEndAnimating(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否启用平移结束后的动画
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时启用，反之，不启用
*/
async isPanEndAnimating() {
try {
var { isPanEndAnimating } = await MV.isPanEndAnimating(this._MGMapViewId);
return isPanEndAnimating;
} catch (e) {
console.error(e);
}
}
/**
* 设置是否启用标记渲染的动画
* @memberOf MapView
* @param enabled 值为true时启用，反之，不启用
* @returns {Promise<void>}
*/
async setLabelRenderAnimating(enabled) {
try {
await MV.setLabelRenderAnimating(this._MGMapViewId, enabled);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否启用标记渲染的动画
* @memberOf MapView
* @returns {Promise<boolean>} 值为true时启用，反之，不启用
*/
async isLabelRenderAnimating() {
try {
var { isLabelRenderAnimating } = await MV.isLabelRenderAnimating(
this._MGMapViewId
);
return isLabelRenderAnimating;
} catch (e) {
console.error(e);
}
}
/**
* 添加单击事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerTapListener() {
try {
await MV.registerTapListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除单击事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterTapListener() {
try {
await MV.unregisterTapListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 添加长按事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerLongTapListener() {
try {
await MV.registerLongTapListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除长按事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterLongTapListener() {
try {
await MV.unregisterLongTapListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 添加双击事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerDoubleTapListener() {
try {
await MV.registerDoubleTapListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除双击事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterDoubleTapListener() {
try {
await MV.unregisterDoubleTapListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 添加触摸事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerTouchListener() {
try {
await MV.registerTouchListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除触摸事件监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterTouchListener() {
try {
await MV.unregisterTouchListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 添加地图视图级别改变的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerZoomChangedListener() {
try {
await MV.registerZoomChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图视图级别改变的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterZoomChangedListener() {
try {
await MV.unregisterZoomChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 添加地图视图中心点变化的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerCenterChangedListener() {
try {
await MV.registerCenterChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图视图中心点变化的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterCenterChangedListener() {
try {
await MV.unregisterCenterChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 添加地图视图旋转角度变化的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerRotateChangedListener() {
try {
await MV.registerRotateChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图视图旋转角度变化的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterRotateChangedListener() {
try {
await MV.unregisterRotateChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 地图视图地图位置变化的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerPositionChangedListener() {
try {
await MV.registerPositionChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图视图地图位置变化的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterPositionChangedListener() {
try {
await MV.unregisterPositionChangedListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 地图视图动画的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerAnimationListener() {
try {
await MV.registerAnimationListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图视图动画的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterAnimationListener() {
try {
await MV.unregisterAnimationListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 地图视图刷新的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerRefreshListener() {
try {
await MV.registerRefreshListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图视图刷新的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterRefreshListener() {
try {
await MV.unregisterRefreshListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 地图视图地图加载的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerMapLoadListener() {
try {
await MV.registerMapLoadListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图加载监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterMapLoadListener() {
try {
await MV.unregisterMapLoadListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 地图视图标记的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async registerAnnotationListener() {
try {
await MV.registerAnnotationListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 移除地图视图标记的监听
* @memberOf MapView
* @returns {Promise<void>}
*/
async unregisterAnnotationListener() {
try {
await MV.unregisterAnnotationListener(this._MGMapViewId);
} catch (e) {
console.error(e);
}
}
/**
* 对当前地图中指定图层应用卷帘效果
* 特别说明:由于移动端相邻的离线矢量图层是由同一个层渲染器渲染，所以对其中的任一离线矢量图层应用卷帘，会对相邻的所有离线矢量图层都起作用。
* @memberOf MapView
* @param swipeLayer 应用卷帘的图层,传null关闭卷帘效果
* @param {object}swipeRegionDots 卷帘区域(应用卷帘的图层被擦除的区域),为视图坐标,原点在视图的左上角,区域必须为闭合区（首尾点应重合）
* @returns {Promise<Number>} 0:失败,1:成功
*/
async swipe(swipeLayer, swipeRegionDots) {
try {
let { iResVal } = await MV.swipe(
swipeLayer._MGMapLayerId,
swipeRegionDots._MGDotsId
);
return iResVal;
} catch (e) {
console.error(e);
}
}
}