change imagery provider

src/modules/imagery/ImageryLayerFactory.js

   /**
    * Create amap imagery layer
    * @param options
-   * @returns {AmapImageryProvider}
+   * @returns {Promise<AmapImageryProvider>}
    */
   static createAmapImageryLayer(options) {
-    return new AmapImageryProvider(options)
+    return Promise.resolve(new AmapImageryProvider(options))
   }
 
   /**
    * Create baidu imagery layer
    * @param options
-   * @returns {BaiduImageryProvider}
+   * @returns {Promise<BaiduImageryProvider>}
    */
   static createBaiduImageryLayer(options) {
-    return new BaiduImageryProvider(options)
+    return Promise.resolve(new BaiduImageryProvider(options))
   }
 
   /**
    * Create geoVis imagery layer
    * @param options
-   * @returns {GeoVisImageryProvider}
+   * @returns {Promise<GeoVisImageryProvider>}
    */
   static createGeoVisImageryLayer(options) {
-    return new GeoVisImageryProvider(options)
+    return Promise.resolve(new GeoVisImageryProvider(options))
   }
 
   /**
    * Create google imagery layer
    * @param options
-   * @returns {GoogleImageryProvider}
+   * @returns {Promise<GoogleImageryProvider>}
    */
   static createGoogleImageryLayer(options) {
-    return new GoogleImageryProvider(options)
+    return Promise.resolve(new GoogleImageryProvider(options))
   }
 
   /**
    * Create tdt imagery layer
    * @param options
-   * @returns {TdtImageryProvider}
+   * @returns {Promise<TdtImageryProvider>}
    */
   static createTdtImageryLayer(options) {
-    return new TdtImageryProvider(options)
+    return Promise.resolve(new TdtImageryProvider(options))
   }
 
   /**
    * Create tencent imagery layer
    * @param options
-   * @returns {TencentImageryProvider}
+   * @returns {Promise<TencentImageryProvider>}
    */
   static createTencentImageryLayer(options) {
-    return new TencentImageryProvider(options)
+    return Promise.resolve(new TencentImageryProvider(options))
   }
 
   /**
    * Create arcgis imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<ArcGisMapServerImageryProvider>}
    */
   static createArcGisImageryLayer(options) {
-    return new Cesium.ArcGisMapServerImageryProvider(options)
+    return Cesium.ArcGisMapServerImageryProvider.fromUrl(options.url, options)
   }
 
   /**
    *
    * @param options
-   * @returns {BingMapsImageryProvider}
+   * @returns {Promise<BingMapsImageryProvider>}
    */
   static createBingImageryLayer(options) {
-    return new Cesium.BingMapsImageryProvider(options)
+    return Cesium.BingMapsImageryProvider.fromUrl(options.url, options)
   }
 
   /**
    *
    * @param options
-   * @returns {OpenStreetMapImageryProvider}
+   * @returns {Promise<OpenStreetMapImageryProvider>}
    */
   static createOSMImageryLayer(options) {
-    return new Cesium.OpenStreetMapImageryProvider(options)
+    return Promise.resolve(new Cesium.OpenStreetMapImageryProvider(options))
   }
 
   /**
    * Create single tile imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<ImageryProvider>}
    */
   static createSingleTileImageryLayer(options) {
-    return new Cesium.SingleTileImageryProvider(options)
+    return Promise.resolve(new Cesium.SingleTileImageryProvider(options))
   }
 
   /**
    * Create WMS imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<WebMapServiceImageryProvider>}
    */
   static createWMSImageryLayer(options) {
-    return new Cesium.WebMapServiceImageryProvider(options)
+    return Promise.resolve(new Cesium.WebMapServiceImageryProvider(options))
   }
 
   /**
    * Create WMTS imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<WebMapTileServiceImageryProvider>}
    */
   static createWMTSImageryLayer(options) {
-    return new Cesium.WebMapTileServiceImageryProvider(options)
+    return Promise.resolve(new Cesium.WebMapTileServiceImageryProvider(options))
   }
 
   /**
    * Create xyz imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<UrlTemplateImageryProvider>}
    */
   static createXYZImageryLayer(options) {
-    return new Cesium.UrlTemplateImageryProvider(options)
+    return Promise.resolve(new Cesium.UrlTemplateImageryProvider(options))
   }
 
   /**
    * Create coord imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<TileCoordinatesImageryProvider>}
    */
   static createCoordImageryLayer(options) {
-    return new Cesium.TileCoordinatesImageryProvider(options)
+    return Promise.resolve(new Cesium.TileCoordinatesImageryProvider(options))
   }
 
   /**
    * Create grid imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<GridImageryProvider>}
    */
   static createGridImageryLayer(options) {
-    return new Cesium.GridImageryProvider(options)
+    return Promise.resolve(new Cesium.GridImageryProvider(options))
   }
 
   /**
    * Create mapbox imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<MapboxImageryProvider>}
    */
   static createMapboxImageryLayer(options) {
-    return new Cesium.MapboxImageryProvider(options)
+    return Promise.resolve(new Cesium.MapboxImageryProvider(options))
   }
 
   /**
    * Create mapbox style imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<MapboxStyleImageryProvider>}
    */
   static createMapboxStyleImageryLayer(options) {
-    return new Cesium.MapboxStyleImageryProvider(options)
+    return Promise.resolve(new Cesium.MapboxStyleImageryProvider(options))
   }
 
   /**
    * Create TMS imagery layer
    * @param options
-   * @returns {ImageryProvider}
+   * @returns {Promise<TileMapServiceImageryProvider>}
    */
   static createTMSImageryLayer(options) {
-    return new Cesium.TileMapServiceImageryProvider(options)
+    return Cesium.TileMapServiceImageryProvider.fromUrl(options.url, options)
   }
 
   /**

src/modules/viewer/Viewer.js

     return Cesium.Rectangle.fromDegrees(min.lng, min.lat, max.lng, max.lat)
   }
 
-  get level() {
-    return this._delegate.scene.globe._surface._debug.maxDepthVisited
+  get zoom() {
+    let height = this._delegate.camera.positionCartographic.height
+    let A = 40487.57
+    let B = 0.00007096758
+    let C = 91610.74
+    let D = -40467.74
+    return Math.round(D + (A - D) / (1 + Math.pow(height / C, B)))
   }
 
   /**
     if (!baseLayer) {
       return this
     }
-    this._baseLayerPicker.addImageryLayer(baseLayer, options)
-    if (!this._baseLayerPicker.selectedImageryLayer) {
-      this._baseLayerPicker.changeImageryLayer(0)
+    let baseLayerPromises = []
+    if (!Array.isArray(baseLayer)) {
+      baseLayerPromises = baseLayer.slice(0)
+    } else {
+      baseLayerPromises = [baseLayer]
     }
-    this['mapSwitch'] && this['mapSwitch'].addMap(options)
+    Promise.all(baseLayerPromises).then((baseLayers) => {
+      this._baseLayerPicker.addImageryLayer(baseLayers, options)
+      if (!this._baseLayerPicker.selectedImageryLayer) {
+        this._baseLayerPicker.changeImageryLayer(0)
+      }
+      this['mapSwitch'] && this['mapSwitch'].addMap(options)
+    })
     return this
   }