protected OnlineMapsGooglePlaceDetails(string key, string place_id, string reference, string language)
    {
        _status = OnlineMapsQueryStatus.downloading;

        if (string.IsNullOrEmpty(key))
        {
            key = OnlineMapsKeyManager.GoogleMaps();
        }

        StringBuilder url = new StringBuilder("https://maps.googleapis.com/maps/api/place/details/xml?sensor=false&key=").Append(key);

        if (!string.IsNullOrEmpty(place_id))
        {
            url.Append("&placeid=").Append(place_id);
        }
        if (!string.IsNullOrEmpty(reference))
        {
            url.Append("&reference=").Append(reference);
        }
        if (!string.IsNullOrEmpty(language))
        {
            url.Append("&language=").Append(language);
        }

        www             = new OnlineMapsWWW(url);
        www.OnComplete += OnRequestComplete;
    }
    /// <summary>
    /// Constructor.
    /// </summary>
    /// <param name="address">Location title</param>
    /// <param name="latlng">Location coordinates (latitude,longitude). Example: 40.714224,-73.961452.</param>
    /// <param name="lang">Language of result</param>
    protected OnlineMapsGoogleGeocoding(string address = null, string latlng = null, string lang = null)
    {
        _status = OnlineMapsQueryStatus.downloading;

        StringBuilder url = new StringBuilder("https://maps.googleapis.com/maps/api/geocode/xml?sensor=false");

        if (!string.IsNullOrEmpty(address))
        {
            url.Append("&address=").Append(OnlineMapsWWW.EscapeURL(address));
        }
        if (!string.IsNullOrEmpty(latlng))
        {
            url.Append("&latlng=").Append(latlng.Replace(" ", ""));
        }
        if (!string.IsNullOrEmpty(lang))
        {
            url.Append("&language=").Append(lang);
        }

        if (OnlineMapsKeyManager.hasGoogleMaps)
        {
            url.Append("&key=").Append(OnlineMapsKeyManager.GoogleMaps());
        }

        www             = new OnlineMapsWWW(url);
        www.OnComplete += OnRequestComplete;
    }
Пример #3
0
        private void OnMapClick()
        {
            control.GetCoords(out targetLng, out targetLat);

            if (targetMarker == null)
            {
                targetMarker       = OnlineMapsMarker3DManager.CreateItem(targetLng, targetLat, targetPrefab);
                targetMarker.scale = targetScale;
            }
            else
            {
                targetMarker.SetPosition(targetLng, targetLat);
            }

            double tx1, ty1, tx2, ty2;

            map.projection.CoordinatesToTile(lng, lat, map.zoom, out tx1, out ty1);
            map.projection.CoordinatesToTile(targetLng, targetLat, map.zoom, out tx2, out ty2);

            rotation = (float)OnlineMapsUtils.Angle2D(tx1, ty1, tx2, ty2) - 90;

            if (!OnlineMapsKeyManager.hasGoogleMaps)
            {
                Debug.LogWarning("Please enter Map / Key Manager / Google Maps");
                return;
            }

            OnlineMapsGoogleDirections request = new OnlineMapsGoogleDirections(OnlineMapsKeyManager.GoogleMaps(), new Vector2((float)lng, (float)lat), control.GetCoords());

            request.OnComplete += OnRequestComplete;
            request.Send();
        }
    private OnlineMapsGooglePlacePhoto(string key, string photo_reference, int?maxWidth, int?maxHeight)
    {
        if (string.IsNullOrEmpty(key))
        {
            key = OnlineMapsKeyManager.GoogleMaps();
        }

        StringBuilder builder = new StringBuilder("https://maps.googleapis.com/maps/api/place/photo?key=").Append(key);

        builder.Append("&photo_reference=").Append(photo_reference);
        if (maxWidth.HasValue)
        {
            builder.Append("&maxwidth=").Append(maxWidth);
        }
        if (maxHeight.HasValue)
        {
            builder.Append("&maxheight=").Append(maxHeight);
        }

        if (!maxWidth.HasValue && !maxHeight.HasValue)
        {
            builder.Append("&maxwidth=").Append(800);
        }

        www             = new OnlineMapsWWW(builder);
        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");
        }
        if (OnlineMapsKeyManager.hasGoogleMaps)
        {
            url.Append("&key=").Append(OnlineMapsKeyManager.GoogleMaps());
        }
        www             = new OnlineMapsWWW(url);
        www.OnComplete += OnRequestComplete;
    }
    protected OnlineMapsGooglePlacesAutocomplete(string input, string key, string types, int offset, Vector2 lnglat, int radius, string language, string components)
    {
        _status = OnlineMapsQueryStatus.downloading;

        if (string.IsNullOrEmpty(key))
        {
            key = OnlineMapsKeyManager.GoogleMaps();
        }

        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             = new OnlineMapsWWW(url);
        www.OnComplete += OnRequestComplete;
    }
Пример #7
0
    protected OnlineMapsGooglePlaces(string key, RequestParams p)
    {
        _status = OnlineMapsQueryStatus.downloading;

        if (string.IsNullOrEmpty(key))
        {
            key = OnlineMapsKeyManager.GoogleMaps();
        }

        StringBuilder url = new StringBuilder();

        url.AppendFormat("https://maps.googleapis.com/maps/api/place/{0}/xml?sensor=false", p.typePath);
        if (!string.IsNullOrEmpty(key))
        {
            url.Append("&key=").Append(key);
        }
        p.AppendParams(url);

        www             = new OnlineMapsWWW(url);
        www.OnComplete += OnRequestComplete;
    }
Пример #8
0
    private void Download(StringBuilder url, string key, string client, string signature)
    {
        if (!string.IsNullOrEmpty(key))
        {
            url.Append("&key=").Append(key);
        }
        else if (OnlineMapsKeyManager.hasGoogleMaps)
        {
            url.Append("&key=").Append(OnlineMapsKeyManager.GoogleMaps());
        }

        if (!string.IsNullOrEmpty(client))
        {
            url.Append("&client=").Append(client);
        }
        if (!string.IsNullOrEmpty(signature))
        {
            url.Append("&signature=").Append(signature);
        }
        www             = new OnlineMapsWWW(url);
        www.OnComplete += OnRequestComplete;
    }
        internal virtual void GenerateURL(StringBuilder url)
        {
            if (!string.IsNullOrEmpty(key))
            {
                url.Append("&key=").Append(key);
            }
            else if (OnlineMapsKeyManager.hasGoogleMaps)
            {
                url.Append("&key=").Append(OnlineMapsKeyManager.GoogleMaps());
            }

            if (!string.IsNullOrEmpty(language))
            {
                url.Append("&language=").Append(language);
            }
            if (!string.IsNullOrEmpty(client))
            {
                url.Append("&client=").Append(client);
            }
            if (!string.IsNullOrEmpty(signature))
            {
                url.Append("&signature=").Append(signature);
            }
        }
    public void Send()
    {
        if (_status != OnlineMapsQueryStatus.idle)
        {
            return;
        }
        _status = OnlineMapsQueryStatus.downloading;

        Params p = requestParams;

        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.ToString(OnlineMapsUtils.numberFormat)).Append(",")
            .Append(o.x.ToString(OnlineMapsUtils.numberFormat));
        }
        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.ToString(OnlineMapsUtils.numberFormat)).Append(",")
            .Append(d.x.ToString(OnlineMapsUtils.numberFormat));
        }
        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.ToString(OnlineMapsUtils.numberFormat)).Append(",")
                    .Append(v.x.ToString(OnlineMapsUtils.numberFormat));
                }
                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("&region=").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);
        }
        else if (OnlineMapsKeyManager.hasGoogleMaps)
        {
            url.Append("&key=").Append(OnlineMapsKeyManager.GoogleMaps());
        }

        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             = new OnlineMapsWWW(url);
        www.OnComplete += OnRequestComplete;
    }
Пример #11
0
        public void Search()
        {
            if (!OnlineMapsKeyManager.hasGoogleMaps)
            {
                Debug.LogWarning("Please enter Map / Key Manager / Google Maps");
                return;
            }

            if (inputField == null)
            {
                return;
            }
            if (inputField.text.Length < 3)
            {
                return;
            }

            string locationName = inputField.text;

            OnlineMapsGoogleGeocoding request = new OnlineMapsGoogleGeocoding(locationName, OnlineMapsKeyManager.GoogleMaps());

            request.OnComplete += OnGeocodingComplete;
            request.Send();
        }
    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;
    }