protected OnlineMapsGooglePlacesAutocomplete(string input, string key, string types, int offset, Vector2 lnglat, int radius, string language, string components)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder("https://maps.googleapis.com/maps/api/place/autocomplete/xml?sensor=false");
url.Append("&input=").Append(OnlineMapsWWW.EscapeURL(input));
url.Append("&key=").Append(key);
if (lnglat != default(Vector2))
{
url.AppendFormat("&location={0},{1}", lnglat.y, lnglat.x);
}
if (radius != -1)
{
url.Append("&radius=").Append(radius);
}
if (offset != -1)
{
url.Append("&offset=").Append(offset);
}
if (!string.IsNullOrEmpty(types))
{
url.Append("&types=").Append(types);
}
if (!string.IsNullOrEmpty(components))
{
url.Append("&components=").Append(components);
}
if (!string.IsNullOrEmpty(language))
{
url.Append("&language=").Append(language);
}
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
protected OnlineMapsGoogleDirections(string origin, string destination, bool alternatives = false)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder();
url.AppendFormat("https://maps.googleapis.com/maps/api/directions/xml?origin={0}&destination={1}&sensor=false", OnlineMapsWWW.EscapeURL(origin), OnlineMapsWWW.EscapeURL(destination));
if (alternatives)
{
url.Append("&alternatives=true");
}
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
private void OnElevationRequestComplete(OnlineMapsWWW www)
{
elevationRequest = null;
if (www.hasError)
{
Debug.Log(www.error);
return;
}
string response = www.text;
try
{
bool isFirstResponse = false;
SavePrevValues();
if (elevationData == null)
{
elevationData = new short[elevationDataResolution, elevationDataResolution];
isFirstResponse = true;
}
int dataIndex = response.IndexOf("\"data\":[");
if (dataIndex == -1)
{
if (isFirstResponse)
{
elevationX1 = elevationRequestX1;
elevationY1 = elevationRequestY1;
elevationW = elevationRequestW;
elevationH = elevationRequestH;
SavePrevValues();
elevationDataWidth = elevationDataResolution;
elevationDataHeight = elevationDataResolution;
}
Debug.LogWarning(response);
if (OnElevationFails != null)
{
OnElevationFails(response);
}
return;
}
dataIndex += 8;
int index = 0;
int v = 0;
bool isNegative = false;
for (int i = dataIndex; i < response.Length; i++)
{
char c = response[i];
if (c == ',')
{
int x = index % elevationDataResolution;
int y = elevationDataResolution - index / elevationDataResolution - 1;
if (isNegative)
{
v = -v;
}
elevationData[x, y] = (short)v;
v = 0;
isNegative = false;
index++;
}
else if (c == '-')
{
isNegative = true;
}
else if (c > 47 && c < 58)
{
v = v * 10 + (c - 48);
}
else
{
break;
}
}
if (isNegative)
{
v = -v;
}
elevationData[elevationDataResolution - 1, 0] = (short)v;
elevationX1 = elevationRequestX1;
elevationY1 = elevationRequestY1;
elevationW = elevationRequestW;
elevationH = elevationRequestH;
elevationDataWidth = elevationDataResolution;
elevationDataHeight = elevationDataResolution;
UpdateMinMax();
if (OnElevationUpdated != null)
{
OnElevationUpdated();
}
control.UpdateControl();
}
catch (Exception exception)
{
Debug.Log(exception.Message + exception.StackTrace);
if (OnElevationFails != null)
{
OnElevationFails(exception.Message);
}
}
map.Redraw();
}
public override void CancelCurrentElevationRequest()
{
waitSetElevationData = false;
elevationRequest = null;
}
private OnlineMapsFindDirection(string origin, string destination, bool alternatives = false)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder();
url.AppendFormat("https://maps.googleapis.com/maps/api/directions/xml?origin={0}&destination={1}&sensor=false", OnlineMapsWWW.EscapeURL(origin), OnlineMapsWWW.EscapeURL(destination));
if (alternatives)
{
url.Append("&alternatives=true");
}
www = OnlineMapsUtils.GetWWW(url);
OnlineMaps.instance.AddGoogleAPIQuery(this);
}
private OnlineMapsBingMapsLocation(string query, string key, int maxResults, bool includeNeighborhood)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder();
url.AppendFormat("https://dev.virtualearth.net/REST/v1/Locations/{0}?key={1}&o=xml", OnlineMapsWWW.EscapeURL(query), key);
if (includeNeighborhood)
{
url.Append("&inclnb=1");
}
if (maxResults > 0 && maxResults != 5)
{
url.Append("&maxRes=").Append(maxResults);
}
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
private OnlineMapsGoogleRoads(string key, IEnumerable path, Units units = Units.KPH)
{
StringBuilder builder = new StringBuilder("https://roads.googleapis.com/v1/speedLimits?key=").Append(key);
if (units != Units.KPH)
{
builder.Append("&units=MPH");
}
int type = -1;
int i = -1;
double latitude = 0;
double longitude = 0;
bool isFirst = true;
foreach (object p in path)
{
i++;
if (type == -1)
{
if (p is double)
{
type = 0;
}
else if (p is float)
{
type = 1;
}
else if (p is Vector2)
{
type = 2;
}
else if (p is string)
{
type = 3;
}
else
{
throw new Exception("Unknown type of points. Must be IEnumerable<double>, IEnumerable<float>, IEnumerable<Vector2> or IEnumerable<string>.");
}
}
if (type == 0 || type == 1)
{
if (i % 2 == 1)
{
if (type == 0)
{
latitude = (double)p;
}
else
{
latitude = (float)p;
}
}
else
{
if (type == 0)
{
longitude = (double)p;
}
else
{
longitude = (float)p;
}
continue;
}
}
else if (type == 2)
{
Vector2 v = (Vector2)p;
longitude = v.x;
latitude = v.y;
}
if (type < 3)
{
if (isFirst)
{
builder.Append("&path=");
isFirst = false;
}
else
{
builder.Append("|");
}
builder.Append(latitude).Append(",").Append(longitude);
}
else
{
builder.Append("&placeId=").Append((string)p);
}
}
www = new OnlineMapsWWW(builder);
www.OnComplete += OnRequestComplete;
}
private OnlineMapsQQSearch(string key, string keyword, Params p)
{
if (string.IsNullOrEmpty(key))
{
key = OnlineMapsKeyManager.QQ();
}
StringBuilder builder = new StringBuilder("http://apis.map.qq.com/ws/place/v1/search?key=").Append(key).Append("&keyword=").Append(OnlineMapsWWW.EscapeURL(keyword));
p.AppendParams(builder);
www = new OnlineMapsWWW(builder);
www.OnComplete += OnRequestComplete;
}
private void Update()
{
if (api == null)
{
api = OnlineMaps.instance;
if (api == null)
{
return;
}
}
try
{
if (!started)
{
#if !UNITY_EDITOR
if (!Input.location.isEnabledByUser)
{
return;
}
Input.compass.enabled = true;
Input.location.Start(desiredAccuracy, updateDistance);
#endif
started = true;
}
#if !UNITY_EDITOR
useGPSEmulator = false;
#endif
bool positionChanged = false;
if (findByIPRequest != null && findByIPRequest.isDone)
{
if (string.IsNullOrEmpty(findByIPRequest.error))
{
string response = findByIPRequest.text;
Match latMath = Regex.Match(response, "geoplugin_latitude\";.*?\"(\\d*\\.\\d*)\"");
Match lngMath = Regex.Match(response, "geoplugin_longitude\";.*?\"(\\d*\\.\\d*)\"");
if (latMath.Success && lngMath.Success)
{
float lng = float.Parse(lngMath.Groups[1].Value);
float lat = float.Parse(latMath.Groups[1].Value);
if (useGPSEmulator)
{
emulatorPosition = new Vector2(lng, lat);
}
else if (position == Vector2.zero)
{
position = new Vector2(lng, lat);
positionChanged = true;
}
}
}
findByIPRequest = null;
}
if (createMarkerInUserPosition && _marker == null && (useGPSEmulator || position != Vector2.zero))
{
UpdateMarker();
}
if (!useGPSEmulator && Input.location.status != LocationServiceStatus.Running)
{
return;
}
bool compassChanged = false;
#if !UNITY_EDITOR
UpdateCompassFromInput(ref compassChanged);
#else
if (useGPSEmulator)
{
UpdateCompassFromEmulator(ref compassChanged);
}
else
{
UpdateCompassFromInput(ref compassChanged);
}
#endif
#if !UNITY_EDITOR
UpdateSpeed();
UpdatePositionFromInput(ref positionChanged);
#else
if (useGPSEmulator)
{
UpdatePositionFromEmulator(ref positionChanged);
}
else
{
UpdatePositionFromInput(ref positionChanged);
}
#endif
if (positionChanged)
{
if (!isPositionInited)
{
isPositionInited = true;
if (OnLocationInited != null)
{
OnLocationInited();
}
}
if (OnLocationChanged != null)
{
OnLocationChanged(position);
}
}
if (createMarkerInUserPosition && (positionChanged || compassChanged))
{
UpdateMarker();
}
if (updatePosition)
{
if (_allowUpdatePosition)
{
UpdatePosition();
}
else if (restoreAfter > 0 && DateTime.Now.Ticks > lastPositionChangedTime + OnlineMapsUtils.second * restoreAfter)
{
_allowUpdatePosition = true;
UpdatePosition();
}
}
}
catch /*(Exception exception)*/
{
//errorMessage = exception.Message + "\n" + exception.StackTrace;
}
}
private void OnInputLocationName(string locationName)
{
new OnlineMapsWWW(
"http://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates?f=pjson&address=" + OnlineMapsWWW.EscapeURL(locationName)
).OnComplete += OnGeocodeComplete;
}
public override void StartDownloadElevationTile(Tile tile)
{
string url = "https://api.mapbox.com/v4/mapbox.terrain-rgb/" + tile.zoom + "/" + tile.x + "/" + tile.y + ".pngraw?access_token=" + accessToken;
OnlineMapsWWW www = new OnlineMapsWWW(url);
www.OnComplete += delegate { OnTileDownloaded(tile, www); };
}
private OnlineMapsGoogleRoads(string key, IEnumerable path, bool interpolate)
{
if (string.IsNullOrEmpty(key))
{
key = OnlineMapsKeyManager.GoogleMaps();
}
StringBuilder builder = new StringBuilder("https://roads.googleapis.com/v1/snapToRoads?key=").Append(key);
if (interpolate)
{
builder.Append("&intepolate=true");
}
builder.Append("&path=");
int type = -1;
int i = -1;
double longitude = 0;
bool isFirst = true;
foreach (object p in path)
{
i++;
if (type == -1)
{
if (p is double)
{
type = 0;
}
else if (p is float)
{
type = 1;
}
else if (p is Vector2)
{
type = 2;
}
else
{
throw new Exception("Unknown type of points. Must be IEnumerable<double>, IEnumerable<float> or IEnumerable<Vector2>.");
}
}
double latitude;
if (type == 0 || type == 1)
{
if (i % 2 == 1)
{
if (type == 0)
{
latitude = (double)p;
}
else
{
latitude = (float)p;
}
}
else
{
if (type == 0)
{
longitude = (double)p;
}
else
{
longitude = (float)p;
}
continue;
}
}
else
{
Vector2 v = (Vector2)p;
longitude = v.x;
latitude = v.y;
}
if (!isFirst)
{
builder.Append("|");
}
isFirst = false;
builder.Append(latitude.ToString(OnlineMapsUtils.numberFormat)).Append(",")
.Append(longitude.ToString(OnlineMapsUtils.numberFormat));
}
www = new OnlineMapsWWW(builder);
www.OnComplete += OnRequestComplete;
}
protected abstract void LoadTileFromWWW(OnlineMapsWWW www);
public static void CheckNewVersionAvailable()
{
if (EditorPrefs.HasKey(lastVersionKey))
{
lastVersionID = EditorPrefs.GetString(lastVersionKey);
if (CompareVersions())
{
hasNewVersion = true;
return;
}
}
const long ticksInHour = 36000000000;
if (EditorPrefs.HasKey(lastVersionCheckKey))
{
long lastVersionCheck = EditorPrefs.GetInt(lastVersionCheckKey) * ticksInHour;
if (DateTime.Now.Ticks - lastVersionCheck < 24 * ticksInHour)
{
return;
}
}
EditorPrefs.SetInt(lastVersionCheckKey, (int)(DateTime.Now.Ticks / ticksInHour));
if (EditorPrefs.HasKey(channelKey))
{
channel = (OnlineMapsUpdateChannel)EditorPrefs.GetInt(channelKey);
}
else
{
channel = OnlineMapsUpdateChannel.stable;
}
if (channel == OnlineMapsUpdateChannel.stablePrevious)
{
channel = OnlineMapsUpdateChannel.stable;
}
WebClient client = new WebClient();
client.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
client.UploadDataCompleted += delegate(object sender, UploadDataCompletedEventArgs response)
{
if (response.Error != null)
{
Debug.Log(response.Error.Message);
return;
}
string version = Encoding.UTF8.GetString(response.Result);
try
{
string[] vars = version.Split(new[] { '.' });
string[] vars2 = new string[4];
while (vars[1].Length < 8)
{
vars[1] += "0";
}
vars2[0] = vars[0];
vars2[1] = int.Parse(vars[1].Substring(0, 2)).ToString();
vars2[2] = int.Parse(vars[1].Substring(2, 2)).ToString();
vars2[3] = int.Parse(vars[1].Substring(4)).ToString();
version = string.Join(".", vars2);
}
catch (Exception)
{
Debug.Log("Automatic check for Online Maps updates: Bad response.");
return;
}
lastVersionID = version;
hasNewVersion = CompareVersions();
EditorApplication.update += SetLastVersion;
};
client.UploadDataAsync(new Uri("http://infinity-code.com/products_update/getlastversion.php"), "POST", Encoding.UTF8.GetBytes("c=" + (int)channel + "&package=" + OnlineMapsWWW.EscapeURL(packageID)));
}
private string GetUpdateKey()
{
WebClient client = new WebClient();
client.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
string updateKey = client.UploadString("http://infinity-code.com/products_update/getupdatekey.php",
"key=" + invoiceNumber + "&package=" + OnlineMapsWWW.EscapeURL(packageID));
return(updateKey);
}
private OnlineMapsGoogleDirections(Params p)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder();
url.Append("https://maps.googleapis.com/maps/api/directions/xml?sensor=false");
url.Append("&origin=");
if (p.origin is string)
{
url.Append(OnlineMapsWWW.EscapeURL(p.origin as string));
}
else if (p.origin is Vector2)
{
Vector2 o = (Vector2)p.origin;
url.Append(o.y).Append(",").Append(o.x);
}
else
{
throw new Exception("Origin must be string or Vector2.");
}
url.Append("&destination=");
if (p.destination is string)
{
url.Append(OnlineMapsWWW.EscapeURL(p.destination as string));
}
else if (p.destination is Vector2)
{
Vector2 d = (Vector2)p.destination;
url.Append(d.y).Append(",").Append(d.x);
}
else
{
throw new Exception("Destination must be string or Vector2.");
}
if (p.mode.HasValue && p.mode.Value != Mode.driving)
{
url.Append("&mode=").Append(Enum.GetName(typeof(Mode), p.mode.Value));
}
if (p.waypoints != null)
{
StringBuilder waypointStr = new StringBuilder();
bool isFirst = true;
int countWaypoints = 0;
foreach (object w in p.waypoints)
{
if (countWaypoints >= 8)
{
Debug.LogWarning("The maximum number of waypoints is 8.");
break;
}
if (!isFirst)
{
waypointStr = waypointStr.Append("|");
}
if (w is string)
{
waypointStr.Append(OnlineMapsWWW.EscapeURL(w as string));
}
else if (w is Vector2)
{
Vector2 v = (Vector2)w;
waypointStr.Append(v.y).Append(",").Append(v.x);
}
else
{
throw new Exception("Waypoints must be string or Vector2.");
}
countWaypoints++;
isFirst = false;
}
if (countWaypoints > 0)
{
url.Append("&waypoints=optimize:true|").Append(waypointStr);
}
}
if (p.alternatives)
{
url.Append("&alternatives=true");
}
if (p.avoid.HasValue && p.avoid.Value != Avoid.none)
{
url.Append("&avoid=").Append(Enum.GetName(typeof(Avoid), p.avoid.Value));
}
if (p.units.HasValue && p.units.Value != Units.metric)
{
url.Append("&units=").Append(Enum.GetName(typeof(Units), p.units.Value));
}
if (!string.IsNullOrEmpty(p.region))
{
url.Append("®ion=").Append(p.region);
}
if (p.departure_time != null)
{
url.Append("&departure_time=").Append(p.departure_time);
}
if (p.arrival_time.HasValue && p.arrival_time.Value > 0)
{
url.Append("&arrival_time=").Append(p.arrival_time.Value);
}
if (!string.IsNullOrEmpty(p.language))
{
url.Append("&language=").Append(p.language);
}
if (!string.IsNullOrEmpty(p.key))
{
url.Append("&key=").Append(p.key);
}
if (p.traffic_model.HasValue && p.traffic_model.Value != TrafficModel.bestGuess)
{
url.Append("&traffic_model=").Append(Enum.GetName(typeof(TrafficModel), p.traffic_model.Value));
}
if (p.transit_mode.HasValue)
{
OnlineMapsUtils.GetValuesFromEnum(url, "transit_mode", typeof(TransitMode), (int)p.transit_mode.Value);
}
if (p.transit_routing_preference.HasValue)
{
url.Append("&transit_routing_preference=").Append(Enum.GetName(typeof(TransitRoutingPreference), p.transit_routing_preference.Value));
}
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
private OnlineMapsOSMNominatim(string query, string acceptlanguage, int limit, bool addressdetails)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder("https://nominatim.openstreetmap.org/search?format=xml&q=").Append(OnlineMapsWWW.EscapeURL(query));
if (addressdetails)
{
url.Append("&addressdetails=1");
}
if (limit > 0)
{
url.Append("&limit=").Append(limit);
}
if (!string.IsNullOrEmpty(acceptlanguage))
{
url.Append("&accept-language=").Append(acceptlanguage);
}
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
private void OnFindLocationComplete(OnlineMapsWWW www)
{
if (!string.IsNullOrEmpty(www.error))
{
return;
}
string response = www.text;
if (string.IsNullOrEmpty(response))
{
return;
}
int index = 0;
string s = "\"loc\": \"";
float lat = 0, lng = 0;
bool finded = false;
for (int i = 0; i < response.Length; i++)
{
if (response[i] == s[index])
{
index++;
if (index >= s.Length)
{
i++;
int startIndex = i;
while (true)
{
char c = response[i];
if (c == ',')
{
lat = float.Parse(response.Substring(startIndex, i - startIndex));
i++;
startIndex = i;
}
else if (c == '"')
{
lng = float.Parse(response.Substring(startIndex, i - startIndex));
finded = true;
break;
}
i++;
}
break;
}
}
else
{
index = 0;
}
}
if (finded)
{
if (useGPSEmulator)
{
emulatorPosition = new Vector2(lng, lat);
}
else if (position == Vector2.zero)
{
position = new Vector2(lng, lat);
if (!isPositionInited && OnLocationInited != null)
{
isPositionInited = true;
OnLocationInited();
}
if (OnLocationChanged != null)
{
OnLocationChanged(position);
}
}
if (OnFindLocationByIPComplete != null)
{
OnFindLocationByIPComplete();
}
}
}
private OnlineMapsQQSearch(string key, string keyword, Params p)
{
StringBuilder builder = new StringBuilder("http://apis.map.qq.com/ws/place/v1/search?key=").Append(key).Append("&keyword=").Append(OnlineMapsWWW.EscapeURL(keyword));
p.AppendParams(builder);
www = OnlineMapsUtils.GetWWW(builder);
www.OnComplete += OnRequestComplete;
}
private OnlineMapsWhat3Words(StringBuilder url)
{
_status = OnlineMapsQueryStatus.downloading;
www = new OnlineMapsWWW(url);
www.OnComplete += OnRequestComplete;
}
