/// <summary>
/// constructor
/// </summary>
public GpsLocationService(string id, IotNode parent, GeolocationAccuracy accuracy, TimeSpan timeout) : base(id, parent) // , accuracy, timeout
{
Location = new LocationData {
Id = nameof(Location)
};
_request = new GeolocationRequest(accuracy, timeout);
}
public async Task <Position> GetPositionAsync(TimeSpan?timeout = null, CancellationToken?token = null)
{
try
{
GeolocationAccuracy accuracy = this.GetAccuracy();
var request = timeout.HasValue ? new GeolocationRequest(accuracy, timeout.Value) : new GeolocationRequest(accuracy);
var location = await Geolocation.GetLocationAsync(request);
if (location != null)
{
Console.WriteLine($"Latitude: {location.Latitude}, Longitude: {location.Longitude}");
return(new Position(location.Latitude, location.Longitude));
}
return(null);
}
catch (FeatureNotSupportedException fnsEx)
{
// Handle not supported on device exception
}
catch (PermissionException pEx)
{
// Handle permission exception
}
catch (Exception ex)
{
// Unable to get location
}
return(null);
}
public async Task SHOULD_use_given_accuracy(LocationAccuracy given, GeolocationAccuracy required)
{
//Arrange
MockProxy.Where_GetCurrentLocationAsync_returns(new Location(22, 66, DateTimeOffset.Now));
//Act
Sut.Connect(new GeolocationRequirements(TimeSpan.FromTicks(1), given))
.Subscribe(next => { LocationTaskCompletionSource.SetResult(new List <IGpsLocation> {
next
}); });
await LocationTaskCompletionSource.Task;
//Assert
MockProxy.Mock.Verify(x => x.GetCurrentLocationAsync(It.Is <GeolocationRequest>(y => y.DesiredAccuracy == required)));
}
/// <summary>
/// Queries the current location of the device
/// </summary>
/// <returns>A point object containing the device's current location</returns>
public static async Task <Position> GetGeoLocation()
{
GeolocationAccuracy geolocationAccuracy = Preferences.Get(Constants.GPSPrecisionKey, Constants.DefaultGPSPrecisionValue) switch
{
0 => GeolocationAccuracy.Best,
1 => GeolocationAccuracy.High,
3 => GeolocationAccuracy.Low,
_ => GeolocationAccuracy.Medium,
};
Location location = await Geolocation.GetLocationAsync(new GeolocationRequest(geolocationAccuracy));
if (location != null)
{
int decimalAccuracy = Preferences.Get(Constants.DecimalAccuracyKey, Constants.DefaultDecimalAccuracyValue);
return(new Position(Math.Round(location.Longitude, decimalAccuracy), Math.Round(location.Latitude, decimalAccuracy), Math.Round(location.Altitude ?? 0.0, decimalAccuracy)));
}
throw new ArgumentNullException(nameof(location), "Fetched location was empty");
}
public static async Task <Location> GetLastLocationAsync(GeolocationAccuracy geolocationAccuracy = GeolocationAccuracy.Medium, TimeSpan?timeOutParameter = null)
{
var location = new Location();
var timeOut = timeOutParameter ?? new TimeSpan(0, 0, 15);
await PermissionService.RequirePermissionToExecute(async() =>
{
var request = new GeolocationRequest(geolocationAccuracy, timeOut);
location =
await Geolocation.GetLocationAsync(request) ??
await Geolocation.GetLastKnownLocationAsync();
}, new Permissions.LocationWhenInUse());
return(location);
}
static string GetBestProvider(LocationManager locationManager, GeolocationAccuracy accuracy)
{
var criteria = new Criteria();
criteria.BearingRequired = false;
criteria.AltitudeRequired = false;
criteria.SpeedRequired = false;
switch (accuracy)
{
case GeolocationAccuracy.Lowest:
criteria.Accuracy = Accuracy.NoRequirement;
criteria.HorizontalAccuracy = Accuracy.NoRequirement;
criteria.PowerRequirement = Power.NoRequirement;
break;
case GeolocationAccuracy.Low:
criteria.Accuracy = Accuracy.Low;
criteria.HorizontalAccuracy = Accuracy.Low;
criteria.PowerRequirement = Power.Low;
break;
case GeolocationAccuracy.Medium:
criteria.Accuracy = Accuracy.Medium;
criteria.HorizontalAccuracy = Accuracy.Medium;
criteria.PowerRequirement = Power.Medium;
break;
case GeolocationAccuracy.High:
criteria.Accuracy = Accuracy.High;
criteria.HorizontalAccuracy = Accuracy.High;
criteria.PowerRequirement = Power.High;
break;
case GeolocationAccuracy.Best:
criteria.Accuracy = Accuracy.Fine;
criteria.HorizontalAccuracy = Accuracy.Fine;
criteria.PowerRequirement = Power.High;
break;
}
return(locationManager.GetBestProvider(criteria, true) ?? locationManager.GetProviders(true).FirstOrDefault());
}
/// <summary>
/// Возвращает текущие координаты местоположения.
/// </summary>
/// <returns>Текущие координаты.</returns>
public static async Task <Location> GetCurrentGeolocationAsync(GeolocationAccuracy accuracy)
{
Xamarin.Essentials.Location location = null;
try
{
var request = new GeolocationRequest(GeolocationAccuracy.Medium, TimeSpan.FromSeconds(10));
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken cancelToken = source.Token;
location = await Geolocation.GetLocationAsync(request, cancelToken);
}
catch (FeatureNotSupportedException fnsEx)
{
// Handle not supported on device exception
Debug.WriteLine("-------------------------------------------------");
Debug.WriteLine(fnsEx);
Debug.WriteLine("-------------------------------------------------");
}
catch (PermissionException pEx)
{
// Handle permission exception
Debug.WriteLine("-------------------------------------------------");
Debug.WriteLine(pEx);
Debug.WriteLine("-------------------------------------------------");
}
catch (Exception ex)
{
// Unable to get location
Debug.WriteLine("-------------------------------------------------");
Debug.WriteLine(ex);
Debug.WriteLine("-------------------------------------------------");
}
if (location == null)
{
return(await Task.FromResult(_currentGeolocation));
}
_currentGeolocation = new Location(location.Latitude, location.Longitude);
return(await Task.FromResult(_currentGeolocation));
}
public async static Task <Location> GetLocationAsync(GeolocationAccuracy desiredAccuracy)
{
Location loc;
var permission = await CheckAndRequestLocationPermission();
if (permission == PermissionStatus.Granted)
{
try
{
var request = new GeolocationRequest(desiredAccuracy);
loc = await Geolocation.GetLocationAsync(request);
}
catch (FeatureNotSupportedException fnsEx)
{
// Handle not supported on device exception
loc = null;
}
catch (FeatureNotEnabledException fneEx)
{
// Handle not enabled on device exception
loc = null;
}
catch (PermissionException pEx)
{
// Handle permission exception
loc = null;
}
catch (Exception ex)
{
loc = null;
}
}
else
{
loc = null;
}
return(loc);
}
protected async Task <State> GetLocationAsync(GeolocationAccuracy accuracy = GeolocationAccuracy.Default)
{
Reset();
var request = new GeolocationRequest(accuracy);
Location = await Geolocation.GetLocationAsync(request).ConfigureAwait(false);
if (Location is null)
{
return(State.UnknownError);
}
Status = Location.IsFromMockProvider
? State.IsFromMockProvider
: State.Success;
// try
// {
// }
// catch ( FeatureNotSupportedException ) // Handle not supported on device exception
// {
// Status = StatusState.FeatureNotSupported;
// }
// catch ( FeatureNotEnabledException ) // Handle not enabled on device exception
// {
// Status = StatusState.FeatureNotEnabled;
// }
// catch ( PermissionException ) // Handle permission exception
// {
// Status = StatusState.PermissionIssue;
// }
// catch ( Exception ) // Unable to get location
// {
// Status = StatusState.UnknownError;
// }
return(Status);
}
public Task <Location> GetDeviceLocationAsync(GeolocationAccuracy accuracy, TimeSpan timeout, CancellationTokenSource cancellationTokenSource) =>
Task.Run(async() => {
Location result = null;
try {
GeolocationRequest request = new GeolocationRequest(accuracy);
request.Timeout = timeout;
result = await Geolocation.GetLocationAsync(request, cancellationTokenSource.Token);
} catch (FeatureNotSupportedException fnsEx) {
// TODO: Handle not supported on device exception
Debug.WriteLine($"ERROR: {fnsEx.Message}");
Debugger.Break();
} catch (PermissionException pEx) {
// TODO: Handle permission exception
Debug.WriteLine($"ERROR: {pEx.Message}");
Debugger.Break();
} catch (Exception ex) {
// TODO: Unable to get location
Debug.WriteLine($"ERROR: {ex.Message}");
Debugger.Break();
}
return(result);
}, cancellationTokenSource.Token);
static (string Provider, float Accuracy) GetBestProvider(LocationManager locationManager, GeolocationAccuracy accuracy)
{
// Criteria: https://developer.android.com/reference/android/location/Criteria
var criteria = new Criteria
{
BearingRequired = false,
AltitudeRequired = false,
SpeedRequired = false
};
var accuracyDistance = 100;
switch (accuracy)
{
case GeolocationAccuracy.Lowest:
criteria.Accuracy = Accuracy.NoRequirement;
criteria.HorizontalAccuracy = Accuracy.NoRequirement;
criteria.PowerRequirement = LocationPower.NoRequirement;
accuracyDistance = 500;
break;
case GeolocationAccuracy.Low:
criteria.Accuracy = Accuracy.Coarse;
criteria.HorizontalAccuracy = Accuracy.Low;
criteria.PowerRequirement = LocationPower.Low;
accuracyDistance = 500;
break;
case GeolocationAccuracy.Default:
case GeolocationAccuracy.Medium:
criteria.Accuracy = Accuracy.Coarse;
criteria.HorizontalAccuracy = Accuracy.Medium;
criteria.PowerRequirement = LocationPower.Medium;
accuracyDistance = 250;
break;
case GeolocationAccuracy.High:
criteria.Accuracy = Accuracy.Fine;
criteria.HorizontalAccuracy = Accuracy.High;
criteria.PowerRequirement = LocationPower.High;
accuracyDistance = 100;
break;
case GeolocationAccuracy.Best:
criteria.Accuracy = Accuracy.Fine;
criteria.HorizontalAccuracy = Accuracy.High;
criteria.PowerRequirement = LocationPower.High;
accuracyDistance = 50;
break;
}
var provider = locationManager.GetBestProvider(criteria, true) ?? locationManager.GetProviders(true).FirstOrDefault();
return(provider, accuracyDistance);
}
/// <include file="../../docs/Microsoft.Maui.Essentials/GeolocationRequest.xml" path="//Member[@MemberName='.ctor'][3]/Docs" />
public GeolocationRequest(GeolocationAccuracy accuracy, TimeSpan timeout)
{
Timeout = timeout;
DesiredAccuracy = accuracy;
}
/// <include file="../../docs/Microsoft.Maui.Essentials/GeolocationRequest.xml" path="//Member[@MemberName='.ctor'][2]/Docs" />
public GeolocationRequest(GeolocationAccuracy accuracy)
{
Timeout = TimeSpan.Zero;
DesiredAccuracy = accuracy;
}
public NewTimeClockPageCS()
{
Title = "TimeClock Item";
BackgroundColor = Color.Black;
//TimeClockItem codeItem = (TimeClockItem)BindingContext;
Editor notesEntry = new Editor();
notesEntry.SetBinding(Editor.TextProperty, "Notes");
notesEntry.BackgroundColor = Color.FromHex("#292929");
notesEntry.TextColor = Color.FromHex("#32cd32");
notesEntry.HeightRequest = 300;
Button saveButton = new Button {
Text = "Create", Margin = new Thickness(0, 50, 0, 0), BackgroundColor = Color.FromHex("#00FFFF"), TextColor = Color.FromHex("#000033")
};
saveButton.Clicked += async(sender, e) =>
{
TimeClockItem timeClock = (TimeClockItem)BindingContext;
timeClock.TimePunch = DateTime.Now;
TimeClockItem lastItem = App.Database.GetLastTimeClockItemAsync().Result;
if (lastItem != null)
{
timeClock.IsClockIn = lastItem.IsClockIn == false;
timeClock.IsClockOut = lastItem.IsClockIn == true;
}
else
{
timeClock.IsClockIn = true;
timeClock.IsClockOut = false;
}
Location location = await Geolocation.GetLastKnownLocationAsync();
timeClock.IsMock = false;
if (location != null)
{
if (location.Accuracy.HasValue)
{
double value = location.Accuracy.Value;
GeolocationAccuracy enumDisplayStatus = (GeolocationAccuracy)value;
string stringValue = enumDisplayStatus.ToString();
timeClock.gpsDetail = stringValue;
}
timeClock.gpsLatitude = location.Latitude.ToString();
timeClock.gpsLongitude = location.Longitude.ToString();
timeClock.gpsLastTimestamp = location.Timestamp;
if (location.IsFromMockProvider)
{
// location is from a mock provider
timeClock.IsMock = true;
}
//Location msLocation = new Location(47.645160, -122.1306032);
//double miles = Location.CalculateDistance(msLocation, location, DistanceUnits.Miles);
}
await App.Database.SaveItemAsync(timeClock);
await Navigation.PopAsync();
};
Button cancelButton = new Button {
Text = "Cancel", BackgroundColor = Color.FromHex("#FF0000"), TextColor = Color.White, Margin = new Thickness(0, 20, 0, 0)
};
cancelButton.Clicked += async(sender, e) =>
{
await Navigation.PopAsync();
};
Content = new StackLayout
{
Margin = new Thickness(20),
VerticalOptions = LayoutOptions.StartAndExpand,
Children =
{
new Label {
Text = "Notes", TextColor = Color.White
},
notesEntry,
saveButton,
cancelButton
}
};
}
