Source: GraphicImage.js

/**
 * @content 图片对象功能组件
 * @author fjl 2019-6-24 下午2:52:36
 */
import { NativeModules } from 'react-native';
import Graphic from './Graphic';
import Image from './Image';
import PointF from './PointF';
import Dot from './Dot';
import ObjectUtils from './components/ObjectUtils';
let GI = NativeModules.JSGraphicImage;

/**
 * @constructor GraphicImage
 */
export default class GraphicImage extends Graphic {
  constructor() {
    super();
    Object.defineProperty(this, '_MGGraphicImageId', {
      get: function() {
        return this._MGGraphicId;
      },
      set: function(_MGGraphicImageId) {
        this._MGGraphicId = _MGGraphicImageId;
      },
    });
  }

  /**
   * 构造一个新的 GraphicImage 对象。
   * @memberOf GraphicImage
   * @returns {Promise.<GraphicImage>}
   */
  async createObj() {
    try {
      var { GraphicImageId } = await GI.createObj();
      var graphicImage = new GraphicImage();
      graphicImage._MGGraphicImageId = GraphicImageId;
      return graphicImage;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 通过文件路径设置图片
   * @memberOf GraphicImage
   * @param {String} filePath
   * @returns {Promise<void>}
   */
  async setImageByFilePath(filePath) {
    try {
      if(this.isValid()){
        await GI.setImageFromPath(this._MGGraphicImageId, filePath);
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置图片
   * @memberOf GraphicImage
   * @param {Image} image
   * @returns {Promise<void>}
   */
  async setImage(image) {
    try {
      if(this.isValid() && ObjectUtils.isValidObject(image) && image.isValid()){
        await GI.setImage(this._MGGraphicImageId, image._MGImageId);
      } else {
        console.log('GraphicImage or image is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置位置
   * @memberOf GraphicImage
   * @param {Dot} point
   * @returns {Promise<void>}
   */
  async setPoint(point) {
    try {
      if(this.isValid() && ObjectUtils.isValidObject(point) && point.isValid()){
        await GI.setPoint(this._MGGraphicImageId, point._MGDotId);
      } else {
        console.log('GraphicImage or point is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置锚点
   * @memberOf GraphicImage
   * @param {PointF} anchorPoint 图片锚点的位置：左下角为(0,0),右上角为(1,1)
   * @returns {Promise<void>}
   */
  async setAnchorPoint(anchorPoint) {
    try {
      if(this.isValid() && ObjectUtils.isValidObject(anchorPoint) && anchorPoint.isValid()){
        await GI.setAnchorPoint(this._MGGraphicImageId, anchorPoint._MGPointFId);
      } else {
        console.log('GraphicImage or anchorPoint is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取锚点
   * @memberOf GraphicImage
   * @returns {Promise<PointF>}
   */
  async getAnchorPoint() {
    try {
      if(this.isValid()){
        let { PointFID } = await GI.getAnchorPoint(this._MGGraphicImageId);
        var pointF = new PointF();
        pointF._MGPointFId = PointFID;
        return pointF;
      } else {
        console.log('GraphicImage is invalid !');
      }
     
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置透明度
   * @memberOf GraphicImage
   * @param {Number} alpha 透明度：0(透明)-255(不透明)
   * @returns {Promise<void>}
   */
  async setAlpha(alpha) {
    try {
      if(this.isValid()){
        await GI.setAlpha(this._MGGraphicImageId, alpha);
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置旋转角度
   * @memberOf GraphicImage
   * @param {Number} rotateAngle
   * @returns {Promise<void>}
   */
  async setRotateAngle(rotateAngle) {
    try {
      if(this.isValid()){
        await GI.setRotateAngle(this._MGGraphicImageId, rotateAngle);
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否随地图倾斜
   * @memberOf GraphicImage
   * @param {Boolean} IsSlope
   * @returns {Promise<void>}
   */
  async setSlope(IsSlope) {
    try {
      if(this.isValid()){
        await GI.setSlope(this._MGGraphicImageId, IsSlope);
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图片
   * @memberOf GraphicImage
   * @returns {Promise<Image>}
   */
  async getImage() {
    try {
      if(this.isValid()){
        let { ImageID } = await GI.getImage(this._MGGraphicImageId);
        var image = new Image();
        image._MGImageId = ImageID;
        return image;
      } else {
        console.log('GraphicImage is invalid !');
      }
      
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取位置
   * @memberOf GraphicImage
   * @returns {Promise<Dot>}
   */
  async getPoint() {
    try {
      if(this.isValid()){
        var { dotID } = await GI.getPoint(this._MGGraphicImageId);
        var dot = new Dot();
        dot._MGDotId = dotID;
        return dot;
      } else {
        console.log('GraphicImage is invalid !');
      }
     
    } catch (e) {
      console.error(e);
    }
  }
  /**
   * 获取旋转角度
   * @memberOf GraphicImage
   * @returns {Promise<Number>}
   */
  async getRotateAngle() {
    try {
      if(this.isValid()){
        let rotateAngle = await GI.getRotateAngle(this._MGGraphicImageId);
 
        return rotateAngle;
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取透明度
   * @memberOf GraphicImage
   * @returns {Promise<Number>}
   */
  async getAlpha() {
    try {
      if(this.isValid()){
        let alpha = await GI.getAlpha(this._MGGraphicImageId);

        return alpha;
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取是否随地图倾斜
   * @memberOf GraphicImage
   * @returns {Promise<boolean>}
   */
  async isSlope() {
    try {
      if(this.isValid()){
        let isSlope = await GI.isSlope(this._MGGraphicImageId);
        return isSlope;
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图片宽度
   * @memberOf GraphicImage
   * @returns {Promise<Number>}
   */
  async getImageWidth() {
    try {
      if(this.isValid()){
        let imageWidth = await GI.getImageWidth(this._MGGraphicImageId);
        return imageWidth;
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图片高度
   * @memberOf GraphicImage
   * @returns {Promise<Number>}
   */
  async getImageHeight() {
    try {
      if(this.isValid()){
        let imageHeight = await GI.getImageHeight(this._MGGraphicImageId);
        
        return imageHeight;
      } else {
        console.log('GraphicImage is invalid !');
      }
    } catch (e) {
      console.error(e);
    }
  }
}