public static async Task GetPosition(PositionAccuracy accuracy, int timeout)
{
if (App.Settings.LocationServiceEnabled)
{
var geolocater = new Geolocator { DesiredAccuracy = accuracy };
try
{
var geoposition =
await geolocater.GetGeopositionAsync(TimeSpan.FromMinutes(2), TimeSpan.FromSeconds(timeout)
);
App.ViewModel.CurrentPosition = new Position
{
Latitude = geoposition.Coordinate.Latitude,
Longitude = geoposition.Coordinate.Longitude,
Accuracy = geoposition.Coordinate.Accuracy,
Timestamp = geoposition.Coordinate.Timestamp.DateTime
};
}
catch (TimeoutException ex)
{
BugSenseHandler.Instance.LogException(ex);
}
catch (Exception ex)
{
MessageBox.Show(AppResources.ErrorLocationTitle, AppResources.ErrorTitle, MessageBoxButton.OK);
}
}
}
public static async Task <Geoposition> GetGeoposition(PositionAccuracy acc, TimeSpan timeout)
{
var loc = new Geolocator();
loc.DesiredAccuracy = acc;
var result = (await loc.GetGeopositionAsync(TimeSpan.FromSeconds(30), timeout));
SettingsManager.SetSetting <double[]>("LastLocation", true, new double[] { result.Coordinate.Point.Position.Latitude, result.Coordinate.Point.Position.Longitude });
return(result);
}
public static async Task <BasicGeoposition?> GetCurrentLocation(PositionAccuracy acc)
{
var loc = new Geolocator();
try
{
loc.DesiredAccuracy = acc;
var result = (await loc.GetGeopositionAsync()).Coordinate.Point.Position;
SettingsManager.SetSetting <double[]>("LastLocation", true, new double[] { result.Latitude, result.Longitude });
return(result);
}
catch (Exception) { }
return(null);
}
public static LocationServiceAccuracy ToLocationServiceAccuracy(this PositionAccuracy positionAccuracy)
{
switch (positionAccuracy)
{
case PositionAccuracy.Default:
return(LocationServiceAccuracy.Default);
case PositionAccuracy.High:
return(LocationServiceAccuracy.High);
default:
throw new ArgumentOutOfRangeException(nameof(positionAccuracy), positionAccuracy, null);
}
}
/// <summary>
/// Get the current position from OS.
/// </summary>
public async Task GetCurrentLocation(PositionAccuracy accuracy = PositionAccuracy.High)
{
FSLog.Debug();
var locator = new Geolocator();
locator.DesiredAccuracy = accuracy;
if (accuracy == PositionAccuracy.High)
{
locator.DesiredAccuracyInMeters = 10;
locator.MovementThreshold = 10;
locator.ReportInterval = 5000;
}
else
{
// Get inaccurate rough position( something else than Africa )
locator.DesiredAccuracyInMeters = 2000;
locator.MovementThreshold = 1000;
locator.ReportInterval = 1;
}
try
{
Geoposition geoposition = await locator.GetGeopositionAsync(
maximumAge : TimeSpan.FromMinutes(60),
timeout : TimeSpan.FromSeconds(30)
);
if (geoposition != null)
{
OnNewPosition(geoposition, isForced: true);
}
else
{
FSLog.Warning("Failed to get position");
}
}
catch (Exception ex)
{
if ((uint)ex.HResult == 0x80004004)
{
FSLog.Warning("User has disabled location services or power save");
}
//else
{
FSLog.Exception(ex);
// something else happened acquring the location
}
}
}
public async Task <Geoposition> GetUserLocation(PositionAccuracy accuracy)
{
// Get cancellation token
_cts = new CancellationTokenSource();
CancellationToken token = _cts.Token;
// Carry out the operation
// geolocator and location permissions are initialized and checked on page creation.
var geolocator = new Geolocator();
// Request a high accuracy position for better accuracy locating the geofence
geolocator.DesiredAccuracy = accuracy;
return(await geolocator.GetGeopositionAsync().AsTask(token));
}
public async Task <GeoAddress> GetCurrentLocation(PositionAccuracy accuracy = PositionAccuracy.Default)
{
if (locator.LocationStatus == PositionStatus.Disabled || locator.LocationStatus == PositionStatus.NotAvailable)
{
return(null);
}
locator.DesiredAccuracy = accuracy;
var location = await locator.GetGeopositionAsync();
return(new GeoAddress()
{
Latitude = location?.Coordinate?.Point?.Position.Latitude,
Longitude = location?.Coordinate?.Point?.Position.Longitude,
Country = location?.CivicAddress?.Country,
Locality = location?.CivicAddress?.City
});
}
public static Core.Geolocation.PositionAccuracy AsTrackTimerModel(this PositionAccuracy accuracy)
{
return((Core.Geolocation.PositionAccuracy)(int) accuracy);
}
public static async Task<BasicGeoposition?> GetCurrentLocation(PositionAccuracy acc)
{
var loc = new Geolocator();
try
{
loc.DesiredAccuracy = acc;
var result = (await loc.GetGeopositionAsync()).Coordinate.Point.Position;
SettingsManager.SetSetting<double[]>("LastLocation", true, new double[] { result.Latitude, result.Longitude });
return result;
}
catch (Exception) { }
return null;
}
public static async Task <LatLon?> GetCurrentLocation(PositionAccuracy acc, TimeSpan timeout)
{
return((await GetGeoposition(acc, timeout)).Coordinate.Point.ToLatLon());
}
