constructor(id, options) {

super();

this.mapId = id;

options = options || {};

this.server = options.server || 'https://www.supermapol.com';

this.successCallback = options.successCallback;

this.errorCallback = options.errorCallback;

this.credentialKey = options.credentialKey;

this.credentialValue = options.credentialValue;

this.withCredentials = options.withCredentials || false;

this.target = options.target || "map";

this.excludePortalProxyUrl = options.excludePortalProxyUrl || false;

this.serviceProxy = options.serviceProxy || null;

this.tiandituKey = options.tiandituKey;

//计数叠加图层，处理过的数量（成功和失败都会计数）

this.layerAdded = 0;

this.events = new Events(this, null, ["updateDataflowFeature"], true);

this.createMap(options.mapSetting);

this.createWebmap();

}

/**

createMap(mapSetting) {

let overlays, controls,interactions;

if (mapSetting) {

interactions = mapSetting.interactions;

overlays = mapSetting.overlays;

controls = mapSetting.controls;

}

this.map = new Map({

interactions: interactions,

overlays: overlays,

controls: controls,

target: this.target

});

mapSetting && this.registerMapEvent({

mapClickCallback: mapSetting.mapClickCallback

});

}

/**

registerMapEvent(mapSetting) {

let map = this.map;

map.on("click", function (evt) {

mapSetting.mapClickCallback && mapSetting.mapClickCallback(evt);

});

}

/**

createWebmap() {

let urlArr = this.server.split('');

if (urlArr[urlArr.length - 1] !== '/') {

this.server += '/';

}

let mapUrl = this.server + 'web/maps/' + this.mapId + '/map';

let filter = 'getUrlResource.json?url=';

if (this.excludePortalProxyUrl && this.server.indexOf(filter) > -1) {

//大屏需求,或者有加上代理的

let urlArray = this.server.split(filter);

if (urlArray.length > 1) {

mapUrl = urlArray[0] + filter + this.server + 'web/maps/' + this.mapId + '/map.json';

}

}

this.getMapInfo(mapUrl);

}

/**

getMapInfo(url) {

let that = this,

mapUrl = url;

if (url.indexOf('.json') === -1) {

//传递过来的url,没有包括.json,在这里加上。

mapUrl = `${url}.json`

}

FetchRequest.get(that.getRequestUrl(mapUrl), null, {

withCredentials: this.withCredentials

}).then(function (response) {

return response.json();

}).then(async function (mapInfo) {

if (mapInfo.succeed === false) {

that.errorCallback && that.errorCallback(mapInfo.error, 'getMapFaild', that.map);

return;

}

if(mapInfo.projection === 'EPSG:910111' || mapInfo.projection === 'EPSG:910112'){

// 早期数据存在的自定义坐标系 "EPSG:910111": "GCJ02MERCATOR"， "EPSG:910112": "BDMERCATOR"

mapInfo.projection = "EPSG:3857";

}else if(mapInfo.projection === 'EPSG:910101' || mapInfo.projection === 'EPSG:910102'){

// 早期数据存在的自定义坐标系 "EPSG:910101": "GCJ02", "EPSG:910102": "BD",

mapInfo.projection = "EPSG:4326";

}

that.baseProjection = mapInfo.projection;

that.webMapVersion = mapInfo.version;

that.baseLayer = mapInfo.baseLayer;

that.mapParams = {

title: mapInfo.title,

description: mapInfo.description

}; //存储地图的名称以及描述等信息，返回给用户

// 多坐标系支持

if(proj4){

(olProj4 && olProj4.register) ? olProj4.register(proj4) : window.ol.proj.setProj4(proj4) ;

}

// 目前iServer服务中可能出现的EPSG 0，-1，-1000

if(mapInfo.projection.indexOf("EPSG") === 0 && mapInfo.projection.split(":")[1] <= 0){

//对于这两种地图，只能view，不能叠加其他图层

that.createSpecLayer(mapInfo);

return;

} else if(that.addProjctionFromWKT(mapInfo.projection)){

mapInfo.projection = that.baseProjection = that.getEpsgInfoFromWKT(mapInfo.projection);

}else{

// 不支持的坐标系

that.errorCallback && that.errorCallback({type: "Not support CS", errorMsg: `Not support CS: ${mapInfo.projection}`}, 'getMapFaild', that.map);

return;

}

if (mapInfo.baseLayer && mapInfo.baseLayer.layerType === 'MAPBOXSTYLE') {

// 添加矢量瓦片服务作为底图

that.addMVTMapLayer(mapInfo, mapInfo.baseLayer, 0).then(() => {

that.createView(mapInfo);

if (!mapInfo.layers || mapInfo.layers.length === 0) {

that.sendMapToUser(0);

} else {

that.addLayers(mapInfo);

}

});

} else {

await that.addBaseMap(mapInfo);

if (!mapInfo.layers || mapInfo.layers.length === 0) {

that.sendMapToUser(0);

} else {

that.addLayers(mapInfo);

}

}

}).catch(function (error) {

that.errorCallback && that.errorCallback(error, 'getMapFaild', that.map);

});

}

/**

getScales(baseLayerInfo) {

let scales = [], resolutions = {}, res, scale, resolutionArray = [],

coordUnit = baseLayerInfo.coordUnit || olProj.get(baseLayerInfo.projection).getUnits();

if(!coordUnit) {

coordUnit = this.baseProjection === "EPSG:3857" ? "m" : "degree";

}

if(baseLayerInfo.visibleScales && baseLayerInfo.visibleScales.length > 0) {

//底部设置过固定比例尺，则使用设置的

baseLayerInfo.visibleScales.forEach(scale => {

let value = 1/scale;

res = this.getResFromScale(value, coordUnit);

scale = `1:${value.toLocaleString()}`;

//多此一举转换，因为toLocalString会自动保留小数点后三位，and当第二位小数是0就会保存小数点后两位。所有为了统一。

resolutions[this.formatScale(scale)] = res;

resolutionArray.push(res);

scales.push(scale);

}, this)

} else if(baseLayerInfo.layerType === 'WMTS') {

baseLayerInfo.scales.forEach(scale => {

res = this.getResFromScale(scale, coordUnit, 90.7);

scale = `1:${scale.toLocaleString()}`;

//多此一举转换，因为toLocalString会自动保留小数点后三位，and当第二位小数是0就会保存小数点后两位。所有为了统一。

resolutions[this.formatScale(scale)] = res;

resolutionArray.push(res);

scales.push(scale);

}, this)

} else {

let {minZoom=0, maxZoom=22} = baseLayerInfo, view = this.map.getView();

for(let i=minZoom; i<= maxZoom; i++) {

res = view.getResolutionForZoom(i);

scale = this.getScaleFromRes(res, coordUnit);

if(scales.indexOf(scale) === -1) {

//不添加重复的比例尺

scales.push(scale);

let attr = scale.replace(/,/g, "");

resolutions[attr] = res;

resolutionArray.push(res);

}

}

}

this.scales = scales;

this.resolutions = resolutions;

this.resolutionArray = resolutionArray;

}

/**

getResFromScale(scale, coordUnit="DEGREE", dpi=96) {

let mpu = metersPerUnit[coordUnit.toUpperCase()];

return scale * .0254 / dpi / mpu;

}

/**

getScaleFromRes(resolution, coordUnit="DEGREE", dpi=96) {

let scale, mpu = metersPerUnit[coordUnit.toUpperCase()];

scale = resolution * dpi * mpu / .0254;

return '1:'+ scale.toLocaleString();

}

/**

formatScale(scale) {

return scale.replace(/,/g, "");

}

/**

createSpecLayer(mapInfo) {

let me = this,

baseLayerInfo = mapInfo.baseLayer,

url = baseLayerInfo.url,

baseLayerType = baseLayerInfo.layerType;

let extent = [mapInfo.extent.leftBottom.x, mapInfo.extent.leftBottom.y, mapInfo.extent.rightTop.x, mapInfo.extent.rightTop.y];

let proj = new olProj.Projection({

extent,

units: 'm',

code: 'EPSG:0'

});

olProj.addProjection(proj);

let options = {

center: mapInfo.center,

level: 0

}

//添加view

me.baseProjection = proj;

let viewOptions = {

center: options.center ? [options.center.x, options.center.y] : [0,0],

zoom: 0,

projection: proj

}

if(!['4', '5'].includes(Util.getOlVersion())) { // 兼容 ol 4，5，6

viewOptions.multiWorld = true;

}

let view = new View(viewOptions);

me.map.setView(view);

if(me.mapParams) {

me.mapParams.extent = extent;

me.mapParams.projection = mapInfo.projection;

}

if(url.indexOf("?token=") > -1) {

//兼容iserver地址有token的情况

me.credentialKey = 'token';

me.credentialValue = mapInfo.baseLayer.credential = url.split("?token=")[1];

url = url.split("?token=")[0];

}

let source;

if(baseLayerType === "TILE"){

FetchRequest.get(me.getRequestUrl(`${url}.json`), null, {

withCredentials: this.withCredentials

}).then(function (response) {

return response.json();

}).then(function (result) {

baseLayerInfo.originResult = result;

let serverType = "IPORTAL", credential = baseLayerInfo.credential, keyfix = 'Token', keyParams = baseLayerInfo.url;

if (baseLayerInfo.url.indexOf("www.supermapol.com") > -1 || baseLayerInfo.url.indexOf("itest.supermapol.com") > -1) {

keyfix = 'Key';

keyParams = [keyParams];

serverType = "ONLINE";

}

if (credential) {

SecurityManager[`register${keyfix}`](keyParams, credential);

}

let options = {

serverType,

url,

tileGrid: TileSuperMapRest.optionsFromMapJSON(url, result).tileGrid

}

if (url && !me.isSameDomain(url)) {

options.tileProxy = me.server + 'apps/viewer/getUrlResource.png?url=';

}

source = new TileSuperMapRest(options);

me.addSpecToMap(source);

}).catch(function(error) {

me.errorCallback && me.errorCallback(error, 'getMapFaild', me.map);

});

} else if(baseLayerType === "WMS"){

source = me.createWMSSource(baseLayerInfo);

me.addSpecToMap(source);

} else if(baseLayerType === "WMTS"){

FetchRequest.get(me.getRequestUrl(url), null, {

withCredentials: this.withCredentials

}).then(function (response) {

return response.text();

}).then(function(capabilitiesText) {

baseLayerInfo.extent = [mapInfo.extent.leftBottom.x, mapInfo.extent.leftBottom.y, mapInfo.extent.rightTop.x, mapInfo.extent.rightTop.y];

baseLayerInfo.scales = me.getWMTSScales(baseLayerInfo.tileMatrixSet, capabilitiesText);

baseLayerInfo.dpi = dpiConfig.iServerWMTS;

source = me.createWMTSSource(baseLayerInfo);

me.addSpecToMap(source);

}).catch(function(error) {

me.errorCallback && me.errorCallback(error, 'getMapFaild', me.map);

})

}else{

me.errorCallback && me.errorCallback({type: "Not support CS", errorMsg: `Not support CS: ${baseLayerType}`}, 'getMapFaild', me.map);

}

}

/**

addSpecToMap(source) {

let layer = new olLayer.Tile({

source: source,

zIndex: 0

});

this.map.addLayer(layer);

this.sendMapToUser(0);

}

/**

getWMTSScales(identifier, capabilitiesText) {

const format = new WMTSCapabilities();

let capabilities = format.read(capabilitiesText);

let content = capabilities.Contents,

tileMatrixSet = content.TileMatrixSet;

let scales = [];

for (let i = 0; i < tileMatrixSet.length; i++) {

if (tileMatrixSet[i].Identifier === identifier) {

for (let h = 0; h < tileMatrixSet[i].TileMatrix.length; h++) {

scales.push(tileMatrixSet[i].TileMatrix[h].ScaleDenominator)

}

break;

}

}

return scales;

}

/**

async addBaseMap(mapInfo) {

let {baseLayer} = mapInfo, layerType = baseLayer.layerType;

//底图，使用默认的配置，不用存储的

if(layerType !== 'TILE' && layerType !== 'WMS' && layerType !== 'WMTS'){

this.getInternetMapInfo(mapInfo.baseLayer);

}else if(layerType === 'WMTS'){

// 通过请求完善信息

await this.getWmtsInfo(baseLayer);

}else if(layerType === 'TILE'){

await this.getTileInfo(baseLayer);

}

baseLayer.projection = mapInfo.projection;

if(!baseLayer.extent) {

baseLayer.extent = [mapInfo.extent.leftBottom.x, mapInfo.extent.leftBottom.y, mapInfo.extent.rightTop.x, mapInfo.extent.rightTop.y];

}

this.createView(mapInfo);

let layer = this.createBaseLayer(baseLayer, 0);

//底图增加图层类型，DV分享需要用它来识别版权信息

layer.setProperties({

layerType: layerType

});

this.map.addLayer(layer);

if(this.mapParams) {

this.mapParams.extent = baseLayer.extent;

this.mapParams.projection = mapInfo.projection;

}

if (mapInfo.baseLayer && mapInfo.baseLayer.labelLayerVisible) {

let layerInfo = mapInfo.baseLayer;

//存在天地图路网

let labelLayer = new olLayer.Tile({

source: this.createTiandituSource(layerInfo.layerType, mapInfo.projection, true),

zIndex: layerInfo.zIndex || 1,

visible: layerInfo.visible

});

this.map.addLayer(labelLayer);

}

}

/**

addMVTMapLayer(mapInfo, layerInfo, zIndex) {

layerInfo.zIndex = zIndex;

// 获取地图详细信息

return this.getMBStyle(mapInfo, layerInfo).then(() => {

// 创建图层

return this.createMVTLayer(layerInfo).then(layer => {

let layerID = Util.newGuid(8);

if (layerInfo.name) {

layer.setProperties({

name: layerInfo.name,

layerID: layerID,

layerType: 'VECTOR_TILE'

});

}

//否则没有ID，对不上号

layerInfo.layer = layer;

layerInfo.layerID = layerID;

this.map.addLayer(layer);

});

});

}

/**

createView(options) {

let oldcenter = options.center,

zoom = options.level !== undefined ? options.level : 1,

maxZoom = options.maxZoom || 22,

extent,

projection = this.baseProjection;

let center = [];

for (let key in oldcenter) {

center.push(oldcenter[key]);

}

if (center.length === 0) {

//兼容wms

center = [0, 0];

}

//与DV一致用底图的默认范围，不用存储的范围。否则会导致地图拖不动

this.baseLayerExtent = extent = options.baseLayer && options.baseLayer.extent;

if(this.mapParams) {

this.mapParams.extent = extent;

this.mapParams.projection = projection;

}

//当前中心点不在extent内,就用extent的中心点 todo

!containsCoordinate(extent, center) && (center = getCenter(extent));

// 计算当前最大分辨率

let baseLayer = options.baseLayer;

let maxResolution, minResolution;

if((baseLayer.visibleScales && baseLayer.visibleScales.length > 0) || (baseLayer.scales && baseLayer.scales.length >0)) {

//底图有固定比例尺，就直接获取。不用view计算

this.getScales(baseLayer);

} else if(options.baseLayer && ['TILE', 'VECTOR_TILE'].includes(options.baseLayer.layerType) && extent && extent.length === 4){

let width = extent[2] - extent[0];

let height = extent[3] - extent[1];

let maxResolution1 = width / 512;

let maxResolution2 = height / 512;

maxResolution = Math.max(maxResolution1, maxResolution2);

}

// if(options.baseLayer.visibleScales && options.baseLayer.visibleScales.length > 0){

// maxZoom = options.baseLayer.visibleScales.length;

// }

let viewOptions;

if(baseLayer.layerType === "WMTS"){

if(baseLayer.scales && baseLayer.scales.length >0) {

//因为新版extent超出，不可见。所以将extent去除

viewOptions = { zoom, center, projection, resolutions: this.resolutionArray, maxZoom};

} else {

viewOptions = { zoom, center, projection, maxZoom};

this.getScales(baseLayer);

}

}else {

if(this.resolutionArray && this.resolutionArray.length > 0) {

viewOptions = { zoom, center, projection, resolutions: this.resolutionArray, maxZoom};

} else {

viewOptions = {zoom, center, projection, maxResolution, minResolution, maxZoom};

this.getScales(baseLayer);

}

}

if(!['4', '5'].includes(Util.getOlVersion())){ // 兼容 ol 4，5，6

viewOptions.multiWorld = true;

viewOptions.showFullExtent = true;

viewOptions.enableRotation = false;

viewOptions.constrainResolution = true; //设置此参数，是因为需要显示整数级别。为了可视比例尺中包含当前比例尺

}

this.map.setView(new View(viewOptions));

if (options.visibleExtent) {

const view = this.map.getView();

const resolution = view.getResolutionForExtent(options.visibleExtent, this.map.getSize());

view.setResolution(resolution);

view.setCenter(getCenter(options.visibleExtent));

}

}

/**

createBaseLayer(layerInfo, index, isCallBack, scope) {

let source, isBaseLayer, that= this;

if(scope){

// 解决异步回调

that = scope;

}

let layerType = layerInfo.layerType; //底图和rest地图兼容

if (layerType.indexOf('TIANDITU_VEC') > -1 || layerType.indexOf('TIANDITU_IMG') > -1 ||

layerType.indexOf('TIANDITU_TER') > -1) {

layerType = layerType.substr(0, 12);

}

switch (layerType) {

case "TIANDITU_VEC":

case "TIANDITU_IMG":

case "TIANDITU_TER":

source = this.createTiandituSource(layerType, layerInfo.projection);

break;

case "BAIDU":

source = this.createBaiduSource();

break;

case 'BING':

source = this.createBingSource(layerInfo, layerInfo.projection);

break;

case "WMS":

source = this.createWMSSource(layerInfo);

break;

case "WMTS":

source = that.createWMTSSource(layerInfo);

break;

case 'TILE':

case 'SUPERMAP_REST':

source = that.createDynamicTiledSource(layerInfo, isBaseLayer);

break;

case 'CLOUD':

case 'CLOUD_BLACK':

case 'OSM':

case 'JAPAN_ORT':

case 'JAPAN_RELIEF':

case 'JAPAN_PALE':

case 'JAPAN_STD':

case 'GOOGLE_CN':

case 'GOOGLE':

source = this.createXYZSource(layerInfo);

break;

default:

break;

}

var layer = new olLayer.Tile({

source: source,

zIndex: layerInfo.zIndex || 1,

visible: layerInfo.visible

});

var layerID = Util.newGuid(8);

if (layerInfo.name) {

layer.setProperties({

name: layerInfo.name,

layerID: layerID

});

}

if(layerInfo.visible === undefined || layerInfo.visible === null) {

layerInfo.visible = true;

}

layer.setVisible(layerInfo.visible);

layerInfo.opacity && layer.setOpacity(layerInfo.opacity);

//layerInfo没有存储index属性

index && layer.setZIndex(index);

//否则没有ID，对不上号

layerInfo.layer = layer;

layerInfo.layerID = layerID;

let {visibleScale, autoUpdateTime} = layerInfo, minResolution, maxResolution;

if(visibleScale) {

maxResolution = this.resolutions[visibleScale.minScale];

minResolution = this.resolutions[visibleScale.maxScale];

//比例尺和分别率是反比的关系

maxResolution > 1 ? layer.setMaxResolution(Math.ceil(maxResolution)) : layer.setMaxResolution(maxResolution * 1.1);

layer.setMinResolution(minResolution);

}

if(autoUpdateTime && !layerInfo.autoUpdateInterval) {

//自动更新

layerInfo.autoUpdateInterval = setInterval(() => {

that.updateTileToMap(layerInfo, index);

}, autoUpdateTime);

}

if(isCallBack){

layer.setZIndex(0); // wmts

that.map.addLayer(layer);

}

return layer;

}

/**

updateTileToMap(layerInfo, layerIndex) {

this.map.removeLayer(layerInfo.layer);

this.map.addLayer(this.createBaseLayer(layerInfo, layerIndex));

}

/**

getInternetMapInfo(baseLayerInfo) {

const baiduBounds = [-20037508.3427892, -20037508.3427892, 20037508.3427892, 20037508.3427892];

const bounds_4326 = [-180, -90, 180, 90];

const osmBounds = [-20037508.34, -20037508.34, 20037508.34, 20037508.34];

const japanReliefBounds = [12555667.53929,1281852.98656,17525908.86651,7484870.70596];

const japanOrtBounds = [-19741117.14519,-10003921.36848,19981677.71404,19660983.56089];

baseLayerInfo.units= "m";

switch (baseLayerInfo.layerType){

case( 'BAIDU'):

baseLayerInfo.iServerUrl= 'https://map.baidu.com/';

baseLayerInfo.epsgCode= 'EPSG:3857';

baseLayerInfo.minZoom= 1;

baseLayerInfo.maxZoom= 19;

baseLayerInfo.level= 1;

baseLayerInfo.extent= baiduBounds;

// thumbnail: this.getImagePath('bmap.png') 暂时不用到缩略图

break;

case ('CLOUD'):

baseLayerInfo.url= 'http://t2.supermapcloud.com/FileService/image?map=quanguo&type=web&x={x}&y={y}&z={z}';

baseLayerInfo.epsgCode= 'EPSG:3857';

baseLayerInfo.minZoom= 1;