private async Task <GeoCoordinate> ShowMyCurrentLocationOnTheMap()
{
// Get my current location.
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
myGeocoordinate = myGeoposition.Coordinate;
wayPoints.Add(new GeoCoordinate(myGeocoordinate.Latitude, myGeocoordinate.Longitude));
//GeoCoordinate myxGeocoordinate = new GeoCoordinate(47.6785619, -122.1311156);
myGeoCoordinate =
CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);
// Make my current location the center of the Map.
this.mapPostItinerary.Center = myGeoCoordinate;
this.mapPostItinerary.ZoomLevel = 16;
// Create a MapOverlay to contain the circle.
myCurentLocationOverlay = MarkerDraw.DrawMapMarker(myGeoCoordinate);
// Create a MapLayer to contain the MapOverlay.
myLocationLayer = new MapLayer();
myLocationLayer.Add(myCurentLocationOverlay);
// Add the MapLayer to the Map.
mapPostItinerary.Layers.Add(myLocationLayer);
return(myGeoCoordinate);
}
private async void ShowMyLocationOnTheMap()
{
Geolocator myGeolocator = new Geolocator();
if (myGeolocator.LocationStatus != PositionStatus.Disabled)
{
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
GeoCoordinate myGeoCoordinate = CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);
Ellipse myCircle = new Ellipse();
myCircle.Fill = new SolidColorBrush(Colors.Red);
myCircle.Height = 20;
myCircle.Width = 20;
myCircle.Opacity = 50;
MapOverlay myLocationOverlay = new MapOverlay();
myLocationOverlay.Content = myCircle;
myLocationOverlay.PositionOrigin = new Point(0.5, 0.5);
myLocationOverlay.GeoCoordinate = myGeoCoordinate;
MapLayer myLocationLayer = new MapLayer();
myLocationLayer.Add(myLocationOverlay);
mapWithMyLocation.Layers.Add(myLocationLayer);
}
}
private void UpdateGpsData(Geocoordinate geocoordinate)
{
BasicGeoposition position = geocoordinate.Point.Position;
LatitudeTB.Text = String.Format("{0} {1}", position.Latitude > 0 ? "N" : "S", position.Latitude);
LongitudeTB.Text = String.Format("{0} {1}", position.Longitude > 0 ? "E" : "W", position.Longitude);
}
private async void ShowMyLocationOnTheMap()
{
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
GeoCoordinate myGeoCoordinate =
CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);
// Make my current location the center of the Map.
this.mapWithMyLocation.Center = myGeoCoordinate;
this.mapWithMyLocation.ZoomLevel = 13;
// Create a small circle to mark the current location.
BitmapImage bmi = new BitmapImage(new Uri("/Assets/pushpinRood.png", UriKind.Relative));
Image img = new Image();
img.Source = bmi;
// Create a MapOverlay to contain the circle.
MapOverlay myLocationOverlay = new MapOverlay();
myLocationOverlay.Content = img;
myLocationOverlay.PositionOrigin = new Point(0.5, 0.5);
myLocationOverlay.GeoCoordinate = myGeoCoordinate;
// Create a MapLayer to contain the MapOverlay.
MapLayer myLocationLayer = new MapLayer();
myLocationLayer.Add(myLocationOverlay);
// Add the MapLayer to the Map.
mapWithMyLocation.Layers.Add(myLocationLayer);
}
/// <inheritdoc />
public async Task RecordLocationAsync(string trackingId, Geocoordinate coordinate, string comment)
{
if (string.IsNullOrWhiteSpace(trackingId))
{
return;
}
if (coordinate == null)
{
return;
}
var waypointSectionContent = string.Format(
WaypointXmlTemplate,
coordinate.Point.Position.Latitude,
coordinate.Point.Position.Longitude,
coordinate.Point.Position.Altitude,
DateTime.Now.ToUniversalTime().ToString("o"),
coordinate.PositionSource,
coordinate.Accuracy,
comment) + "\r\n";
var workingFolder = await GetFolder(WorkingFolderName);
var randomFileName = GetRandomString(6);
var sectionFileName = $"{trackingId}-{DateTime.Now.ToString("yyyyMMddHHmmss")}-{randomFileName}.xml";
Debug.WriteLine($"{DateTime.Now} - Creating way-point section file {sectionFileName}");
var waypointFile = await workingFolder.CreateFileAsync(sectionFileName, CreationCollisionOption.ReplaceExisting);
await this.waypointFileRetryPolicy.ExecuteAsync(async() => await FileIO.WriteTextAsync(waypointFile, waypointSectionContent));
}
private Dictionary <string, object> GeocoordinateToMowblyCoordinate(Geocoordinate coordinate)
{
Dictionary <string, object> result = new Dictionary <string, object>();
// Read coordinate values
double latitude = Convert.ToDouble(coordinate.Latitude);
double longitude = Convert.ToDouble(coordinate.Longitude);
double altitude = Convert.ToDouble(coordinate.Altitude);
double accuracy = Convert.ToDouble(coordinate.Accuracy);
double altitudeAccuracy = Convert.ToDouble(coordinate.AltitudeAccuracy);
double heading = Convert.ToDouble(coordinate.Heading);
double speed = Convert.ToDouble(coordinate.Speed);
// Read timestamp
DateTimeOffset locTime = coordinate.Timestamp;
DateTime Jan1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
TimeSpan ts = locTime - Jan1970;
double timestamp = ts.TotalMilliseconds;
// Create coords
Dictionary <string, double> coords = new Dictionary <string, double>();
if (!Double.IsNaN(latitude))
{
coords.Add("latitude", latitude);
}
if (!Double.IsNaN(longitude))
{
coords.Add("longitude", longitude);
}
if (!Double.IsNaN(altitude))
{
coords.Add("altitude", altitude);
}
if (!Double.IsNaN(accuracy))
{
coords.Add("accuracy", accuracy);
}
if (!Double.IsNaN(altitudeAccuracy))
{
coords.Add("altitudeAccuracy", altitudeAccuracy);
}
if (!Double.IsNaN(heading))
{
coords.Add("heading", heading);
}
if (!Double.IsNaN(speed))
{
coords.Add("speed", speed);
}
// Create result
Dictionary <string, object> position = new Dictionary <string, object>();
position.Add("coords", coords);
position.Add("timestamp", timestamp);
result.Add("position", position);
return(result);
}
public static List <String> ToDataDump([NotNull] this Geocoordinate geocoordinate)
{
if (geocoordinate == null)
{
throw new ArgumentNullException("geocoordinate");
}
var results = new List <String>();
results.Add(String.Format("Position Source: {0}", geocoordinate.PositionSource));
results.Add(String.Format("Timestamp: {0:h:mm:ss tt}", geocoordinate.Timestamp));
results.Add(String.Format("Accuracy: {0} meters", geocoordinate.Accuracy));
results.Add(String.Format("Altitude Accuracy: {0} meters", geocoordinate.AltitudeAccuracy));
results.Add(String.Format("Speed: {0} meters/sec", geocoordinate.Speed));
results.Add(String.Format("Heading: {0} degrees", geocoordinate.Heading));
results.Add("Point:");
results.Add(String.Format(" GeoshapeType: {0}", geocoordinate.Point.GeoshapeType));
results.Add(" Position:");
results.Add(String.Format(" Latitude: {0} degrees", geocoordinate.Point.Position.Latitude));
results.Add(String.Format(" Longitude: {0} degrees", geocoordinate.Point.Position.Longitude));
results.Add(String.Format(" Altitude: {0}", geocoordinate.Point.Position.Altitude));
results.Add(String.Format(" Altitude Reference System: {0}", geocoordinate.Point.AltitudeReferenceSystem));
results.Add(String.Format(" SpatialReferenceId: {0}", geocoordinate.Point.SpatialReferenceId));
results.Add("Satellite Data:");
results.Add(String.Format(" HorizontalDilutionOfPrecision: {0}", geocoordinate.SatelliteData.HorizontalDilutionOfPrecision));
results.Add(String.Format(" VerticalDilutionOfPrecision: {0}", geocoordinate.SatelliteData.VerticalDilutionOfPrecision));
results.Add(String.Format(" PositionDilutionOfPrecision: {0}", geocoordinate.SatelliteData.PositionDilutionOfPrecision));
// Deprecated values:
// geocoordinate.Latitude
// geocoordinate.Longitude
// geocoordinate.Altitude
return(results);
}
private async void getPosicionActual()
{
var accessStatus = await Geolocator.RequestAccessAsync();
switch (accessStatus)
{
case GeolocationAccessStatus.Allowed:
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
MapIcon posicionActual = new MapIcon();
posicionActual.Location = myGeocoordinate.Point;
posicionActual.NormalizedAnchorPoint = new Point(0.5, 1.0);
posicionActual.Title = "MiPosicion";
posicionActual.Image = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/posicion_actual.png"));
posicionActual.ZIndex = 0;
editMap.MapElements.Add(posicionActual);
break;
case GeolocationAccessStatus.Denied:
break;
case GeolocationAccessStatus.Unspecified:
break;
}
}
public Location GetLocationByCoordinate(Geocoordinate geocoordinate)
{
// seattle - 47° 36′ 35″ N, 122° 19′ 59″ W - 47.609722, -122.333056
// paris - 48° 51′ 24.12″ N, 2° 21′ 2.88″ E - 48.8567, 2.3508
// rome - 41° 54′ 0″ N, 12° 30′ 0″ E - 41.9, 12.5
// new york city - 40° 39′ 51″ N, 73° 56′ 19″ W - 40.664167, -73.938611
if (geocoordinate != null)
{
if (geocoordinate.Latitude == 47.609722 && geocoordinate.Longitude == -122.333056)
{
return(CreateLocation(1, "Seattle", "United States", "Washington"));
}
else if (geocoordinate.Latitude == 48.8567 && geocoordinate.Longitude == 2.3508)
{
return(CreateLocation(2, "Paris", "France"));
}
else if (geocoordinate.Latitude == 41.9 && geocoordinate.Longitude == 12.5)
{
return(CreateLocation(3, "Rome", "Italy"));
}
else if (geocoordinate.Latitude == 40.664167 && geocoordinate.Longitude == -73.938611)
{
return(CreateLocation(4, "New York", "United States", "New York"));
}
}
// For the purposes of these labs, always default to Seattle
return(CreateLocation(1, "Seattle", "United States", "Washington"));
}
public static string ToJson(this Geocoordinate geocoordinate)
{
var numberFormatInfo = (NumberFormatInfo)NumberFormatInfo.CurrentInfo.Clone();
numberFormatInfo.NaNSymbol = "0";
numberFormatInfo.NumberDecimalSeparator = ".";
return(string.Format("{{ " +
"\"accuracy\": {0}," +
"\"latitude\": {1}," +
"\"longitude\": {2}," +
"\"altitude\": {3}," +
"\"altitudeAccuracy\": {4}," +
"\"heading\": {5}," +
"\"speed\": {6}," +
"\"timestamp\": {7}" +
"}}"
, geocoordinate.Accuracy.ToString(numberFormatInfo)
, geocoordinate.Latitude.ToString(numberFormatInfo)
, geocoordinate.Longitude.ToString(numberFormatInfo)
, geocoordinate.Altitude.HasValue ? geocoordinate.Altitude.Value.ToString(numberFormatInfo) : "0"
, geocoordinate.AltitudeAccuracy.HasValue ? geocoordinate.AltitudeAccuracy.Value.ToString(numberFormatInfo) : "0"
, geocoordinate.Heading.HasValue ? geocoordinate.Heading.Value.ToString(numberFormatInfo) : "0"
, geocoordinate.Speed.HasValue ? geocoordinate.Speed.Value.ToString(numberFormatInfo) : "0"
, geocoordinate.Timestamp.DateTime.ToJavaScriptMilliseconds()));
}
/*For see you location on the map*/
private async void ShowMyLocationOnTheMap()
{
// Get my current location.
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
GeoCoordinate myGeoCoordinate = CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);
// Make my current location the center of the Map.
//MessageBox.Show("Latitude" + myGeoCoordinate.Latitude+ "Longitud: " + myGeoCoordinate.Longitude + "Altitud:"+myGeoCoordinate.Altitude);
place = myGeocoordinate.ToGeoCoordinate().ToString();
this.mapWithMyLocation.Center = myGeoCoordinate;
this.mapWithMyLocation.ZoomLevel = 13;
// Create a small circle to mark the current location.
Ellipse myCircle = new Ellipse();
myCircle.Fill = new SolidColorBrush(Colors.Blue);
myCircle.Height = 20;
myCircle.Width = 20;
myCircle.Opacity = 50;
// Create a MapOverlay to contain the circle.
MapOverlay myLocationOverlay = new MapOverlay();
myLocationOverlay.Content = myCircle;
myLocationOverlay.PositionOrigin = new Point(0.5, 0.5);
myLocationOverlay.GeoCoordinate = myGeoCoordinate;
// Create a MapLayer to contain the MapOverlay.
MapLayer myLocationLayer = new MapLayer();
myLocationLayer.Add(myLocationOverlay);
// Add the MapLayer to the Map.
mapWithMyLocation.Layers.Add(myLocationLayer);
}
void LoadUserPosition(Geocoordinate userCoordinate, bool center)
{
var userPosition = new BasicGeoposition
{
Latitude = userCoordinate.Point.Position.Latitude,
Longitude = userCoordinate.Point.Position.Longitude
};
var point = new Geopoint(userPosition);
CreateCircle();
if (Control.Children.Contains(_userPositionCircle))
{
Control.Children.Remove(_userPositionCircle);
}
MapControl.SetLocation(_userPositionCircle, point);
MapControl.SetNormalizedAnchorPoint(_userPositionCircle, new Windows.Foundation.Point(0.5, 0.5));
Control.Children.Add(_userPositionCircle);
if (center)
{
Control.Center = point;
Control.ZoomLevel = 13;
}
}
public async void pollLocation(string parameters)
{
if (!polling)
{
polling = true;
string[] args = WPCordovaClassLib.Cordova.JSON.JsonHelper.Deserialize <string[]>(parameters);
int watchId = int.Parse(args[0]);
MobiLocationListener listen = listeners.Where <MobiLocationListener>(x => x.index == watchId).FirstOrDefault();
if (listen != null)
{
Geoposition geoposition = await GetPosition(listen.maxAge, listen.highAccuracy);
Geocoordinate cord = geoposition.Coordinate;
System.Globalization.CultureInfo ci = new CultureInfo("en-US");
// AppMobi.Geolocation.prototype.successCB = function (ID, latitude, longitude, altitude, accuracy, altitudeAccuracy, heading, speed, timestamp) {
var js = string.Format(ci, "javascript:intel.xdk.geolocation.successCB({0},{1},{2},{3},{4},{5},{6},{7},'{8}');", listen.successID,
(cord.Latitude != null) ? cord.Latitude : 0.00,
(cord.Longitude != null) ? cord.Longitude : 0.00,
(cord.Altitude != null) ? cord.Altitude : 0.00,
(cord.Accuracy != null) ? cord.Accuracy : 0.00,
(cord.AltitudeAccuracy != null) ? cord.AltitudeAccuracy : 0.00,
(cord.Heading.HasValue && !Double.IsNaN(cord.Heading.Value)) ? cord.Heading : 0.00,
(cord.Speed.HasValue && !Double.IsNaN(cord.Speed.Value)) ? cord.Speed : 0.00,
cord.Timestamp);
//InjectJS(js);
InvokeCustomScript(new ScriptCallback("eval", new string[] { js }), true);
}
polling = false;
}
}
public InfoBox(Geocoordinate center, InfoboxOptions options, string id)
{
Id = Guid.NewGuid().ToString();
Center = center;
JSRuntime.Current.InvokeAsync <object>(_infoboxRegister, Id, center, options);
thisRef = new DotNetObjectRef(this);
}
//Nearby List Methods***********************************************************************************************************************************************************//
private async void getNearbyStops()
{
if (refreshingNearby == false)
{
refreshingNearby = true;
try
{
Geocoordinate myCoordinate = await GeoLocator.getMyLocation();
if (myCoordinate != null)
{
nearbyStops = await OCTranspoStopsData.getCloseStops(myCoordinate.Latitude, myCoordinate.Longitude, currentLocation.ZoomLevel);
this.nearbyList.ItemsSource = nearbyStops;
setNearbyErrorMessage(true, nearbyStops.Count > 0);
}
else
{
nearbySorry.Visibility = nearbyStops.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
nearbyFrown.Visibility = nearbyStops.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
setNearbyErrorMessage(true, false);
}
}
catch
{
setNearbyErrorMessage(false, false);
}
refreshingNearby = false;
}
}
public Location GetLocationByCoordinate(Geocoordinate geocoordinate)
{
// seattle - 47° 36′ 35″ N, 122° 19′ 59″ W - 47.609722, -122.333056
// paris - 48° 51′ 24.12″ N, 2° 21′ 2.88″ E - 48.8567, 2.3508
// rome - 41° 54′ 0″ N, 12° 30′ 0″ E - 41.9, 12.5
// new york city - 40° 39′ 51″ N, 73° 56′ 19″ W - 40.664167, -73.938611
//if (geocoordinate.Latitude == 47.609722 && geocoordinate.Longitude == -122.333056)
//{
return(CreateLocation(1, "Seattle", "United States", "Washington"));
//}
//else if (geocoordinate.Latitude == 48.8567 && geocoordinate.Longitude == 2.3508)
//{
//return CreateLocation(2, "Paris", "France");
//}
//else if (geocoordinate.Latitude == 41.9 && geocoordinate.Longitude == 12.5)
//{
// return CreateLocation(3, "Rome", "Italy");
//}
//else if (geocoordinate.Latitude == 40.664167 && geocoordinate.Longitude == -73.938611)
//{
// return CreateLocation(4, "New York", "United States", "New York");
//}
//else
//{
// return null;
//}
}
private void DrawLine(Geocoordinate pos)
{
// first check for any lines we need to draw from coordinates gathered while app
// was running in the background:
if (App.tempChartData != null && App.tempChartData.Count() > 0)
{
GeoCoordinate tempLast = new GeoCoordinate(App.tempChartData[0].Coordinate.Latitude, App.tempChartData[0].Coordinate.Longitude);
for (int i = 1; i < App.tempChartData.Count(); i++)
{
GeoCoordinate thisCoord = new GeoCoordinate(App.tempChartData[i].Coordinate.Latitude, App.tempChartData[i].Coordinate.Longitude);
MapPolyline tempLine = new MapPolyline();
tempLine.StrokeColor = Colors.Blue;
tempLine.StrokeThickness = 15;
tempLine.Path.Add(tempLast);
tempLine.Path.Add(thisCoord);
MainMap.MapElements.Add(tempLine);
tempLast = thisCoord;
}
// reset:
App.tempChartData = null;
}
MapPolyline line = new MapPolyline();
line.StrokeColor = Colors.Blue;
line.StrokeThickness = 15;
line.Path.Add(new GeoCoordinate(App.LastCoordinate.Latitude, App.LastCoordinate.Longitude));
line.Path.Add(new GeoCoordinate(pos.Latitude, pos.Longitude));
MainMap.MapElements.Add(line);
}
public async void ShowLocationOnMap()
{
Geolocator geolocator = new Geolocator();
Geoposition geoposition = await geolocator.GetGeopositionAsync(); // Get geolocation
Geocoordinate geocoordinate = geoposition.Coordinate;
geoCoordinate = CoordinateConverter.ConvertGeocoordinate(geocoordinate); // Convert to a maps control compatible class
map.Center = geoCoordinate; // Set current location as the centre of the map
map.ZoomLevel = 13;
// Create blue circle shown in app
Ellipse marker = new Ellipse();
marker.Fill = new SolidColorBrush(Colors.Blue);
marker.Height = 20;
marker.Width = 20;
marker.Opacity = 50;
// Overlay blue circle on map control
MapOverlay mapOverlay = new MapOverlay();
mapOverlay.Content = marker;
mapOverlay.PositionOrigin = new Point(0.5, 0.5);
mapOverlay.GeoCoordinate = geoCoordinate;
MapLayer mapLayer = new MapLayer();
mapLayer.Add(mapOverlay);
map.Layers.Add(mapLayer);
}
private async void ShowMyLocationOnTheMap()
{
// Get my current location.
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
GeoCoordinate myGeoCoordinate = CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);
// Create a small circle to mark the current location.
Ellipse myCircle = new Ellipse();
myCircle.Fill = new SolidColorBrush(Colors.Blue);
myCircle.Height = 20;
myCircle.Width = 20;
myCircle.Opacity = 50;
// Create a MapOverlay to contain the circle.
MapOverlay myLocationOverlay = new MapOverlay();
myLocationOverlay.Content = myCircle;
myLocationOverlay.PositionOrigin = new Point(0.5, 0.5);
myLocationOverlay.GeoCoordinate = myGeoCoordinate;
// Create a MapLayer to contain the MapOverlay.
MapLayer myLocationLayer = new MapLayer();
myLocationLayer.Add(myLocationOverlay);
// Add the MapLayer to the Map.
Haritam.Layers.Add(myLocationLayer);
}
/// <summary>
/// Se encarga de obtener los FeedXively en un radio de 1km.
/// </summary>
private async void ObetenerFeedXively()
{
/// Que esten muchas condiciones anidadas es porque cada llamado se demora su tiempo, puede
/// que se pierda la conexión en algun momento.
if (HayConexiónInternet())
{
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
if (HayConexiónInternet())
{
Double la = Convert.ToDouble(myGeoposition.Coordinate.Latitude);
Double lo = Convert.ToDouble(myGeoposition.Coordinate.Longitude);
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
GeoCoordinate myGeoCoordinate = CoordinateConverter.ConvertGeocoordinate(myGeocoordinate);
if (HayConexiónInternet())
{
WSSemanticSearchSoapClient WS = new WSSemanticSearchSoapClient();
WS.RetornarMapaLugarDatapointsAsync(la, lo, paramConsulta, DateTime.Now.AddSeconds(tSegundosAntes), DateTime.Now, "Español", rangoConsulta);
WS.RetornarMapaLugarDatapointsCompleted += ob_RetornarMapaLugarDatapointsCompleted;
}
}
}
}
/// <summary>
/// Get the currrent geolocation position
/// </summary>
/// <param name="parameters"></param>
public async void getCurrentPosition(string parameters)
{
string[] args = WPCordovaClassLib.Cordova.JSON.JsonHelper.Deserialize <string[]>(parameters);
if (args.Length > 3)
{
successCallbackID = int.Parse(args[0]);
errorCallbackID = int.Parse(args[1]);
maximumAge = int.Parse(args[2]);
highAccuracy = bool.Parse(args[3]);
}
Geoposition geoposition = await GetPosition(maximumAge, highAccuracy);
Geocoordinate cord = geoposition.Coordinate;
System.Globalization.CultureInfo ci = new CultureInfo("en-US");
// AppMobi.Geolocation.prototype.successCB = function (ID, latitude, longitude, altitude, accuracy, altitudeAccuracy, heading, speed, timestamp) {
var js = string.Format(ci, "javascript:intel.xdk.geolocation.successCB({0},{1},{2},{3},{4},{5},{6},{7},'{8}');", successCallbackID,
(cord.Latitude != null) ? cord.Latitude : 0.00,
(cord.Longitude != null) ? cord.Longitude : 0.00,
(cord.Altitude != null) ? cord.Altitude : 0.00,
(cord.Accuracy != null) ? cord.Accuracy : 0.00,
(cord.AltitudeAccuracy != null) ? cord.AltitudeAccuracy : 0.00,
(cord.Heading != null) ? cord.Heading : 0.00,
(cord.Speed != null) ? cord.Speed : 0.00,
cord.Timestamp);
//DispatchCommandResult(new PluginResult(PluginResult.Status.OK, js));
InvokeCustomScript(new ScriptCallback("eval", new string[] { js }), true);
//InjectJS(js);
}
private async void ShowMyLocationOnTheMap()
{
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
GeoCoordinate myGeoCoordinate = CoordinateConverterRed.ConvertGeocoordinateRed(myGeocoordinate);
this.map.Center = myGeoCoordinate;
this.map.ZoomLevel = 17;
Ellipse myCircle = new Ellipse();
myCircle.Fill = new SolidColorBrush(Colors.Red);
myCircle.Height = 20;
myCircle.Width = 20;
myCircle.Opacity = 50;
MapOverlay myLocationOverlay = new MapOverlay();
myLocationOverlay.Content = myCircle;
myLocationOverlay.PositionOrigin = new Point(0.5, 0.5);
myLocationOverlay.GeoCoordinate = myGeoCoordinate;
MapLayer myLocationLayer = new MapLayer();
myLocationLayer.Add(myLocationOverlay);
map.Layers.Add(myLocationLayer);
}
public static LocationServicePosition ToLocationServicePosition(this Geocoordinate coordinate)
{
#if WINDOWS_PHONE
return(new LocationServicePosition(
coordinate.Timestamp,
coordinate.Latitude,
coordinate.Longitude,
coordinate.Accuracy,
coordinate.Altitude,
coordinate.AltitudeAccuracy,
coordinate.Heading,
coordinate.Speed));
#else
var point = coordinate.Point;
var position = point.Position;
return(new LocationServicePosition(
coordinate.Timestamp,
position.Latitude,
position.Longitude,
coordinate.Accuracy,
position.Altitude,
coordinate.AltitudeAccuracy,
coordinate.Heading,
coordinate.Speed));
#endif
}
private async void ContextMenu_Click(object sender, RoutedEventArgs e)
{
MenuItem menuItem = sender as MenuItem;
if (menuItem != null && ((sender as MenuItem).DataContext is PointOfInterest))
{
PointOfInterest poiSelected = (sender as MenuItem).DataContext as PointOfInterest;
switch (menuItem.Name)
{
case "POIGet":
try
{
ViewModel.Loading = true;
BingMapsDirectionsTask bingMap = new BingMapsDirectionsTask();
// Get my current location.
Geolocator myGeolocator = new Geolocator();
Geoposition myGeoposition = await myGeolocator.GetGeopositionAsync();
Geocoordinate myGeocoordinate = myGeoposition.Coordinate;
bingMap.Start = new LabeledMapLocation();
bingMap.End = new LabeledMapLocation();
bingMap.Start.Label = AppResources.YourPosition;
bingMap.Start.Location = new GeoCoordinate(myGeocoordinate.Point.Position.Latitude, myGeocoordinate.Point.Position.Longitude);
bingMap.End.Location = poiSelected.Coordinate;
bingMap.End.Label = poiSelected.Name;
bingMap.Show();
ViewModel.Loading = false;
}
catch (Exception)
{
// the app does not have the right capability or the location master switch is off
MessageBox.Show(AppResources.LocationError, AppResources.Warning, MessageBoxButton.OK);
}
break;
case "POIShare":
ShareStatusTask status = new ShareStatusTask();
status.Status = String.Format(AppResources.IamHere, poiSelected.Name);
status.Show();
break;
case "POIPictures":
ViewModel.ListPhotoCommand.Execute(poiSelected);
break;
case "POINotes":
ViewModel.ListNoteCommand.Execute(poiSelected);
break;
case "EditPoi":
ViewModel.EditPOICommand.Execute(new Tuple <int, Mode>(poiSelected.Id, Mode.edit));
break;
case "DeletePOI":
ConfirmDeletePOI(poiSelected);
break;
}
}
}
public Room(string _roomcode, Floor _floor, Building _building, string _type, Geocoordinate _latlon)
{
roomCode = _roomcode;
floor = _floor;
building = _building;
type = _type;
location = _latlon;
}
internal static Location ToLocation(this Geocoordinate coordinate) =>
new Location
{
Latitude = coordinate.Point.Position.Latitude,
Longitude = coordinate.Point.Position.Longitude,
TimestampUtc = coordinate.Timestamp,
Accuracy = coordinate.Accuracy
};
public GpsReading(Geocoordinate coordinate)
{
this.coordinate = coordinate;
this.Position = new Position(
coordinate.Point.Position.Latitude,
coordinate.Point.Position.Longitude
);
}
//TODO: Bounding Locations
public static async void centerMapOnCurrentLocation(Map map)
{
Geocoordinate coordinate = await getMyLocation();
if (coordinate != null)
{
map.Center = new GeoCoordinate(coordinate.Latitude, coordinate.Longitude);
}
}
protected virtual void OnPosChanged(Geocoordinate e)
{
var handler = PosChanged;
if (handler != null)
{
handler(this, e);
}
}
//METODOS DE LOCALIZACION Y MAPA
//busca la ubicacion, situa al usuario y al mapa, e inicia el seguimiento
private async void iniciamapa()
{
geolocator.DesiredAccuracyInMeters = DesiredAccuracyInMeters;
geolocator.DesiredAccuracy = PositionAccuracy.High;
try
{
prog.IsVisible = true;
prog.Text = "Obteniendo localización";
IAsyncOperation <Geoposition> locationTask = null;
try
{
locationTask = geolocator.GetGeopositionAsync(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(15));
Geoposition position = await locationTask;
Geocoordinate myGeocoordinate = position.Coordinate;
GeoCoordinate myGeoCoordinate = ConvertGeocoordinate(myGeocoordinate);
centro = myGeoCoordinate;
prog.Text = "Localización obtenida";
this.mapacentral.Center = myGeoCoordinate;
usuariocordx = position.Coordinate.Latitude;
usuariocordy = position.Coordinate.Longitude;
setPosition(position.Coordinate.Latitude, position.Coordinate.Longitude);
ReverseGeocodeQuery query = new ReverseGeocodeQuery();
query.GeoCoordinate = new GeoCoordinate(position.Coordinate.Latitude, position.Coordinate.Longitude);
query.QueryCompleted += ReverseGeocodeQuery_QueryCompleted;
query.QueryAsync();
localespincho(position.Coordinate.Latitude, position.Coordinate.Longitude);
Uri url = new Uri("http://produccion.rl2012alc.com/api/index.php/setPosition ");
objetoslistas.getByCoord paquete = new objetoslistas.getByCoord();
paquete.latitude = position.Coordinate.Latitude;
paquete.longitude = position.Coordinate.Longitude;
string respuesta = await metodosJson.jsonPOST(url, paquete);
if (listapinchos.Count > 0)
{
checklocal();
}
}
finally
{
if (locationTask != null)
{
if (locationTask.Status == AsyncStatus.Started)
{
locationTask.Cancel();
}
locationTask.Close();
}
}
}
catch (Exception)
{
// the app does not have the right capability or the location master switch is off
MessageBoxResult result = MessageBox.Show("Location is disabled in phone settings", "ERROR", MessageBoxButton.OK);
}
}
/// <summary>
/// Creates a new search condition to lookup for records around the given coordinates
/// </summary>
/// <param name="location">The coordinates to use for the search</param>
/// <param name="maxDistance">The radius in meters to search around the coordinates</param>
public CBHelperSearchCondition(Geocoordinate location, double maxDistance)
{
List<double> points = new List<double>();
points.Add(location.Latitude);
points.Add(location.Longitude);
this.field = "cb_location";
this.conditionOperator = CBConditionOperator.CBOperatorEqual;
Dictionary<string, object> searchQuery = new Dictionary<string, object>();
searchQuery.Add("$near", points);
if (maxDistance != -1)
{
searchQuery.Add("$maxDistance", (maxDistance / 1000) / 111.12);
}
this.value = searchQuery;
this.Limit = -1;
this.Offset = -1;
this.CommandType = CBDataAggregationCommandType.CBDataAggregationMatch;
}
private double GetDistanceBetween(Geocoordinate origin, Geocoordinate other)
{
if (double.IsNaN(origin.Latitude) || double.IsNaN(origin.Longitude) || double.IsNaN(other.Latitude) || double.IsNaN(other.Longitude))
{
throw new ArgumentException("Argument_LatitudeOrLongitudeIsNotANumber");
}
else
{
double latitude = origin.Latitude * 0.0174532925199433;
double longitude = origin.Longitude * 0.0174532925199433;
double num = other.Latitude * 0.0174532925199433;
double longitude1 = other.Longitude * 0.0174532925199433;
double num1 = longitude1 - longitude;
double num2 = num - latitude;
double num3 = Math.Pow(Math.Sin(num2 / 2), 2) + Math.Cos(latitude) * Math.Cos(num) * Math.Pow(Math.Sin(num1 / 2), 2);
double num4 = 2 * Math.Atan2(Math.Sqrt(num3), Math.Sqrt(1 - num3));
double num5 = 6376500 * num4;
return num5;
}
}
public void StopStream()
{
this.callTimer.Stop();
this.foundObjects.Clear();
this.previousPosition = null;
}
private void updateObjects(object sender, object e)
{
Geocoordinate currentLocation = this.GetLatestPosition(this.streamName);
if (this.previousPosition != null)
{
double distance = this.GetDistanceBetween(this.previousPosition, currentLocation);
if (distance < this.queryRadius / CBGEODATASTREAM_RADIUS_RATIO)
{
if (this.helper.DebugMode)
{
System.Diagnostics.Debug.WriteLine("Not enough distance between the two points. returning without fetching data");
}
return;
}
double speed = distance / CBGEODATASTREAM_UPDATE_SPEED;
double ratio = 1.0;
if (this.helper.DebugMode)
{
System.Diagnostics.Debug.WriteLine("Computed speed " + speed + " meters per second");
}
if (this.previousSpeed != 0.0)
{
ratio = speed / previousSpeed;
}
if (this.queryRadius * ratio < this.SearchRadius)
{
this.queryRadius = this.SearchRadius;
}
else
{
this.queryRadius = this.queryRadius * ratio;
}
this.previousSpeed = speed;
}
this.previousPosition = currentLocation;
CBHelperSearchCondition condition = new CBHelperSearchCondition(currentLocation, this.queryRadius);
this.helper.SearchDocument(this.CollectionName, condition, delegate(CBResponseInfo resp)
{
if (resp.Status && resp.Data != null)
{
List<object> data = ((JArray)resp.Data).ToObject<List<object>>();
foreach (JObject curPointObject in data)
{
Dictionary<string, object> curPoint = curPointObject.ToObject<Dictionary<string, object>>();
Dictionary<string, double> locationData = ((JObject)curPoint["cb_location"]).ToObject<Dictionary<string, double>>();
CBGeoLocatedObject newObj = new CBGeoLocatedObject();
newObj.Latitude = locationData["lat"];
newObj.Longitude = locationData["lng"];
if (curPoint["cb_location_altitude"] != null)
{
newObj.Altitude = Convert.ToDouble(curPoint["cb_location_altitude"]);
}
newObj.ObjectData = curPoint;
if (!this.foundObjects.Keys.Contains(Convert.ToString(newObj.Hash())))//(this.foundObjects[Convert.ToString(newObj.Hash())] == null)
{
this.foundObjects.Add(Convert.ToString(newObj.Hash()), newObj);
this.ReceivedPoint(this.streamName, newObj);
}
}
}
else
{
System.Diagnostics.Debug.WriteLine("Failed call to the cloudbase.io APIs");
}
return true;
});
List<string> itemsToRemove = new List<string>();
foreach (KeyValuePair<string, CBGeoLocatedObject> item in this.foundObjects)
{
if (this.GetDistanceBetween(item.Value.Latitude, item.Value.Longitude, currentLocation.Latitude, currentLocation.Longitude) > this.SearchRadius)
{
this.RemovingPoint(this.streamName, item.Value);
itemsToRemove.Add(item.Key);
}
}
foreach (string itemKey in itemsToRemove)
{
this.foundObjects.Remove(itemKey);
}
}