# Source: GraphicsOverlays.js

    /**
     * @content 覆盖物对象功能组件
     * @author fjl 2019-6-21 下午2:52:36
     */
    import { NativeModules } from 'react-native';

    let X = NativeModules.JSGraphicsOverlays;
    import GraphicsOverlay from './GraphicsOverlay.js';

    /**
     * @class GraphicsOverlays
     */
    export default class GraphicsOverlays {
      /**
       * 构造一个新的 GraphicsOverlays 对象。
       * @memberOf GraphicsOverlays
       * @returns {Promise.<GraphicsOverlays>}
       */
      async createObj() {
        try {
          var { GraphicsOverlaysId } = await X.createObj();
          var graphicsOverlays = new GraphicsOverlays();
          graphicsOverlays._MGGraphicsOverlaysId = GraphicsOverlaysId;
          return graphicsOverlays;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 添加图形覆盖物
       * @memberOf GraphicsOverlays
       * @param graphicsOverlay
       * @returns {Promise<void>}
       */
      async add(graphicsOverlay) {
        try {
          await X.add(
            this._MGGraphicsOverlaysId,
            graphicsOverlay._MGGraphicsOverlayId
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取图形覆盖物的数目
       * @memberOf GraphicsOverlays
       * @returns {Promise<*>}
       */
      async getCount() {
        try {
          let name = await X.getCount(this._MGGraphicsOverlaysId);

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

      /**
       * 获取图形覆盖物的索引
       * @memberOf GraphicsOverlays
       * @param graphicsOverlay
       * @returns {Promise<*|NavigationPreloadState>}
       */
      async indexOf(graphicsOverlay) {
        try {
          let index = await X.indexOf(
            this._MGGraphicsOverlaysId,
            graphicsOverlay._MGGraphicsOverlayId
          );
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取图形覆盖物的索引
       * @memberOf GraphicsOverlays
       * @param {String} graphicLayerName
       * @returns {Promise<*|NavigationPreloadState>}
       */
      async indexOfByName(graphicLayerName) {
        try {
          let index = await X.indexOfByName(
            this._MGGraphicsOverlaysId,
            graphicLayerName
          );
          return index;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取图形覆盖物
       * @memberOf GraphicsOverlays
       * @returns {Promise<*>}
       */
      async getGraphicsOverlay(index) {
        try {
          let { GraphicsOverlayId } = await X.getGraphicsOverlay(
            this._MGGraphicsOverlaysId,
            index
          );
          var graphicsOverlay = new GraphicsOverlay();
          graphicsOverlay._MGGraphicsOverlayId = GraphicsOverlayId;

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

      /**
       * 返回所有图形
       * @memberOf GraphicsOverlays
       * @returns {Promise<*>}
       */
      async getAllGraphicsOverlays() {
        try {
          var objArr = [];
          var  graphicOverlayArray = await X.getAllGraphicsOverlays(
            this._MGGraphicsOverlaysId
          );

          for (let i = 0; i < graphicOverlayArray.length; i++) {
            var graphicsOverlay = new GraphicsOverlay();
            graphicsOverlay._MGGraphicsOverlayId = graphicOverlayArray[i];
            objArr.push(graphicsOverlay);
          }
          return objArr;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 插入图形覆盖物
       * @memberOf GraphicsOverlays
       * @param graphicsOverlay 图形覆盖物
       * @returns {Promise<*|NavigationPreloadState>}
       */
      async insert(index, graphicsOverlay) {
        try {
          let result = await X.insert(
            this._MGGraphicsOverlaysId,
            index,
            graphicsOverlay._MGGraphicsOverlayId
          );

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

      /**
       * 移动图形覆盖物
       * @memberOf GraphicsOverlays
       * @param fromIndex
       * @param toIndex
       * @returns {Promise<*>}
       */
      async move(fromIndex, toIndex) {
        try {
          await X.move(this._MGGraphicsOverlaysId, fromIndex, toIndex);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 移除图形覆盖物
       * @memberOf GraphicsOverlays
       * @param index
       * @returns {Promise<void>}
       */
      async removeByIndex(index) {
        try {
          await X.remove(this._MGGraphicsOverlaysId, index);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 移除图形覆盖物
       * @memberOf GraphicsOverlays
       * @param graphicsOverlay
       * @returns {Promise<void>}
       */
      async remove(graphicsOverlay) {
        try {
          await X.move(
            this._MGGraphicsOverlaysId,
            graphicsOverlay._MGGraphicsOverlayId
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 移除所有图形覆盖物
       * @memberOf GraphicsOverlays
       * @param index
       * @returns {Promise<void>}
       */
      async removeAll() {
        try {
          await X.removeAll(this._MGGraphicsOverlaysId);
        } catch (e) {
          console.error(e);
        }
      }
    }