/*
* @Description: In User Settings Edit
* @Author: xiaoying
* @Date: 2019-09-10 10:46:01
* @LastEditTime: 2019-09-21 13:53:36
* @LastEditors: mayuanye
*/
import { NativeModules } from 'react-native';
import GroupLayer from './GroupLayer';
import VectorMapServer from './VectorMapServer.js';
import VectorTileMapServer from './VectorTileMapServer.js';
import OGCWMTSMapServer from './OGCWMTSMapServer.js';
import TileMapServer from './TileMapServer.js';
let SL = NativeModules.JSServerLayer;
/**
* @class ServerLayer
* @description 服务图层
*/
export default class ServerLayer extends GroupLayer {
constructor() {
super();
Object.defineProperty(this, '_MGServerLayerId', {
get: function() {
return this._MGGroupLayerId;
},
set: function(_MGServerLayerId) {
this._MGGroupLayerId = _MGServerLayerId;
},
});
}
/**
* 构造一个新的ServerLayer对象
*
* @memberof ServerLayer
* @returns {Promise<ServerLayer>}
*/
async createObj() {
try {
var { ServerLayerId } = await SL.createObj();
var serverLayer = new ServerLayer();
serverLayer._MGServerLayerId = ServerLayerId;
return serverLayer;
} catch (e) {
console.error(e);
}
}
/**
* 设置地图服务
*
* @memberof ServerLayer
* @param {Object} mapServer 地图服务对象 （MapServer类型的Object）
* @returns {Promise<Void>}
*/
async setMapServer(mapServer) {
try {
await SL.setMapServer(this._MGServerLayerId, mapServer._MGMapServerId);
} catch (e) {
console.error(e);
}
}
/**
* 设置服务图层的数据读取模式
*
* @memberof ServerLayer
* @param {Number} accessMode 地图服务访问模式（int类型的Number），例：1--MapServerAccessMode.ServerAndCache
* @returns {Promise<void>}
*/
async setAccessMode(accessMode) {
try {
await SL.setAccessMode(this._MGServerLayerId, accessMode);
} catch (e) {
console.error(e);
}
}
/**
* 获取地图服务
*
* @memberof ServerLayer
* @returns {Promise<MapServer>}
*/
async getMapServer() {
try {
var { MapServerId, MapBrowseType, Type } = await SL.getMapServer(
this._MGServerLayerId
);
let mapServer = ServerLayer.createMapServerByIdAndType(
MapServerId,
MapBrowseType,
Type
);
return mapServer;
} catch (e) {
console.error(e);
}
}
// 通过地图服务类型、地图浏览类型创建MapServer对象
static async createMapServerByIdAndType(mapServerId, mapBrowseType, type) {
let mapServer = null;
if (mapServerId != null) {
if (mapBrowseType === 1) {
// 地图浏览类型 -- 矢量
mapServer = new VectorMapServer();
mapServer._MGMapServerId = mapServerId;
} else if (mapBrowseType === 2) {
// 地图浏览类型 -- 矢量瓦片
mapServer = new VectorTileMapServer();
mapServer._MGMapServerId = mapServerId;
} else {
// 地图浏览类型 -- 任意
if (type != null) {
if (type === 'OGCWMTS') {
// 服务类型 -- OGCWMTS地图服务
mapServer = new OGCWMTSMapServer();
mapServer._MGMapServerId = mapServerId;
} else {
mapServer = new TileMapServer();
mapServer._MGMapServerId = mapServerId;
}
}
}
}
return mapServer;
}
/**
* 获取服务图层的数据读取模式
*
* @memberof ServerLayer
* @returns {Number} 地图服务访问模式（int类型的Number），例：1--MapServerAccessMode.ServerAndCache
*/
async getAccessMode() {
try {
let accessMode = await SL.getAccessMode(this._MGServerLayerId);
return accessMode;
} catch (e) {
console.error(e);
}
}
/**
* 设置服务URL
*
* @memberof ServerLayer
* @param {String} strURL 服务URL
* @returns {boolean} 成功返回true
*/
async setURL(strURL) {
try {
let result = await SL.setURL(this._MGServerLayerId, strURL);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 根据类型创建地图服务
*
* @memberof ServerLayer
* @param {String} type MapServer中的类型常量，如：MapServer.MapServerType.MAPSERVER_TYPE_OGC_WMS
* @returns {Promise<MapServer>} 返回创建好的MapServer对象
*/
static async createMapServer(type) {
try {
var { MapServerId, MapServerBrowseType, Type } = await SL.createMapServer(
type
);
let mapServer = null;
if (MapServerId !== '' && MapServerBrowseType !== -1) {
if (MapServerBrowseType === 1) {
mapServer = new VectorMapServer();
mapServer._MGMapServerId = MapServerId;
} else if (MapServerBrowseType === 2) {
mapServer = new VectorTileMapServer();
mapServer._MGMapServerId = MapServerId;
} else {
if (Type === 'OGCWMTS') {
mapServer = new OGCWMTSMapServer();
mapServer._MGMapServerId = MapServerId;
} else {
mapServer = new TileMapServer();
mapServer._MGMapServerId = MapServerId;
}
}
}
return mapServer;
} catch (e) {
console.error(e);
}
}
/**
* 清除缓存(内存缓存+本地文件缓存)
*
* @memberof ServerLayer
* @returns {Promise<Void>}
*/
async clearCache() {
try {
await SL.clearCache(this._MGServerLayerId);
} catch (e) {
console.error(e);
}
}
/**
* 设置是否开启自适应显示
*
* @memberof ServerLayer
* @param {boolean} flag true为开启,false不开启。默认情况下不开启。
* @returns {Promise<Void>}
*/
async setAutoScaleFlag(flag) {
try {
await SL.setAutoScaleFlag(this._MGServerLayerId, flag);
} catch (e) {
console.error(e);
}
}
/**
* 获取是否开启自适应显示。
*
* @memberof ServerLayer
* @returns {boolean} true为开启,false不开启。默认情况下不开启。
*/
async getAutoScaleFlag() {
try {
let result = await SL.getAutoScaleFlag(this._MGServerLayerId);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 设置缓存路径
*
* @memberof ServerLayer
* @param {String} strCacheLocation 缓存路径.用户需要保证该目录存在，否则设置失败。
* @returns {Number} 0:失败.1:成功（int类型的Number）
*/
async setCacheLocation(strCacheLocation) {
try {
let result = await SL.setCacheLocation(
this._MGServerLayerId,
strCacheLocation
);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 获取缓存路径。
*
* @memberof ServerLayer
* @returns {String} 缓存路径
*/
async getCacheLocation() {
try {
let result = await SL.getCacheLocation(this._MGServerLayerId);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 预缓存(可根据级别或者范围进行缓存)
* 该方法为异步方法，用户可以通过ServerLayer上的TilePreFetchListener获取预缓存的任务状态
*
* @memberof ServerLayer
* @param {Number} lMinZoom 预缓存的最小级别
* @param {Number} lMaxZoom 预缓存的最小级别
* @param {Object} rect 预缓存的空间范围 （Rect类型的Object）
* @memberof ServerLayer
* @returns {Number} （int类型的Number） >=0成功,返回任务ID,-1:没有设置MapServer,-2:MapServer类型不支持预缓存,-3:参数不合法.
* 任务ID,从0开始，用户可以通过该返回值区分不同的预缓存任务.
*/
async preFetch(lMinZoom, lMaxZoom, rect) {
try {
let result = await SL.preFetch(
this._MGServerLayerId,
lMinZoom,
lMaxZoom,
rect._MGRectId
);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 停止预缓存
*
* @memberof ServerLayer
* @param {Number} taskId 任务Id (int类型的Number)
* @returns {Number} >0成功 （int类型的Number）
*/
async stopFetch(taskId) {
try {
let result = await SL.stopFetch(this._MGServerLayerId, taskId);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 设置预缓存状态监听类
*
* @memberof ServerLayer
* @returns {Number} 1 ：成功，0：失败。
*/
async registerTilePreFetchListener() {
try {
let result = await SL.registerTilePreFetchListener(this._MGServerLayerId);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 移除预缓存状态监听类
*
* @memberof ServerLayer
* @returns {Object} 预缓存状态监听对象。
*/
async removeTilePreFetchListener() {
try {
await SL.removeTilePreFetchListener(this._MGServerLayerId);
} catch (e) {
console.error(e);
}
}
/**
* 设置透明度,0-100 默认为0,表示不透明
*
* @memberof ServerLayer
* @param {Number} trans 透明度，0-100的整数
* @returns {Number} 1：成功，0：失败。(int类型的Number)
*/
async setTransparency(trans) {
try {
let result = await SL.setTransparency(this._MGServerLayerId, trans);
return result;
} catch (e) {
console.error(e);
}
}
/**
* 获取透明度
*
* @memberof ServerLayer
* @returns {Number} 透明度,0-100的整数。 默认为0,表示不透明
*/
async getTransparency() {
try {
let result = await SL.getTransparency(this._MGServerLayerId);
return result;
} catch (e) {
console.error(e);
}
}
}