import buildModuleUrl from "../Core/buildModuleUrl.js";
|
import Check from "../Core/Check.js";
|
import Credit from "../Core/Credit.js";
|
import defaultValue from "../Core/defaultValue.js";
|
import defined from "../Core/defined.js";
|
import DeveloperError from "../Core/DeveloperError.js";
|
import Event from "../Core/Event.js";
|
import GeographicTilingScheme from "../Core/GeographicTilingScheme.js";
|
import Rectangle from "../Core/Rectangle.js";
|
import Resource from "../Core/Resource.js";
|
import RuntimeError from "../Core/RuntimeError.js";
|
import TileProviderError from "../Core/TileProviderError.js";
|
import WebMercatorTilingScheme from "../Core/WebMercatorTilingScheme.js";
|
import when from "../ThirdParty/when.js";
|
import ImageryProvider from "./ImageryProvider.js";
|
|
/**
|
* @typedef {Object} GoogleEarthEnterpriseMapsProvider.ConstructorOptions
|
*
|
* Initialization options for the GoogleEarthEnterpriseMapsProvider constructor
|
*
|
* @property {Resource|String} url The url of the Google Earth server hosting the imagery.
|
* @property {Number} channel The channel (id) to be used when requesting data from the server.
|
* The channel number can be found by looking at the json file located at:
|
* earth.localdomain/default_map/query?request=Json&vars=geeServerDefs The /default_map path may
|
* differ depending on your Google Earth Enterprise server configuration. Look for the "id" that
|
* is associated with a "ImageryMaps" requestType. There may be more than one id available.
|
* Example:
|
* {
|
* layers: [
|
* {
|
* id: 1002,
|
* requestType: "ImageryMaps"
|
* },
|
* {
|
* id: 1007,
|
* requestType: "VectorMapsRaster"
|
* }
|
* ]
|
* }
|
* @property {String} [path="/default_map"] The path of the Google Earth server hosting the imagery.
|
* @property {Number} [maximumLevel] The maximum level-of-detail supported by the Google Earth
|
* Enterprise server, or undefined if there is no limit.
|
* @property {TileDiscardPolicy} [tileDiscardPolicy] The policy that determines if a tile
|
* is invalid and should be discarded. To ensure that no tiles are discarded, construct and pass
|
* a {@link NeverTileDiscardPolicy} for this parameter.
|
* @property {Ellipsoid} [ellipsoid] The ellipsoid. If not specified, the WGS84 ellipsoid is used.
|
*/
|
|
/**
|
* Provides tiled imagery using the Google Earth Imagery API.
|
*
|
* Notes: This imagery provider does not work with the public Google Earth servers. It works with the
|
* Google Earth Enterprise Server.
|
*
|
* By default the Google Earth Enterprise server does not set the
|
* {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing} headers. You can either
|
* use a proxy server which adds these headers, or in the /opt/google/gehttpd/conf/gehttpd.conf
|
* and add the 'Header set Access-Control-Allow-Origin "*"' option to the '<Directory />' and
|
* '<Directory "/opt/google/gehttpd/htdocs">' directives.
|
*
|
* This provider is for use with 2D Maps API as part of Google Earth Enterprise. For 3D Earth API uses, it
|
* is necessary to use {@link GoogleEarthEnterpriseImageryProvider}
|
*
|
* @alias GoogleEarthEnterpriseMapsProvider
|
* @constructor
|
*
|
* @param {GoogleEarthEnterpriseMapsProvider.ConstructorOptions} options Object describing initialization options
|
*
|
* @exception {RuntimeError} Could not find layer with channel (id) of <code>options.channel</code>.
|
* @exception {RuntimeError} Could not find a version in channel (id) <code>options.channel</code>.
|
* @exception {RuntimeError} Unsupported projection <code>data.projection</code>.
|
*
|
* @see ArcGisMapServerImageryProvider
|
* @see BingMapsImageryProvider
|
* @see OpenStreetMapImageryProvider
|
* @see SingleTileImageryProvider
|
* @see TileMapServiceImageryProvider
|
* @see WebMapServiceImageryProvider
|
* @see WebMapTileServiceImageryProvider
|
* @see UrlTemplateImageryProvider
|
*
|
*
|
* @example
|
* var google = new Cesium.GoogleEarthEnterpriseMapsProvider({
|
* url : 'https://earth.localdomain',
|
* channel : 1008
|
* });
|
*
|
* @see {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing}
|
*/
|
function GoogleEarthEnterpriseMapsProvider(options) {
|
options = defaultValue(options, {});
|
|
//>>includeStart('debug', pragmas.debug);
|
if (!defined(options.url)) {
|
throw new DeveloperError("options.url is required.");
|
}
|
if (!defined(options.channel)) {
|
throw new DeveloperError("options.channel is required.");
|
}
|
//>>includeEnd('debug');
|
|
/**
|
* The default alpha blending value of this provider, with 0.0 representing fully transparent and
|
* 1.0 representing fully opaque.
|
*
|
* @type {Number|undefined}
|
* @default undefined
|
*/
|
this.defaultAlpha = undefined;
|
|
/**
|
* The default alpha blending value on the night side of the globe of this provider, with 0.0 representing fully transparent and
|
* 1.0 representing fully opaque.
|
*
|
* @type {Number|undefined}
|
* @default undefined
|
*/
|
this.defaultNightAlpha = undefined;
|
|
/**
|
* The default alpha blending value on the day side of the globe of this provider, with 0.0 representing fully transparent and
|
* 1.0 representing fully opaque.
|
*
|
* @type {Number|undefined}
|
* @default undefined
|
*/
|
this.defaultDayAlpha = undefined;
|
|
/**
|
* The default brightness of this provider. 1.0 uses the unmodified imagery color. Less than 1.0
|
* makes the imagery darker while greater than 1.0 makes it brighter.
|
*
|
* @type {Number|undefined}
|
* @default undefined
|
*/
|
this.defaultBrightness = undefined;
|
|
/**
|
* The default contrast of this provider. 1.0 uses the unmodified imagery color. Less than 1.0 reduces
|
* the contrast while greater than 1.0 increases it.
|
*
|
* @type {Number|undefined}
|
* @default undefined
|
*/
|
this.defaultContrast = undefined;
|
|
/**
|
* The default hue of this provider in radians. 0.0 uses the unmodified imagery color.
|
*
|
* @type {Number|undefined}
|
* @default undefined
|
*/
|
this.defaultHue = undefined;
|
|
/**
|
* The default saturation of this provider. 1.0 uses the unmodified imagery color. Less than 1.0 reduces the
|
* saturation while greater than 1.0 increases it.
|
*
|
* @type {Number|undefined}
|
* @default undefined
|
*/
|
this.defaultSaturation = undefined;
|
|
/**
|
* The default gamma correction to apply to this provider. 1.0 uses the unmodified imagery color.
|
*
|
* @type {Number|undefined}
|
* @default 1.9
|
*/
|
this.defaultGamma = 1.9;
|
|
/**
|
* The default texture minification filter to apply to this provider.
|
*
|
* @type {TextureMinificationFilter}
|
* @default undefined
|
*/
|
this.defaultMinificationFilter = undefined;
|
|
/**
|
* The default texture magnification filter to apply to this provider.
|
*
|
* @type {TextureMagnificationFilter}
|
* @default undefined
|
*/
|
this.defaultMagnificationFilter = undefined;
|
|
var url = options.url;
|
var path = defaultValue(options.path, "/default_map");
|
|
var resource = Resource.createIfNeeded(url).getDerivedResource({
|
// We used to just append path to url, so now that we do proper URI resolution, removed the /
|
url: path[0] === "/" ? path.substring(1) : path,
|
});
|
|
resource.appendForwardSlash();
|
|
this._resource = resource;
|
this._url = url;
|
this._path = path;
|
this._tileDiscardPolicy = options.tileDiscardPolicy;
|
this._channel = options.channel;
|
this._requestType = "ImageryMaps";
|
this._credit = new Credit(
|
'<a href="http://www.google.com/enterprise/mapsearth/products/earthenterprise.html"><img src="' +
|
GoogleEarthEnterpriseMapsProvider.logoUrl +
|
'" title="Google Imagery"/></a>'
|
);
|
|
this._tilingScheme = undefined;
|
|
this._version = undefined;
|
|
this._tileWidth = 256;
|
this._tileHeight = 256;
|
this._maximumLevel = options.maximumLevel;
|
|
this._errorEvent = new Event();
|
|
this._ready = false;
|
this._readyPromise = when.defer();
|
|
var metadataResource = resource.getDerivedResource({
|
url: "query",
|
queryParameters: {
|
request: "Json",
|
vars: "geeServerDefs",
|
is2d: "t",
|
},
|
});
|
var that = this;
|
var metadataError;
|
|
function metadataSuccess(text) {
|
var data;
|
|
// The Google Earth server sends malformed JSON data currently...
|
try {
|
// First, try parsing it like normal in case a future version sends correctly formatted JSON
|
data = JSON.parse(text);
|
} catch (e) {
|
// Quote object strings manually, then try parsing again
|
data = JSON.parse(
|
text.replace(/([\[\{,])[\n\r ]*([A-Za-z0-9]+)[\n\r ]*:/g, '$1"$2":')
|
);
|
}
|
|
var layer;
|
for (var i = 0; i < data.layers.length; i++) {
|
if (data.layers[i].id === that._channel) {
|
layer = data.layers[i];
|
break;
|
}
|
}
|
|
var message;
|
|
if (!defined(layer)) {
|
message =
|
"Could not find layer with channel (id) of " + that._channel + ".";
|
metadataError = TileProviderError.handleError(
|
metadataError,
|
that,
|
that._errorEvent,
|
message,
|
undefined,
|
undefined,
|
undefined,
|
requestMetadata
|
);
|
throw new RuntimeError(message);
|
}
|
|
if (!defined(layer.version)) {
|
message =
|
"Could not find a version in channel (id) " + that._channel + ".";
|
metadataError = TileProviderError.handleError(
|
metadataError,
|
that,
|
that._errorEvent,
|
message,
|
undefined,
|
undefined,
|
undefined,
|
requestMetadata
|
);
|
throw new RuntimeError(message);
|
}
|
that._version = layer.version;
|
|
if (defined(data.projection) && data.projection === "flat") {
|
that._tilingScheme = new GeographicTilingScheme({
|
numberOfLevelZeroTilesX: 2,
|
numberOfLevelZeroTilesY: 2,
|
rectangle: new Rectangle(-Math.PI, -Math.PI, Math.PI, Math.PI),
|
ellipsoid: options.ellipsoid,
|
});
|
// Default to mercator projection when projection is undefined
|
} else if (!defined(data.projection) || data.projection === "mercator") {
|
that._tilingScheme = new WebMercatorTilingScheme({
|
numberOfLevelZeroTilesX: 2,
|
numberOfLevelZeroTilesY: 2,
|
ellipsoid: options.ellipsoid,
|
});
|
} else {
|
message = "Unsupported projection " + data.projection + ".";
|
metadataError = TileProviderError.handleError(
|
metadataError,
|
that,
|
that._errorEvent,
|
message,
|
undefined,
|
undefined,
|
undefined,
|
requestMetadata
|
);
|
throw new RuntimeError(message);
|
}
|
|
that._ready = true;
|
that._readyPromise.resolve(true);
|
TileProviderError.handleSuccess(metadataError);
|
}
|
|
function metadataFailure(e) {
|
var message =
|
"An error occurred while accessing " + metadataResource.url + ".";
|
metadataError = TileProviderError.handleError(
|
metadataError,
|
that,
|
that._errorEvent,
|
message,
|
undefined,
|
undefined,
|
undefined,
|
requestMetadata
|
);
|
that._readyPromise.reject(new RuntimeError(message));
|
}
|
|
function requestMetadata() {
|
var metadata = metadataResource.fetchText();
|
when(metadata, metadataSuccess, metadataFailure);
|
}
|
|
requestMetadata();
|
}
|
|
Object.defineProperties(GoogleEarthEnterpriseMapsProvider.prototype, {
|
/**
|
* Gets the URL of the Google Earth MapServer.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {String}
|
* @readonly
|
*/
|
url: {
|
get: function () {
|
return this._url;
|
},
|
},
|
|
/**
|
* Gets the url path of the data on the Google Earth server.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {String}
|
* @readonly
|
*/
|
path: {
|
get: function () {
|
return this._path;
|
},
|
},
|
|
/**
|
* Gets the proxy used by this provider.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Proxy}
|
* @readonly
|
*/
|
proxy: {
|
get: function () {
|
return this._resource.proxy;
|
},
|
},
|
|
/**
|
* Gets the imagery channel (id) currently being used.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number}
|
* @readonly
|
*/
|
channel: {
|
get: function () {
|
return this._channel;
|
},
|
},
|
|
/**
|
* Gets the width of each tile, in pixels. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number}
|
* @readonly
|
*/
|
tileWidth: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"tileWidth must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._tileWidth;
|
},
|
},
|
|
/**
|
* Gets the height of each tile, in pixels. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number}
|
* @readonly
|
*/
|
tileHeight: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"tileHeight must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._tileHeight;
|
},
|
},
|
|
/**
|
* Gets the maximum level-of-detail that can be requested. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number|undefined}
|
* @readonly
|
*/
|
maximumLevel: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"maximumLevel must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._maximumLevel;
|
},
|
},
|
|
/**
|
* Gets the minimum level-of-detail that can be requested. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number}
|
* @readonly
|
*/
|
minimumLevel: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"minimumLevel must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return 0;
|
},
|
},
|
|
/**
|
* Gets the tiling scheme used by this provider. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {TilingScheme}
|
* @readonly
|
*/
|
tilingScheme: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"tilingScheme must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._tilingScheme;
|
},
|
},
|
|
/**
|
* Gets the version of the data used by this provider. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number}
|
* @readonly
|
*/
|
version: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"version must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._version;
|
},
|
},
|
|
/**
|
* Gets the type of data that is being requested from the provider. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {String}
|
* @readonly
|
*/
|
requestType: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"requestType must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._requestType;
|
},
|
},
|
/**
|
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Rectangle}
|
* @readonly
|
*/
|
rectangle: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"rectangle must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._tilingScheme.rectangle;
|
},
|
},
|
|
/**
|
* Gets the tile discard policy. If not undefined, the discard policy is responsible
|
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
|
* returns undefined, no tiles are filtered. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {TileDiscardPolicy}
|
* @readonly
|
*/
|
tileDiscardPolicy: {
|
get: function () {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"tileDiscardPolicy must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
return this._tileDiscardPolicy;
|
},
|
},
|
|
/**
|
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing
|
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
|
* are passed an instance of {@link TileProviderError}.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Event}
|
* @readonly
|
*/
|
errorEvent: {
|
get: function () {
|
return this._errorEvent;
|
},
|
},
|
|
/**
|
* Gets a value indicating whether or not the provider is ready for use.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Boolean}
|
* @readonly
|
*/
|
ready: {
|
get: function () {
|
return this._ready;
|
},
|
},
|
|
/**
|
* Gets a promise that resolves to true when the provider is ready for use.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Promise.<Boolean>}
|
* @readonly
|
*/
|
readyPromise: {
|
get: function () {
|
return this._readyPromise.promise;
|
},
|
},
|
|
/**
|
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
|
* the source of the imagery. This function should not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Credit}
|
* @readonly
|
*/
|
credit: {
|
get: function () {
|
return this._credit;
|
},
|
},
|
|
/**
|
* Gets a value indicating whether or not the images provided by this imagery provider
|
* include an alpha channel. If this property is false, an alpha channel, if present, will
|
* be ignored. If this property is true, any images without an alpha channel will be treated
|
* as if their alpha is 1.0 everywhere. When this property is false, memory usage
|
* and texture upload time are reduced.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Boolean}
|
* @readonly
|
*/
|
hasAlphaChannel: {
|
get: function () {
|
return true;
|
},
|
},
|
});
|
|
/**
|
* Gets the credits to be displayed when a given tile is displayed.
|
*
|
* @param {Number} x The tile X coordinate.
|
* @param {Number} y The tile Y coordinate.
|
* @param {Number} level The tile level;
|
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
|
*
|
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
|
*/
|
GoogleEarthEnterpriseMapsProvider.prototype.getTileCredits = function (
|
x,
|
y,
|
level
|
) {
|
return undefined;
|
};
|
|
/**
|
* Requests the image for a given tile. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
*
|
* @param {Number} x The tile X coordinate.
|
* @param {Number} y The tile Y coordinate.
|
* @param {Number} level The tile level.
|
* @param {Request} [request] The request object. Intended for internal use only.
|
* @returns {Promise.<HTMLImageElement|HTMLCanvasElement>|undefined} A promise for the image that will resolve when the image is available, or
|
* undefined if there are too many active requests to the server, and the request
|
* should be retried later. The resolved image may be either an
|
* Image or a Canvas DOM object.
|
*
|
* @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready.
|
*/
|
GoogleEarthEnterpriseMapsProvider.prototype.requestImage = function (
|
x,
|
y,
|
level,
|
request
|
) {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError(
|
"requestImage must not be called before the imagery provider is ready."
|
);
|
}
|
//>>includeEnd('debug');
|
|
var resource = this._resource.getDerivedResource({
|
url: "query",
|
request: request,
|
queryParameters: {
|
request: this._requestType,
|
channel: this._channel,
|
version: this._version,
|
x: x,
|
y: y,
|
z: level + 1, // Google Earth starts with a zoom level of 1, not 0
|
},
|
});
|
|
return ImageryProvider.loadImage(this, resource);
|
};
|
|
/**
|
* Picking features is not currently supported by this imagery provider, so this function simply returns
|
* undefined.
|
*
|
* @param {Number} x The tile X coordinate.
|
* @param {Number} y The tile Y coordinate.
|
* @param {Number} level The tile level.
|
* @param {Number} longitude The longitude at which to pick features.
|
* @param {Number} latitude The latitude at which to pick features.
|
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
|
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
|
* instances. The array may be empty if no features are found at the given location.
|
* It may also be undefined if picking is not supported.
|
*/
|
GoogleEarthEnterpriseMapsProvider.prototype.pickFeatures = function (
|
x,
|
y,
|
level,
|
longitude,
|
latitude
|
) {
|
return undefined;
|
};
|
|
GoogleEarthEnterpriseMapsProvider._logoUrl = undefined;
|
|
Object.defineProperties(GoogleEarthEnterpriseMapsProvider, {
|
/**
|
* Gets or sets the URL to the Google Earth logo for display in the credit.
|
* @memberof GoogleEarthEnterpriseMapsProvider
|
* @type {String}
|
*/
|
logoUrl: {
|
get: function () {
|
if (!defined(GoogleEarthEnterpriseMapsProvider._logoUrl)) {
|
GoogleEarthEnterpriseMapsProvider._logoUrl = buildModuleUrl(
|
"Assets/Images/google_earth_credit.png"
|
);
|
}
|
return GoogleEarthEnterpriseMapsProvider._logoUrl;
|
},
|
set: function (value) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined("value", value);
|
//>>includeEnd('debug');
|
|
GoogleEarthEnterpriseMapsProvider._logoUrl = value;
|
},
|
},
|
});
|
export default GoogleEarthEnterpriseMapsProvider;
|
