# Source: MapView.js

    /**
     * @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);
        }
      }
    }