protected override async void OnAppearing()
{
base.OnAppearing();
if (hasLocationPermission)
{
if (CrossGeolocator.IsSupported && CrossGeolocator.Current.IsGeolocationAvailable && CrossGeolocator.Current.IsGeolocationEnabled)
{
locator.PositionChanged += Locator_PositionChanged;
await locator.StartListeningAsync(TimeSpan.FromSeconds(0), 50, true);
var position = await locator.GetPositionAsync();
var center = new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude);
var span = new Xamarin.Forms.Maps.MapSpan(center, 2, 2);
locationsMap.MoveToRegion(MapSpan.FromCenterAndRadius(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude),
Distance.FromMiles(1)));
//using (SQLiteConnection conn = new SQLiteConnection(App.DatabaseLocation))
//{
// conn.CreateTable<Post>();
// var posts = conn.Table<Post>().ToList();
// DisplayInMap(posts);
//}
var posts = await Post.Read();
DisplayInMap(posts);
}
}
}
// build uri for request
async Task <string> GenerateRequestUri()
{
// get user's location
var position = await userLocator.GetPositionAsync();
// uri request
string requestUri = $"v1/incidents/raw-data?lat={position.Latitude}" +
$"&lon={position.Longitude}" +
$"&distance=km" +
$"&datetime_ini={DateTime.Now.AddDays(-(Int32.Parse("2"))):yyyy-MM-ddTHH:mm:ss.fffZ}" +
$"&datetime_end={DateTime.Now:yyyy-MM-ddTHH:mm:ss.fffZ}";
return(requestUri);
}
protected async override void OnElementChanged(ElementChangedEventArgs <Map> e)
{
if (_map != null)
{
_map.MapClick -= googleMap_MapClick;
}
base.OnElementChanged(e);
if (Control != null)
{
((MapView)Control).GetMapAsync(this);
}
location = CrossGeolocator.Current;
location.DesiredAccuracy = 100;
try
{
position = await location.GetPositionAsync(TimeSpan.FromSeconds(10));
await((MapTapRenderer)Element).ChangePosition(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude));
Console.WriteLine("pos android" + position.Latitude.ToString() + " , " + position.Longitude.ToString());
SetMarker(position.Latitude, position.Longitude);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// 非同期で現在座標を取得する
/// </summary>
/// <param name="timeout">タイムアウト時間</param>
/// <returns>現在の座標</returns>
public async Task <GeoCoordinate> GetGeoCoordinateAsync(int timeout)
{
//指定した秒数までを限度に現在の位置を取得する
Position position = await _locator.GetPositionAsync(timeout : new TimeSpan(timeout));
return(this.ConvertGeoCoordinate(position));
}
protected async override void OnElementChanged(ElementChangedEventArgs <View> e)
{
if ((MapTapRenderer)Element != null)
{
if (Control != null)
{
Control.RemoveGestureRecognizer(_tapRecogniser);
}
base.OnElementChanged(e);
if (Control != null && ((MapTapRenderer)Element).IsEnabled)
{
Control.AddGestureRecognizer(_tapRecogniser);
}
locationG = CrossGeolocator.Current;
locationG.DesiredAccuracy = 100;
try
{
position = await locationG.GetPositionAsync(TimeSpan.FromSeconds(10));
await((MapTapRenderer)Element).ChangePosition(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude));
((MapTapRenderer)Element).SetLocation(new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
private async void GetLocation()
{
//var locator = CrossGeolocator.Current;
position = await geolocator.GetPositionAsync();
await geolocator.StartListeningAsync(TimeSpan.FromMinutes(30), 500);
}
private async Task <XLabs.Platform.Services.Geolocation.Position> GetCurrentPosition()
{
IGeolocator geolocator = Resolver.Resolve <IGeolocator>();
XLabs.Platform.Services.Geolocation.Position result = null;
if (geolocator.IsGeolocationEnabled)
{
try {
if (!geolocator.IsListening)
{
geolocator.StartListening(1000, 1000);
}
var task = await geolocator.GetPositionAsync(10000);
result = task;
System.Diagnostics.Debug.WriteLine("[GetPosition] Lat. : {0} / Long. : {1}", result.Latitude.ToString("N4"), result.Longitude.ToString("N4"));
}
catch (Exception e) {
System.Diagnostics.Debug.WriteLine("Error : {0}", e);
}
}
return(result);
}
public static async Task <Position> GetCurrentPosition()
{
IGeolocator locator = CrossGeolocator.Current;
locator.DesiredAccuracy = Constants.MapDesiredAccuracy;
Position position = await locator.GetLastKnownLocationAsync();
if (position != null)
{
return(position);
}
if (!locator.IsGeolocationAvailable || !locator.IsGeolocationEnabled)
{
return(null);
}
position = await locator.GetPositionAsync(TimeSpan.FromSeconds(Constants.TimeOutSmall), null, true);
if (position == null)
{
return(null);
}
return(position);
}
async void RefreshActionAsync()
{
IsRefreshing = true;
await ItemReportStorage.Refresh(await Geolocator.GetPositionAsync(), 1.0);
IsRefreshing = false;
}
async Task <bool> StartTracking()
{
geolocator = CrossGeolocator.Current;
if (!geolocator.IsGeolocationAvailable)
{
DisplayAlert("Error", "Location is not awailable", "Ok");
return(false);
}
Position result = null;
try {
geolocator.DesiredAccuracy = 50;
if (!geolocator.IsListening)
{
await geolocator.StartListeningAsync(5, 10);
}
oldPosition = await geolocator.GetPositionAsync(50000, CancellationToken.None);
geolocator.PositionChanged += Geolocator_PositionChanged;
} catch (Exception ex) {
System.Diagnostics.Debug.WriteLine("Error : {0}", ex);
return(false);
}
return(true);
}
public async Task <Xamarin.Forms.Maps.Position> GetPosition()
{
IsBusy = true;
Xamarin.Forms.Maps.Position p;
try
{
if (!locator.IsGeolocationAvailable)
{
p = new Xamarin.Forms.Maps.Position();
}
if (!locator.IsGeolocationEnabled)
{
p = new Xamarin.Forms.Maps.Position();
}
var position = await locator.GetPositionAsync(timeoutMilliseconds : 10000);
p = new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
p = new Xamarin.Forms.Maps.Position();
}
IsBusy = false;
return(p);
}
private async void GetGPS()
{
IGeolocator locator = CrossGeolocator.Current;
locator.DesiredAccuracy = 50;
if (locator.IsGeolocationAvailable)
{
if (locator.IsGeolocationEnabled)
{
try
{
position = await locator.GetPositionAsync(timeoutMilliseconds : 10000);
AddListItem("Latitude:\t" + position.Latitude + "\nLongitude:\t" + position.Longitude);
}
catch
{
await DisplayAlert("Error", "Could not get GPS data.", "OK");
}
}
}
list.ScrollTo(listItems.Last(), ScrollToPosition.End, true);
}
protected override void OnAppearing()
{
Device.BeginInvokeOnMainThread(async() =>
{
if (_geolocator.IsGeolocationEnabled)
{
_position = await _geolocator.GetLastKnownLocationAsync();
if (_position == null)
{
_position = await _geolocator.GetPositionAsync();
}
var formsMapPosition = new Xamarin.Forms.Maps.Position(_position.Latitude, _position.Longitude);
var mapSpan = MapSpan.FromCenterAndRadius(formsMapPosition, Distance.FromKilometers(1.5));
_map.MoveToRegion(mapSpan);
Incidents = await AdaptatonEndpoint.Instance.GetIncidents();
foreach (var incident in Incidents)
{
_map.Pins.Add(new Pin
{
Position = new Xamarin.Forms.Maps.Position((double)incident.Latitude,
(double)incident.Longitude),
Label = incident.Id
});
}
}
else
{
await DisplayAlert("Un momento", "Debes activar tu GPS para usar la aplicación.", "OK");
}
});
}
async private void Button_Clicked_In(object sender, EventArgs e)
{
try
{
IsBusy = true;
IGeolocator locator = CrossGeolocator.Current;
locator.DesiredAccuracy = 50;
Position position = await locator.GetPositionAsync(TimeSpan.FromSeconds(10));
AttendanceModel model = new AttendanceModel()
{
IsMockedLocation = App._IsMockLocation.ToString(),
Latitude = Convert.ToString(position.Latitude),
Longitude = Convert.ToString(position.Longitude),
UserId = Convert.ToString(App._UserId),
AttendanceMode = "IN"
};
await CallApiForAttendance(model);
}
catch (Exception ex)
{
lblMessage.Text = ex.Message;
lblMessage.TextColor = Color.Red;
}
finally
{
IsBusy = false;
}
}
public async Task <Position> GetPositionAsync()
{
geolocator.DesiredAccuracy = 1000;
var position = await geolocator.GetPositionAsync();
return(new Position(position.Latitude, position.Longitude));
}
public async Task <bool> GetLocation()
{
Position currentpos = null;
try
{
currentpos = await _locator.GetPositionAsync(timeout : _timeout);
}
catch (Exception e) {
Console.WriteLine("Geolocator.GetLocation error: " + e.Message);
}
if (currentpos != null)
{
Latitude = currentpos.Latitude;
Longitude = currentpos.Longitude;
Timestamp = currentpos.Timestamp.DateTime;
return(true);
}
else
{
return(false);
}
}
private async Task GetPosition()
{
var _cancelSource = new CancellationTokenSource();
TaskScheduler _scheduler = TaskScheduler.FromCurrentSynchronizationContext();
var PositionStatus = string.Empty;
var PositionLatitude = string.Empty;
var PositionLongitude = string.Empty;
var IsBusy = true;
await
Geolocator.GetPositionAsync(10000, _cancelSource.Token, true).ContinueWith(t =>
{
IsBusy = false;
if (t.IsFaulted)
{
PositionStatus = ((GeolocationException)t.Exception.InnerException).Error.ToString();
_contentpage.DisplayAlert("sdf", PositionStatus, "asd");
}
else if (t.IsCanceled)
{
_contentpage.DisplayAlert("sdf", "IsCanceled", "asd");
}
else
{
PositionLatitude = "La: " + t.Result.Latitude.ToString("N4");
PositionLongitude = "Lo: " + t.Result.Longitude.ToString("N4");
_contentpage.DisplayAlert("sdf", PositionLatitude + "," + PositionLongitude, "asd");
}
}, _scheduler);
}
protected override void OnAppearing()
{
Device.BeginInvokeOnMainThread(async() =>
{
if (_geolocator.IsGeolocationEnabled)
{
_position = await _geolocator.GetLastKnownLocationAsync();
if (_position == null)
{
_position = await _geolocator.GetPositionAsync();
}
var formsMapPosition = new Xamarin.Forms.Maps.Position(_position.Latitude, _position.Longitude);
var mapSpan = MapSpan.FromCenterAndRadius(formsMapPosition, Distance.FromKilometers(1));
_map.MoveToRegion(mapSpan);
MyPositionPin = new Pin
{
Address = "Mi ubicación",
Position = formsMapPosition,
Type = PinType.Generic,
Label = "Mi ubicación"
};
_map.Pins.Add(MyPositionPin);
}
else
{
await DisplayAlert("Un momento", "Debes activar tu GPS para usar la aplicación.", "OK");
}
});
}
async Task GetPosition()
{
// Inicia o Acelelometro
var device = Resolver.Resolve <IDevice>();
Debug.WriteLine(device.FirmwareVersion);
this.geolocator = DependencyService.Get <IGeolocator> ();
//geolocator.PositionError += OnPositionError;
//geolocator.PositionChanged += OnPositionChanged;
if (!geolocator.IsListening)
{
geolocator.StartListening(minTime: 1000, minDistance: 0);
}
var position = await geolocator.GetPositionAsync(timeout : 10000);
string message = string.Format("Latitude: {0} | Longitude: {1}", position.Latitude, position.Longitude);
Debug.WriteLine(message);
device.Accelerometer.ReadingAvailable += getEixos;
}
public async void MapViewInit()
{
CLLocationManager manager = new CLLocationManager();
manager.RequestWhenInUseAuthorization();
IGeolocator locator = CrossGeolocator.Current;
locator.DesiredAccuracy = 50;
Position position = await locator.GetPositionAsync(timeoutMilliseconds : 20000);
Console.WriteLine("Position Status: {0}", position.Timestamp);
Console.WriteLine("Position Latitude: {0}", position.Latitude);
Console.WriteLine("Position Longitude: {0}", position.Longitude);
CLLocationCoordinate2D mapCenter = new CLLocationCoordinate2D(position.Latitude, position.Longitude);
//CLLocationCoordinate2D mapCenter = new CLLocationCoordinate2D(22.617193, 120.3032346);
CenterLocation = map.CenterCoordinate = mapCenter;
map.Region = MKCoordinateRegion.FromDistance(mapCenter, 1000, 1000);
//map.ShowsUserLocation = true;
CustomMapViewDelegate customDelegate = new CustomMapViewDelegate();
customDelegate.OnRegionChanged += MapViewOnRegionChanged;
map.Delegate = customDelegate;
}
// added using System.Threading.Tasks;
public async Task <Position> GetLocation(TimeSpan minimumTime, int minimumMeters)
{
position = await locator.GetPositionAsync();
await locator.StartListeningAsync(minimumTime, minimumMeters);
return(position);
}
public async Task <bool> StartNavigation()
{
var locationPermission = DependencyService.Get <ILocationPermission>();
var permissionGranted = await locationPermission.CheckAndAsk();
GeoPosition position = null;
try
{
position = (await _geoLocator.GetPositionAsync()).ToGeoPosition();
} catch (GeolocationException e)
{
var properties = new Dictionary <string, string>
{
{ "Permission status", permissionGranted.ToString() }
};
Crashes.TrackError(e, properties);
return(false);
}
if (_route.GetSectionForPosition(position) == RouteExtensions.DefaultSection)
{
Application.Current.MainPage = new NotNearRoutePage();
return(false);
}
NextWaypoint = _route.FindClosestWaypoint(position);
VisitedWaypoints = new List <RoutePoint> {
NextWaypoint
};
var section = _route.GetSectionForPosition(NextWaypoint);
NavigationDirection = _route.DetermineLongestDirectionInSection(NextWaypoint, section);
RouteEnumerator = _route.GetEnumerable(NextWaypoint, NavigationDirection).GetEnumerator();
RouteEnumerator.MoveNext();
ActivateNextWaypoint();
InitializeMap(position);
await StartListeningToLocationAsync();
return(true);
}
public async void GetLocation()
{
var position = await locator.GetPositionAsync(TimeSpan.FromSeconds(10));
lblPositionStatus.Text = position.Timestamp.ToString();
lblPositionLatitude.Text = position.Latitude.ToString();
lblPositionLongitude.Text = position.Longitude.ToString();
}
/// <summary>
/// Gets the current location.
/// </summary>
/// <returns>The current location.</returns>
public async Task <TaxiPosition> GetCurrentLocation()
{
var position = await m_locator.GetPositionAsync(10000);
m_currentTaxiPosition = new TaxiPosition(position.Latitude, position.Longitude);
return(m_currentTaxiPosition);
}
/// <summary>
/// Gets a GPS reading. Will block the current thread while waiting for a GPS reading. Should not
/// be called from the main / UI thread, since GPS runs on main thread (will deadlock). If you need
/// to get a reading from the UI thread, call GetReadingAsync instead.
/// </summary>
/// <returns>The reading.</returns>
/// <param name="cancellationToken">Cancellation token.</param>
/// <param name="checkAndObtainPermission">Whether or not to check for and obtain permission for the reading. Note that, on Android, this
/// may result in bringing the Sensus UI to the foreground. If you do not wish this to happen, then obtain the user's permission prior to
/// calling this method.</param>
public Position GetReading(CancellationToken cancellationToken, bool checkAndObtainPermission)
{
lock (_locker)
{
if (checkAndObtainPermission && SensusServiceHelper.Get().ObtainPermission(Permission.Location) != PermissionStatus.Granted)
{
return(null);
}
if (_readingIsComing)
{
SensusServiceHelper.Get().Logger.Log("A GPS reading is coming. Will wait for it.", LoggingLevel.Debug, GetType());
}
else
{
_readingIsComing = true; // tell any subsequent, concurrent callers that we're taking a reading
_readingWait.Reset(); // make them wait
Task.Run(async() =>
{
try
{
SensusServiceHelper.Get().Logger.Log("Taking GPS reading.", LoggingLevel.Debug, GetType());
DateTimeOffset readingStart = DateTimeOffset.UtcNow;
_locator.DesiredAccuracy = SensusServiceHelper.Get().GpsDesiredAccuracyMeters;
Position newReading = await _locator.GetPositionAsync(TimeSpan.FromMilliseconds(_readingTimeoutMS), cancellationToken);
DateTimeOffset readingEnd = DateTimeOffset.UtcNow;
if (newReading != null)
{
// create copy of new position to keep return references separate, since the same Position object is returned multiple times when a change listener is attached.
_reading = new Position(newReading);
SensusServiceHelper.Get().Logger.Log("GPS reading obtained in " + (readingEnd - readingStart).TotalSeconds + " seconds.", LoggingLevel.Verbose, GetType());
}
}
catch (Exception ex)
{
SensusServiceHelper.Get().Logger.Log("GPS reading failed: " + ex.Message, LoggingLevel.Normal, GetType());
_reading = null;
}
_readingWait.Set(); // tell anyone waiting on the shared reading that it is ready
_readingIsComing = false; // direct any future calls to this method to get their own reading
});
}
}
_readingWait.WaitOne(_readingTimeoutMS);
if (_reading == null)
{
SensusServiceHelper.Get().Logger.Log("GPS reading is null.", LoggingLevel.Normal, GetType());
}
return(_reading);
}
private async void GetLocation()
{
position = await locator.GetPositionAsync();
if (!locator.IsListening)
{
await locator.StartListeningAsync(TimeSpan.FromMinutes(30), 500);
}
}
public async Task <Position> GetGeoLocation()
{
IGeolocator locator = CrossGeolocator.Current;
locator.DesiredAccuracy = 100;
Position position = await locator.GetPositionAsync(TimeSpan.FromSeconds(10));
return(position);
}
public async Task <Position> GetLocation(TimeSpan minimumTime, int minimumMeters)
{
position = await locator.GetPositionAsync(); // get current position
if (!locator.IsListening)
{
await locator.StartListeningAsync(minimumTime, minimumMeters);
}
return(position);
}
async public Task <Tuple <double, double> > GetCurrentLocationCodinateAsync()
{
var currentPosition = await _geolocator.GetPositionAsync(10000);
var latitude = currentPosition.Latitude;
var longitude = currentPosition.Longitude;
Tuple <double, double> result = new Tuple <double, double>(latitude, longitude);
return(result);
}
private async void GetMyLocation()
{
IGeolocator geoLocator = CrossGeolocator.Current;
geoLocator.DesiredAccuracy = 50;
Position position = await geoLocator.GetPositionAsync(timeout : TimeSpan.FromSeconds(20));
lblLatitude.Text = position.Latitude.ToString("0:0.0000000");
lblLongitude.Text = position.Longitude.ToString("0:0.0000000");
}
public AddGeofenceViewModel(IGeofenceManager geofences,
IUserDialogs dialogs,
IViewModelManager viewModelMgr,
IGeolocator geolocator)
{
this.Add = ReactiveCommand.CreateAsyncTask(
this.WhenAny(
x => x.RadiusMeters,
x => x.Latitude,
x => x.Longitude,
x => x.Identifer,
(radius, lat, lng, id) =>
{
if (radius.Value < 100)
return false;
if (lat.Value < -90 || lat.Value > 90)
return false;
if (lng.Value < -180 || lng.Value > 180)
return false;
if (id.Value.IsEmpty())
return false;
return true;
}
),
async x =>
{
geofences.StartMonitoring(new GeofenceRegion
{
Identifier = this.Identifer,
Center = new Position(this.Latitude, this.Longitude),
Radius = Distance.FromMeters(this.RadiusMeters)
});
await viewModelMgr.PopNav();
}
);
this.UseCurrentLocation = ReactiveCommand.CreateAsyncTask(async x =>
{
try
{
var current = await geolocator.GetPositionAsync(5000);
this.Latitude = current.Latitude;
this.Longitude = current.Longitude;
}
catch
{
}
});
}
public async void Geolocate(IGeolocator locator)
{
try
{
var position = await locator.GetPositionAsync (10000);
((App)App.Current).Latitude = position.Latitude;
((App)App.Current).Longitude = position.Longitude;
System.Diagnostics.Debug.WriteLine("I've got coordinates!");
if(position.Latitude == 0 && position.Longitude == 0)
((App)App.Current).LogError("GetPosition", "Координаты успешно получены, но нулевые!", "", new {});
Navigate();
}
catch(GeolocationException e1)
{
if (e1.Error == GeolocationError.PositionUnavailable)
{
UseGeoError (e1);
Navigate();
}
else
{
App.IOSAppDelegate.Confirm ("Определение погоды", "Для определения точных погодных условий включите, пожалуйста, службу геолокации в настройках. Если Вы пропустите этот шаг, то местоположение будет задано по умолчанию (СПБ). Если Вы уже включили геолокацию, нажмите \"Повторить\".",
async (int n) => {
if(n == 0)
{
UseGeoError (e1, false);
Navigate();
}
else
{
Geolocate(locator);
}
}, "Пропустить", "Повторить");
}
}
catch(Exception e2)
{
UseGeoError (e2);
Navigate();
}
}
async Task GetPosition ()
{
// Inicia o Acelelometro
var device = Resolver.Resolve<IDevice>();
Debug.WriteLine (device.FirmwareVersion);
this.geolocator = DependencyService.Get<IGeolocator> ();
//geolocator.PositionError += OnPositionError;
//geolocator.PositionChanged += OnPositionChanged;
if (!geolocator.IsListening)
geolocator.StartListening(minTime: 1000, minDistance: 0);
var position = await geolocator.GetPositionAsync (timeout: 10000);
string message = string.Format ("Latitude: {0} | Longitude: {1}", position.Latitude, position.Longitude);
Debug.WriteLine (message);
device.Accelerometer.ReadingAvailable += getEixos;
}