Source: VectorLayer.js

/*
 * @Description: In User Settings Edit
 * @Author: fjl
 * @Date: 2019-09-06 16:27:38
 * @LastEditTime: 2019-09-23 10:26:21
 * @LastEditors: mayuanye
 */
/**
 * @content android视图点对象功能组件
 * @author fjl 2019-6-24 下午2:52:36
 */
import { NativeModules } from 'react-native';
import MapLayer from './MapLayer';
import LinInfo from './LinInfo.js';
import Fields from './Fields.js';
let VL = NativeModules.JSVectorLayer;

/**
 * @class VectorLayer
 */
export default class VectorLayer extends MapLayer {
  constructor() {
    super();
    Object.defineProperty(this, '_MGVectorLayerId', {
      get: function() {
        return this._MGMapLayerId;
      },
      set: function(_MGVectorLayerId) {
        this._MGMapLayerId = _MGVectorLayerId;
      },
    });
  }

  /**
   * 通过int类型的VectorLayreType构造一个新的 VectorLayer 对象。
   * @memberOf VectorLayer
   * @returns {Promise.<VectorLayer>}
   */
  async createObj() {
    try {
      var { VectorLayerId } = await VL.createObj(arguments[0]);
      var graphic = new VectorLayer();
      graphic._MGVectorLayerId = VectorLayerId;
      return graphic;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取符号比
   *
   * @memberOf VectorLayer
   * @returns {Number} 符号比 -- double类型
   *
   */
  async getSymbolScale() {
    try {
      let symbolScale = await VL.getSymbolScale(this._MGVectorLayerId);
      return symbolScale;
    } catch (e) {
      console.error(e);
    }
  }

  // /**
  //  * 设置符号比
  //  *
  //  * @memberOf VectorLayer
  //  * @param {Number} symbolScale 符号比 -- double类型
  //  * @returns {Promise<Void>}
  //  */
  // async setSymbolScale(symbolScale){
  //   try {
  //     await VL.setSymbolScale(this._MGVectorLayerId, symbolScale);
  //   } catch (e) {
  //     console.error(e);
  //   }
  // }

  //  /**
  //   * 获取系统库
  //   *
  //   * @memberOf VectorLayer
  //   * @returns {String} 系统库 -- UUID转换后的String
  //  */
  // async getSystemLib(){
  //   try {
  //     let systemLib = await VL.getSystemLib(this._MGVectorLayerId);
  //     return systemLib;
  //   } catch (e) {
  //     console.error(e);
  //   }
  // }

  // /**
  //  * 设置系统库
  //  *
  //  * @memberOf VectorLayer
  //  * @param {String} lib 系统库 -- UUID转换后的String
  //  * @returns {Promise<Void>}
  //  */
  // async setSystemLib(lib){
  //   try {
  //     await VL.setSystemLib(this._MGVectorLayerId, lib);
  //   } catch (e) {
  //     console.error(e);
  //   }
  // }

  /**
   * 获取是否符号化显示
   * @memberOf VectorLayer
   * @returns {Promise<*>}
   */
  async isSymbolShow() {
    try {
      let isSymbolShow = await VL.isSymbolShow(this._MGVectorLayerId);
      return isSymbolShow;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置符号化显示
   * @memberOf VectorLayer
   * @param symbolShow
   * @returns {Promise<void>}
   */
  async setSymbolShow(symbolShow) {
    try {
      await VL.setSymbolShow(this._MGVectorLayerId, symbolShow);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 是否跟随缩放
   *
   * @memberOf VectorLayer
   * @returns {boolean}
   */
  async isFollowZoom() {
    try {
      let followZoom = await VL.isFollowZoom(this._MGVectorLayerId);
      return followZoom;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否跟随缩放
   * @memberOf VectorLayer
   * @param {boolean} followZoom 跟随缩放
   * @returns {Promise<Void>}
   *
   */
  async setFollowZoom(followZoom) {
    try {
      await VL.setFollowZoom(this._MGVectorLayerId, followZoom);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取最小可见图形大小
   * @memberOf VectorLayer
   * @returns {Number} 最小可见图形大小 -- double类型
   */
  async getMinVisibleGeomSize() {
    try {
      let minVisibleGeomSize = await VL.getMinVisibleGeomSize(
        this._MGVectorLayerId
      );
      return minVisibleGeomSize;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置最小可见图形大小
   *
   * @memberOf VectorLayer
   * @param {Number} minVisibleGeomSize 最小可见图形大小 -- double类型
   * @returns {}
   *
   */
  async setMinVisibleGeomSize(minVisibleGeomSize) {
    try {
      await VL.setMinVisibleGeomSize(this._MGVectorLayerId, minVisibleGeomSize);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取透明度
   * @memberOf VectorLayer
   *
   * @return  透明度,0-100 默认为0,表示不透明。
   */
  async getTransparency() {
    try {
      let transparency = await VL.getTransparency(this._MGVectorLayerId);
      return transparency;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置透明度,0-100 默认为0,表示不透明
   * @memberOf VectorLayer
   * @param {Number} transparency 透明度 -- 处于short数值范围的int类型的Number
   * @returns {Promise<void>} 1：成功，0：失败。
   */
  async setTransparency(transparency) {
    try {
      await VL.setTransparency(this._MGVectorLayerId, transparency);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取字段集合
   *
   * @memberOf VectorLayer
   * @returns {Promise<Fields>} 返回Fields对象
   */
  async getFields() {
    try {
      var { FieldsId } = await VL.getFields(this._MGVectorLayerId);
      var fields = null;
      if (FieldsId != null) {
        fields = new Fields();
        fields._MGFieldsId = FieldsId;
      }
      return fields;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置区域边界线图形信息
   *
   * @memberOf VectorLayer
   * @param {LinInfo} linInfo 线图形信息
   * @returns {Promise<Void>}
   */
  async setRegBorderLinInfo(linInfo) {
    try {
      await VL.setRegBorderLinInfo(this._MGVectorLayerId, linInfo._MGLinInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取区域边界线图形信息
   *
   * @memberOf VectorLayer
   * @returns {Promise<LinInfo>} 成功返回线图形信息
   */
  async getRegBorderLinInfo() {
    try {
      var { LinInfoId } = await VL.getRegBorderLinInfo(this._MGVectorLayerId);
      var linInfo = null;
      if (LinInfoId != null) {
        linInfo = new LinInfo();
        linInfo._MGLinInfoId - LinInfoId;
      }
      return linInfo;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 生成一个UUID字符串
   * @memberOf VectorLayer
   * @returns {String} UUID对应的字符串
   */
  async generateUUID() {
    try {
      let uuid = await VL.generateUUID();
      return uuid;
    } catch (e) {
      console.error(e);
    }
  }
}