public PeerCastStationSettings()
{
Logger = new LoggerSettings();
Listeners = new ListenerSettings[0];
AccessController = new AccessControllerSettings();
YellowPages = new YellowPageSettings[0];
}
} //time you have wait for location variable
public static async Task <bool> StartListeningAsync(GLFlag flag, int StartDelay = 1000, double minimumTime = 6.0, bool includeHeading = false, ListenerSettings listenerSettings = null)
{
flag.Flag = true;
Task <bool> startAnswer;
if (AppGeolocator.Current.IsListening)
{
startAnswer = Task.FromResult(true);
}
else
{
startAnswer = Current.StartListeningAsync(TimeSpan.FromSeconds(minimumTime), 0, includeHeading, listenerSettings);//work if true
MinimumListTime = minimumTime;
await Task.Delay(StartDelay);
}
return(await startAnswer);
}
/// <summary>
/// Start listening for changes
/// </summary>
/// <param name="minimumTime">Time</param>
/// <param name="minimumDistance">Distance</param>
/// <param name="includeHeading">Include heading or not</param>
/// <param name="listenerSettings">Optional settings (iOS only)</param>
public async Task <bool> StartListeningAsync(TimeSpan minimumTime, double minimumDistance, bool includeHeading = false, ListenerSettings listenerSettings = null)
{
if (minimumDistance < 0)
{
throw new ArgumentOutOfRangeException(nameof(minimumDistance));
}
if (isListening)
{
throw new InvalidOperationException("Already listening");
}
// if no settings were passed in, instantiate the default settings. need to check this and create default settings since
// previous calls to StartListeningAsync might have already configured the location manager in a non-default way that the
// caller of this method might not be expecting. the caller should expect the defaults if they pass no settings.
if (listenerSettings == null)
{
listenerSettings = new ListenerSettings();
}
#if __IOS__
var hasPermission = false;
if (UIDevice.CurrentDevice.CheckSystemVersion(9, 0))
{
if (listenerSettings.AllowBackgroundUpdates)
{
hasPermission = await CheckAlwaysPermissions();
}
else
{
hasPermission = await CheckWhenInUsePermission();
}
}
if (!hasPermission)
{
throw new GeolocationException(GeolocationError.Unauthorized);
}
#endif
#if __IOS__ || __MACOS__
this.includeHeading = includeHeading;
#endif
// keep reference to settings so that we can stop the listener appropriately later
this.listenerSettings = listenerSettings;
var desiredAccuracy = DesiredAccuracy;
// set background flag
#if __IOS__
if (UIDevice.CurrentDevice.CheckSystemVersion(9, 0))
{
manager.AllowsBackgroundLocationUpdates = listenerSettings.AllowBackgroundUpdates;
}
// configure location update pausing
if (UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
{
manager.PausesLocationUpdatesAutomatically = listenerSettings.PauseLocationUpdatesAutomatically;
switch (listenerSettings.ActivityType)
{
case ActivityType.AutomotiveNavigation:
manager.ActivityType = CLActivityType.AutomotiveNavigation;
break;
case ActivityType.Fitness:
manager.ActivityType = CLActivityType.Fitness;
break;
case ActivityType.OtherNavigation:
manager.ActivityType = CLActivityType.OtherNavigation;
break;
default:
manager.ActivityType = CLActivityType.Other;
break;
}
}
#endif
// to use deferral, CLLocationManager.DistanceFilter must be set to CLLocationDistance.None, and CLLocationManager.DesiredAccuracy must be
// either CLLocation.AccuracyBest or CLLocation.AccuracyBestForNavigation. deferral only available on iOS 6.0 and above.
if (CanDeferLocationUpdate && listenerSettings.DeferLocationUpdates)
{
minimumDistance = CLLocationDistance.FilterNone;
desiredAccuracy = CLLocation.AccuracyBest;
}
isListening = true;
manager.DesiredAccuracy = desiredAccuracy;
manager.DistanceFilter = minimumDistance;
#if __IOS__ || __MACOS__
if (listenerSettings.ListenForSignificantChanges)
{
manager.StartMonitoringSignificantLocationChanges();
}
else
{
manager.StartUpdatingLocation();
}
#elif __TVOS__
//not supported
#endif
return(true);
}
/// <summary>
/// Start listening for changes
/// </summary>
/// <param name="minimumTime">Time</param>
/// <param name="minimumDistance">Distance</param>
/// <param name="includeHeading">Include heading or not</param>
/// <param name="listenerSettings">Optional settings (iOS only)</param>
public Task <bool> StartListeningAsync(TimeSpan minTime, double minDistance, bool includeHeading = false, ListenerSettings settings = null)
{
if (minDistance < 0)
{
throw new ArgumentOutOfRangeException("minDistance");
}
if (IsListening)
{
throw new InvalidOperationException("This Geolocator is already listening");
}
watcher = new GeoCoordinateWatcher(DesiredAccuracy.ToAccuracy());
watcher.MovementThreshold = minDistance;
watcher.PositionChanged += WatcherOnPositionChanged;
watcher.StatusChanged += WatcherOnStatusChanged;
watcher.Start();
return(Task.FromResult(true));
}
/// <summary>
/// Start listening for changes
/// </summary>
/// <param name="minimumTime">Time</param>
/// <param name="minimumDistance">Distance</param>
/// <param name="includeHeading">Include heading or not</param>
/// <param name="listenerSettings">Optional settings (iOS only)</param>
public async Task <bool> StartListeningAsync(TimeSpan minimumTime, double minimumDistance, bool includeHeading = false, ListenerSettings listenerSettings = null)
{
var hasPermission = await CheckPermissions();
if (!hasPermission)
{
throw new GeolocationException(GeolocationError.Unauthorized);
}
var minTimeMilliseconds = minimumTime.TotalMilliseconds;
if (minTimeMilliseconds < 0)
{
throw new ArgumentOutOfRangeException(nameof(minimumTime));
}
if (minimumDistance < 0)
{
throw new ArgumentOutOfRangeException(nameof(minimumDistance));
}
if (IsListening)
{
throw new InvalidOperationException("This Geolocator is already listening");
}
var providers = Providers;
listener = new GeolocationContinuousListener(Manager, minimumTime, providers);
listener.PositionChanged += OnListenerPositionChanged;
listener.PositionError += OnListenerPositionError;
var looper = Looper.MyLooper() ?? Looper.MainLooper;
listeningProviders.Clear();
for (var i = 0; i < providers.Length; ++i)
{
var provider = providers[i];
//we have limited set of providers
if (ProvidersToUseWhileListening != null &&
ProvidersToUseWhileListening.Length > 0)
{
//the provider is not in the list, so don't use it.
if (!ProvidersToUseWhileListening.Contains(provider))
{
continue;
}
}
listeningProviders.Add(provider);
Manager.RequestLocationUpdates(provider, (long)minTimeMilliseconds, (float)minimumDistance, listener, looper);
}
return(true);
}
/// <inheritdoc/>
public async Task <bool> StartListeningAsync(TimeSpan minTime, double minDistance, bool includeHeading = false, ListenerSettings settings = null)
{
var hasPermission = await CheckPermissions();
if (!hasPermission)
{
return(false);
}
var minTimeMilliseconds = minTime.TotalMilliseconds;
if (minTimeMilliseconds < 0)
{
throw new ArgumentOutOfRangeException("minTime");
}
if (minDistance < 0)
{
throw new ArgumentOutOfRangeException("minDistance");
}
if (IsListening)
{
throw new InvalidOperationException("This Geolocator is already listening");
}
var providers = Providers;
listener = new GeolocationContinuousListener(Manager, minTime, providers);
listener.PositionChanged += OnListenerPositionChanged;
listener.PositionError += OnListenerPositionError;
Looper looper = Looper.MyLooper() ?? Looper.MainLooper;
for (int i = 0; i < providers.Length; ++i)
{
Manager.RequestLocationUpdates(providers[i], (long)minTimeMilliseconds, (float)minDistance, listener, looper);
}
return(true);
}
/// <inheritdoc/>
public async Task <bool> StartListeningAsync(int minTime, double minDistance, bool includeHeading = false, ListenerSettings settings = null)
{
var status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permissions.Abstractions.Permission.Location).ConfigureAwait(false);
if (status != Permissions.Abstractions.PermissionStatus.Granted)
{
Console.WriteLine("Currently does not have Location permissions, requesting permissions");
var request = await CrossPermissions.Current.RequestPermissionsAsync(Permissions.Abstractions.Permission.Location);
if (request[Permissions.Abstractions.Permission.Location] != Permissions.Abstractions.PermissionStatus.Granted)
{
Console.WriteLine("Location permission denied, can not get positions async.");
return(false);
}
providers = manager.GetProviders(enabledOnly: false).Where(s => s != LocationManager.PassiveProvider).ToArray();
}
if (providers.Length == 0)
{
providers = manager.GetProviders(enabledOnly: false).Where(s => s != LocationManager.PassiveProvider).ToArray();
}
if (minTime < 0)
{
throw new ArgumentOutOfRangeException("minTime");
}
if (minDistance < 0)
{
throw new ArgumentOutOfRangeException("minDistance");
}
if (IsListening)
{
throw new InvalidOperationException("This Geolocator is already listening");
}
listener = new GeolocationContinuousListener(manager, TimeSpan.FromMilliseconds(minTime), providers);
listener.PositionChanged += OnListenerPositionChanged;
listener.PositionError += OnListenerPositionError;
Looper looper = Looper.MyLooper() ?? Looper.MainLooper;
for (int i = 0; i < providers.Length; ++i)
{
manager.RequestLocationUpdates(providers[i], minTime, (float)minDistance, listener, looper);
}
return(true);
}
/// <summary>
/// Start listening for changes
/// </summary>
/// <param name="minimumTime">Time</param>
/// <param name="minimumDistance">Distance</param>
/// <param name="includeHeading">Include heading or not</param>
/// <param name="listenerSettings">Optional settings (iOS only)</param>
public Task <bool> StartListeningAsync(TimeSpan minimumTime, double minimumDistance, bool includeHeading = false, ListenerSettings listenerSettings = null)
{
if (minimumTime.TotalMilliseconds <= 0 && minimumDistance <= 0)
{
throw new ArgumentException("You must specify either a minimumTime or minimumDistance, setting a minimumDistance will always take precedence over minTime");
}
if (minimumTime.TotalMilliseconds < 0)
{
throw new ArgumentOutOfRangeException(nameof(minimumTime));
}
if (minimumDistance < 0)
{
throw new ArgumentOutOfRangeException(nameof(minimumDistance));
}
if (isListening)
{
throw new InvalidOperationException();
}
isListening = true;
var loc = GetGeolocator();
loc.ReportInterval = (uint)minimumTime.TotalMilliseconds;
loc.MovementThreshold = minimumDistance;
loc.PositionChanged += OnLocatorPositionChanged;
loc.StatusChanged += OnLocatorStatusChanged;
return(Task.FromResult(true));
}
public virtual Listener CreateListener(Proxy owner, ListenerSettings settings)
{
return(new Listener(owner, settings));
}
/// <summary>
/// Start listening for changes
/// </summary>
/// <param name="minimumTime">Time</param>
/// <param name="minimumDistance">Distance</param>
/// <param name="includeHeading">Include heading or not</param>
/// <param name="listenerSettings">Optional settings (iOS only)</param>
public Task <bool> StartListeningAsync(TimeSpan minTime, double minDistance, bool includeHeading = false, ListenerSettings settings = null)
{
if (minTime.TotalMilliseconds < 0)
{
throw new ArgumentOutOfRangeException("minTime");
}
if (minDistance < 0)
{
throw new ArgumentOutOfRangeException("minDistance");
}
if (isListening)
{
throw new InvalidOperationException();
}
isListening = true;
var loc = GetGeolocator();
loc.ReportInterval = (uint)minTime.TotalMilliseconds;
loc.MovementThreshold = minDistance;
loc.PositionChanged += OnLocatorPositionChanged;
loc.StatusChanged += OnLocatorStatusChanged;
return(Task.FromResult(true));
}
/// <inheritdoc/>
public Task <bool> StartListeningAsync(int minTime, double minDistance, bool includeHeading = false, ListenerSettings settings = null)
{
if (minTime < 0)
{
throw new ArgumentOutOfRangeException("minTime");
}
if (minDistance < 0)
{
throw new ArgumentOutOfRangeException("minDistance");
}
if (isListening)
{
throw new InvalidOperationException("Already listening");
}
// if no settings were passed in, instantiate the default settings. need to check this and create default settings since
// previous calls to StartListeningAsync might have already configured the location manager in a non-default way that the
// caller of this method might not be expecting. the caller should expect the defaults if they pass no settings.
if (settings == null)
{
settings = new ListenerSettings();
}
// keep reference to settings so that we can stop the listener appropriately later
listenerSettings = settings;
double desiredAccuracy = DesiredAccuracy;
#region apply settings to location manager
// set background flag
if (UIDevice.CurrentDevice.CheckSystemVersion(9, 0))
{
manager.AllowsBackgroundLocationUpdates = settings.AllowBackgroundUpdates;
}
// configure location update pausing
if (UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
{
manager.PausesLocationUpdatesAutomatically = settings.PauseLocationUpdatesAutomatically;
if (settings.ActivityType == ActivityType.AutomotiveNavigation)
{
manager.ActivityType = CLActivityType.AutomotiveNavigation;
}
else if (settings.ActivityType == ActivityType.Fitness)
{
manager.ActivityType = CLActivityType.Fitness;
}
else if (settings.ActivityType == ActivityType.Other)
{
manager.ActivityType = CLActivityType.Other;
}
else if (settings.ActivityType == ActivityType.OtherNavigation)
{
manager.ActivityType = CLActivityType.OtherNavigation;
}
}
// to use deferral, CLLocationManager.DistanceFilter must be set to CLLocationDistance.None, and CLLocationManager.DesiredAccuracy must be
// either CLLocation.AccuracyBest or CLLocation.AccuracyBestForNavigation. deferral only available on iOS 6.0 and above.
if (CanDeferLocationUpdate && settings.DeferLocationUpdates)
{
minDistance = CLLocationDistance.FilterNone;
desiredAccuracy = CLLocation.AccuracyBest;
}
#endregion
isListening = true;
manager.DesiredAccuracy = desiredAccuracy;
manager.DistanceFilter = minDistance;
if (settings?.ListenForSignificantChanges ?? false)
{
manager.StartMonitoringSignificantLocationChanges();
}
else
{
manager.StartUpdatingLocation();
}
if (includeHeading && CLLocationManager.HeadingAvailable)
{
manager.StartUpdatingHeading();
}
return(Task.FromResult(true));
}
public async Task <bool> StartListeningAsync(TimeSpan minTime, double minDistance, bool includeHeading = false, ListenerSettings listenerSettings = null)
{
if (!client.IsConnected)
{
await ConnectAsync();
}
if (!client.IsConnected)
{
return(await Task.FromResult(false));
}
var minTimeMilliseconds = (long)minTime.TotalMilliseconds;
var locationRequest = new LocationRequest();
locationRequest.SetSmallestDisplacement(Convert.ToInt64(minDistance))
.SetFastestInterval(minTimeMilliseconds)
.SetInterval(minTimeMilliseconds)
.SetMaxWaitTime(minTimeMilliseconds * 6)
.SetPriority(GetPriority());
var result = await LocationServices.FusedLocationApi
.RequestLocationUpdatesAsync(client, locationRequest, callbacks);
if (result.IsSuccess)
{
IsListening = true;
}
return(result.IsSuccess);
}