Source: ModelsOverlay.js

/*
 * @Description: In User Settings Edit
 * @Author: xiaoying
 * @Date: 2019-09-09 19:59:19
 * @LastEditTime: 2019-09-16 17:41:33
 * @LastEditors: mayuanye
 */
import { NativeModules } from 'react-native';
import Model from './Model';
let MO = NativeModules.JSModelsOverlay;

/**
 * @class ModelsOverlay
 * @description 模型层
 */
export default class ModelsOverlay {
  /**
   * 构造一个新的ModelsOverlay对象
   *
   * @memberof ModelsOverlay
   * @returns {Promise<ModelsOverlay>}
   */
  async createObj() {
    try {
      var { ModelsOverlayId } = await MO.createObj();
      var modelsOverlay = new ModelsOverlay();
      modelsOverlay._MGModelsOverlayId = ModelsOverlayId;
      return modelsOverlay;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 添加一个模型
   *
   * @memberof ModelsOverlay
   * @param {Object} model 模型（Model类型的Object）
   * @returns {Promise<Void>}
   */
  async addModel(model) {
    try {
      await MO.addModel(this._MGModelsOverlayId, model._MGModelId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 添加一组模型
   *
   * @memberof ModelsOverlay
   * @param {Array} models  一组模型 （存有Model对象的Id的数组）
   * @returns {Promise<Void>}
   */
  async addModels(models) {
    try {
      // 将存有Model对象的数组转换成包含model对象Id的数组
      let modelIds = [];
      if (models != null) {
        for (let i = 0; i < models.length; i++) {
          let modelId = models[i]._MGModelId;
          modelIds.push(modelId);
        }
        await MO.addModels(this._MGModelsOverlayId, modelIds);
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 删除指定索引的模型
   *
   * @memberof ModelsOverlay
   * @param {Number} index 索引 （int类型的Number）
   * @returns {Promise<Void>}
   */
  async removeModelByIndex(index) {
    try {
      await MO.removeModelByIndex(this._MGModelsOverlayId, index);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 删除一个模型
   *
   * @memberof ModelsOverlay
   * @param {Object} model 模型 （Model类型的Object）
   * @returns {Promise<Void>}
   */
  async removeModel(model) {
    try {
      await MO.removeModel(this._MGModelsOverlayId, model._MGModelId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 删除一组模型
   *
   * @memberof ModelsOverlay
   * @param {Array} models 一组模型 （包含Model对象的数组）
   * @returns {Promise<Void>}
   */
  async removeModels(models) {
    try {
      let modelIds = [];
      if (models != null) {
        for (let i = 0; i < models.length; i++) {
          modelIds.push(models[i]._MGModelId);
        }
        await MO.removeModels(this._MGModelsOverlayId, modelIds);
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 删除所有模型
   *
   * @memberof ModelsOverlay
   * @returns {Promise<Void>}
   */
  async removeAllModels() {
    try {
      await MO.removeAllModels(this._MGModelsOverlayId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型数目
   *
   * @memberof ModelsOverlay
   * @returns {Number} 模型数目 （int类型的Number）
   */
  async getModelCount() {
    try {
      let count = await MO.getModelCount(this._MGModelsOverlayId);
      return count;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取模型的索引
   *
   * @memberof ModelsOverlay
   * @param {Object} model 模型 （Model类型的Object）
   * @returns {Number} 模型索引 -1表示没有找到该模型 （int类型的Number）
   */
  async indexOf(model) {
    try {
      let index = await MO.indexOf(this._MGModelsOverlayId, model._MGModelId);
      return index;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取指定索引的模型
   *
   * @memberof ModelsOverlay
   * @param {Number} index 模型索引 从0开始 （int类型的Number）
   * @returns {Promise<Model>} 索引对应的模型
   */
  async getModel(index) {
    try {
      var { ModelId } = await MO.getModel(this._MGModelsOverlayId, index);
      var model = null;
      if (ModelId != null) {
        model = new Model();
        model._MGModelId = ModelId;
      }

      return model;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取所有模型
   *
   * @memberof ModelsOverlay
   * @returns {Array} 模型列表 （包含一组Model对象的数组）
   */
  async getAllModels() {
    try {
      var models = await MO.getAllModels(this._MGModelsOverlayId);
      let modelArray = [];
      for (let i = 0; i < models.length; i++) {
        let model = new Model();
        model._MGModelId = models[i];
        modelArray.push(model);
      }
      return modelArray;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   *  移动模型,改变模型的层次序列
   *
   * @memberof ModelsOverlay
   * @param {Number} fromIndex 被移动的模型的索引  （int类型的Number）
   * @param {Number} toIndex 移动模型到toIndex处,如果toIndex为-1 表示移动到最上面  （int类型的Number）
   * @returns {Promise<Void>}
   */
  async moveModel(fromIndex, toIndex) {
    try {
      await MO.moveModel(this._MGModelsOverlayId, fromIndex, toIndex);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   *  保存所有的模型覆盖物到文件中,可以通过该文件构建模型层
   * <p>
   * 示例代码:<br>
   * String strModelFile = ""; modelsOverlay.saveToFile(strModelFile,false);
   * SimpleModelLayer modelLayer = new SimpleModelLayer();
   * modelLayer.setURL(strModelFile); mapView.stopCurRequest(new
   * MapViewStopCurRequestCallback() {
   *
   * public void onDidStopCurRequest() {
   *           mapView.getMap().append(modelLayer); mapView.forceRefresh(); }
   *           });
   *           </p>
   *
   * @memberof ModelsOverlay
   * @param {String} strModelFile 模型文件
   * @param {boolean} trunc 如果文件存在true表示截断,false表示追加
   * @returns {boolean} true-成功 ； false-失败
   */
  async saveToFile(strModelFile, toIndex) {
    try {
      let result = await MO.saveToFile(
        this._MGModelsOverlayId,
        strModelFile,
        toIndex
      );
      return result;
    } catch (e) {
      console.error(e);
    }
  }
}