# Source: SpaProjection.js

    /**
     * @content 空间投影功能组件
     * @author  2019-09-25
     */
    import { NativeModules } from 'react-native';

    let SPP = NativeModules.JSSpaProjection;

    import SRefData from './SRefData.js';

    /**
     * @class SpaProjection
     * @description 空间投影
     */
    export default class SpaProjection {
      /**
       * 构造一个新的 SpaProjection 对象。
       * @memberOf SpaProjection
       * @returns {Promise.<SpaProjection>}
       */
      async createObj() {
        try {
          var { SpaProjectionId } = await SPP.createObj();
          var spaProjection = new SpaProjection();
          spaProjection._MGSpaProjectionId = SpaProjectionId;
          return spaProjection;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置源投影参数
       * @memberOf SpaProjection
       * @param {SRefData} sRef 源投影参数
       * @return {Promise.<int>} >0成功； <=0-失败
       */
      async setSourcePara(sRef) {
        try {
          return await SPP.setSourcePara(
            this._MGSpaProjectionId,
            sRef._MGSRefDataId
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取源投影参数
       * @memberOf SpaProjection
       * @return {Promise.<SRefData>} 源投影参数
       */
      async getSourcePara() {
        try {
          let { SRefDataId } = await SPP.getSourcePara(this._MGSpaProjectionId);
          var sRefData = new SRefData();
          sRefData._MGSRefDataId = SRefDataId;
          return sRefData;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置目标投影参数
       * @memberOf SpaProjection
       * @param {SRefData} sRef 目标投影参数
       * @return {Promise.<int>} >0成功； <=0-失败
       */
      async setDestinationPara(sRef) {
        try {
          return await SPP.setDestinationPara(
            this._MGSpaProjectionId,
            sRef._MGSRefDataId
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 取目标投影参数
       * @memberOf SpaProjection
       * @return {Promise.<SRefData>} 目标投影参数
       */
      async getDestinationPara() {
        try {
          let { SRefDataId } = await SPP.getDestinationPara(
            this._MGSpaProjectionId
          );
          var sRefData = new SRefData();
          sRefData._MGSRefDataId = SRefDataId;
          return sRefData;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置椭球坐标系变换参数的索引，当投影前后椭球体不一样时，必须设置椭球坐标系变换参数
       * @memberOf SpaProjection
       * @param {int} transID 椭球坐标系变换参数的索引,从0开始
       * @see ElpTransformation
       * @return {Promise.<int>} >0成功； <=0-失败
       */
      async setEllipTransId(transID) {
        try {
          return await SPP.setEllipTransId(this._MGSpaProjectionId, transID);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置椭球坐标系变换参数，当投影前后椭球体不一样时，必须设置椭球坐标系变换参数
       * @memberOf SpaProjection
       * @param {ElpTransParam} param 椭球坐标系变换参数
       * @return {Promise.<int>} >0成功； <=0-失败
       */
      async setEllipTransParam(param) {
        try {
          return await SPP.setEllipTransParam(
            this._MGSpaProjectionId,
            param._MGElpTransParamId
          );
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获得椭球坐标系变换参数的索引
       * @memberOf SpaProjection
       * @return {Promise.<int>} 椭球坐标系变换参数的索引
       * @see ElpTransformation
       */
      async getEllipTransId() {
        try {
          return await SPP.getEllipTransId(this._MGSpaProjectionId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 单点投影
       * @memberOf SpaProjection
       * @param {Dot} xy 点坐标
       * @return {Promise.<int>} >0成功； <=0-失败
       */
      async projTrans(xy) {
        try {
          return await SPP.projTrans(this._MGSpaProjectionId, xy._MGDotId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * WGS84 （度）到 web墨卡托投影（米）
       * @memberOf SpaProjection
       * @param {Dot} dot 点坐标
       * @return {Promise.<void>}
       */
      static async lonLat2Mercator(dot) {
        try {
          await SPP.lonLat2Mercator(dot._MGDotId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * web墨卡托投影（米）到 WGS84（度）
       * @memberOf SpaProjection
       * @param {Dot} dot 点坐标
       * @return {Promise.<void>}
       */
      static async mercator2LonLat(dot) {
        try {
          await SPP.mercator2LonLat(dot._MGDotId);
        } catch (e) {
          console.error(e);
        }
      }
    }