public MainViewModel(IDialogs dialogs, IVpnManager?vpnManager = null)
{
this.vpnManager = vpnManager;
this.ToggleConnection = ReactiveCommand.CreateFromTask(async() =>
{
if (this.vpnManager == null)
{
await dialogs.Alert("VPN Management is not supported on this platform");
return;
}
if (this.vpnManager.Status != VpnConnectionState.Disconnected)
{
await this.vpnManager.Disconnect();
}
else
{
await this.vpnManager.Connect(new VpnConnectionOptions(this.ServerAddress)
{
UserName = this.UserName,
Password = this.Password
});
}
});
}
IReactiveCommand CreateOneReading(IDialogs dialogs, LocationRetrieve retrieve)
{
IReactiveCommand command = ReactiveCommand.CreateFromTask(async ct =>
{
var observable = retrieve switch
{
LocationRetrieve.Last => this.manager.GetLastReading(),
LocationRetrieve.Current => this.manager.GetCurrentPosition(),
_ => this.manager.GetLastReadingOrCurrentPosition()
};
var reading = await observable.ToTask(ct);
if (reading == null)
{
await dialogs.Alert("Could not getting GPS coordinates");
}
else
{
this.SetValues(reading);
}
});
this.BindBusyCommand(command);
return(command);
}
public AdvertiserViewModel(IDialogs dialogs, IBeaconAdvertiser?advertiser = null)
{
this.Toggle = ReactiveCommand.CreateFromTask(
async() =>
{
if (advertiser == null)
{
await dialogs.Alert("Beacon advertising not supported on this platform");
return;
}
if (advertiser.Uuid != null)
{
this.ToggleText = StartText;
await advertiser.Stop();
}
else
{
var uuid = Guid.Parse(this.Uuid);
var major = UInt16.Parse(this.Major);
var minor = UInt16.Parse(this.Minor);
Byte.Parse(this.TxPower);
await advertiser.Start(uuid, major, minor);
this.ToggleText = StopText;
}
},
this.WhenAny(
x => x.Uuid,
x => x.Major,
x => x.Minor,
x => x.TxPower,
(uuid, major, minor, tx) =>
{
if (!Guid.TryParse(uuid.GetValue(), out var _))
{
return(false);
}
if (!UInt16.TryParse(major.GetValue(), out var M) || M == 0)
{
return(false);
}
if (!UInt16.TryParse(minor.GetValue(), out var m) || m == 0)
{
return(false);
}
if (!Byte.TryParse(tx.GetValue(), out var _))
{
return(false);
}
return(true);
}
)
);
}
public static async Task <bool> AlertAccess(this IDialogs dialogs, AccessState access)
{
switch (access)
{
case AccessState.Available:
return(true);
case AccessState.Restricted:
await dialogs.Alert("WARNING: Access is restricted");
return(true);
default:
await dialogs.Alert("Invalid Access State: " + access);
return(false);
}
}
public MediaScannerViewModel(IDialogs dialogs, IMediaGalleryScanner?scanner = null)
{
this.RunQuery = ReactiveCommand.CreateFromTask(async() =>
{
this.IsSearchExpanded = false;
this.IsBusy = true;
if (scanner == null)
{
await dialogs.Alert("Media scanner not supported");
return;
}
var result = await scanner.RequestAccess();
if (result != AccessState.Available)
{
await dialogs.Alert("Invalid Status - " + result);
return;
}
var mediaTypes = MediaTypes.None;
if (this.IncludeAudio)
{
mediaTypes |= MediaTypes.Audio;
}
if (this.IncludeImages)
{
mediaTypes |= MediaTypes.Image;
}
if (this.IncludeVideos)
{
mediaTypes |= MediaTypes.Video;
}
var list = await scanner.Query(mediaTypes, this.SyncFrom);
this.List.ReplaceAll(list.Select(x => new CommandItem
{
Text = $"{x.Type} - {x.FilePath}",
ImageUri = x.Type == MediaTypes.Audio ? null : x.FilePath
}));
this.IsBusy = false;
});
this.BindBusyCommand(this.RunQuery);
}
public ListViewModel(IDialogs dialogs, IMotionActivityManager?activityManager = null)
{
this.activityManager = activityManager;
this.Load = ReactiveCommand.CreateFromTask(async() =>
{
if (this.activityManager == null)
{
await dialogs.Alert("MotionActivity is not supported on this platform");
return;
}
var result = await this.activityManager.RequestAccess();
if (result != Shiny.AccessState.Available)
{
await dialogs.Alert("Motion Activity is not available - " + result);
return;
}
var activities = await this.activityManager.QueryByDate(this.Date);
this.Events = activities
.OrderByDescending(x => x.Timestamp)
.Select(x => new CommandItem
{
Text = $"({x.Confidence}) {x.Types}",
Detail = $"{x.Timestamp.LocalDateTime}"
})
.ToList();
this.EventCount = this.Events.Count;
});
this.BindBusyCommand(this.Load);
this.WhenAnyValue(x => x.Date)
.DistinctUntilChanged()
.Select(_ => Unit.Default)
.InvokeCommand((ICommand)this.Load)
.DisposeWith(this.DestroyWith);
}
public DictationViewModel(ISpeechRecognizer speech, IDialogs dialogs)
{
speech
.WhenListeningStatusChanged()
.SubOnMainThread(x => this.IsListening = x);
this.ToggleListen = ReactiveCommand.Create(() =>
{
if (this.IsListening)
{
this.Deactivate();
}
else
{
if (this.UseContinuous)
{
speech
.ContinuousDictation()
.SubOnMainThread(
x => this.Text += " " + x,
ex => dialogs.Alert(ex.ToString())
)
.DisposedBy(this.DeactivateWith);
}
else
{
speech
.ListenUntilPause()
.SubOnMainThread(
x => this.Text = x,
ex => dialogs.Alert(ex.ToString())
)
.DisposedBy(this.DeactivateWith);
}
}
});
}
public BasicViewModel(IAppSettings appSettings,
ISettings settings,
IDialogs dialogs)
{
this.appSettings = appSettings;
this.OpenAppSettings = ReactiveCommand.CreateFromTask(async() =>
{
var result = await settings.OpenAppSettings();
if (!result)
{
await dialogs.Alert("Could not open appsettings");
}
});
}
public SettingsViewModel(ITripTrackerManager manager, IDialogs dialogs)
{
this.IsEnabled = manager.TrackingType == null;
this.UseAutomotive = manager.TrackingType == TripTrackingType.Automotive;
this.UseCycling = manager.TrackingType == TripTrackingType.Cycling;
this.UseRunning = manager.TrackingType == TripTrackingType.Running;
this.UseWalking = manager.TrackingType == TripTrackingType.Walking;
this.UseOnFoot = manager.TrackingType == TripTrackingType.OnFoot;
this.UseExercise = manager.TrackingType == TripTrackingType.Exercise;
this.UseStationary = manager.TrackingType == TripTrackingType.Stationary;
this.ToggleMonitoring = ReactiveCommand.CreateFromTask
(
async() =>
{
var access = await manager.RequestAccess();
if (access != AccessState.Available)
{
await dialogs.Alert("Invalid Access - " + access);
}
else
{
if (!this.IsEnabled)
{
await manager.StopTracking();
}
else
{
var type = this.GetTrackingType().Value;
await manager.StartTracking(type);
}
this.IsEnabled = !this.IsEnabled;
this.RaisePropertyChanged(nameof(this.MonitoringText));
}
},
this.WhenAny(
x => x.UseAutomotive,
x => x.UseRunning,
x => x.UseWalking,
x => x.UseCycling,
x => x.UseOnFoot,
x => x.UseExercise,
x => x.UseStationary,
(auto, run, walk, cycle, foot, ex, st) => this.GetTrackingType() != null
)
);
}
public MonitoringViewModel(INavigationService navigator,
IDialogs dialogs,
IBeaconMonitoringManager?beaconManager = null)
{
this.Add = navigator.NavigateCommand("CreateBeacon");
this.Load = ReactiveCommand.CreateFromTask(async() =>
{
if (beaconManager == null)
{
await dialogs.Alert("Beacon monitoring is not supported on this platform");
return;
}
var regions = await beaconManager.GetMonitoredRegions();
this.Regions = regions
.Select(x => new CommandItem
{
Text = $"{x.Identifier}",
Detail = $"{x.Uuid}/{x.Major ?? 0}/{x.Minor ?? 0}",
PrimaryCommand = ReactiveCommand.CreateFromTask(async() =>
{
await beaconManager.StopMonitoring(x.Identifier);
this.Load.Execute(null);
})
})
.ToList();
});
this.StopAllMonitoring = ReactiveCommand.CreateFromTask(
async() =>
{
var result = await dialogs.Confirm("Are you sure you wish to stop all monitoring");
if (result)
{
await beaconManager.StopAllMonitoring();
this.Load.Execute(null);
}
},
Observable.Return(beaconManager != null)
);
}
public PeripheralViewModel(IDialogs dialogs)
{
this.dialogs = dialogs;
this.SelectCharacteristic = ReactiveCommand.Create <GattCharacteristicViewModel>(x => x.Select());
this.ConnectionToggle = ReactiveCommand.Create(() =>
{
// don't cleanup connection - force user to d/c
if (this.peripheral.Status == ConnectionState.Connected || this.peripheral.Status == ConnectionState.Connecting)
{
this.peripheral.CancelConnection();
}
else
{
this.peripheral.Connect();
}
});
this.PairToDevice = ReactiveCommand.CreateFromTask(async() =>
{
var pair = this.peripheral as ICanPairPeripherals;
if (pair == null)
{
await dialogs.Alert("Pairing is not supported on this platform");
}
else if (pair.PairingStatus == PairingState.Paired)
{
await dialogs.Snackbar("Peripheral is already paired");
}
else
{
var pin = await this.dialogs.Input("Use PIN? Cancel to not use one");
var result = await pair.PairingRequest(pin);
await dialogs.Snackbar(result ? "Peripheral Paired Successfully" : "Peripheral Pairing Failed");
this.RaisePropertyChanged(nameof(this.PairingText));
}
});
this.RequestMtu = ReactiveCommand.CreateFromTask(
async x =>
{
var mtu = this.peripheral as ICanRequestMtu;
if (mtu == null)
{
await dialogs.Alert("MTU requests are not supported on this platform");
}
else
{
var result = await dialogs.Input("MTU Request", "Range 20-512");
if (!result.IsEmpty())
{
var actual = await mtu.RequestMtu(Int32.Parse(result));
await dialogs.Snackbar("MTU Changed to " + actual);
}
}
},
this.WhenAny(
x => x.ConnectText,
x => x.GetValue().Equals("Disconnect")
)
);
}
public CreateViewModel(INotificationManager notificationManager, IDialogs dialogs)
{
this.notificationManager = notificationManager;
this.WhenAnyValue
(
x => x.SelectedDate,
x => x.SelectedTime
)
.Select(x => new DateTime(
x.Item1.Year,
x.Item1.Month,
x.Item1.Day,
x.Item2.Hours,
x.Item2.Minutes,
x.Item2.Seconds)
)
.Subscribe(x => this.ScheduledTime = x)
.DisposeWith(this.DestroyWith);
//.ToPropertyEx(this, x => x.ScheduledTime);
this.SelectedDate = DateTime.Now;
this.SelectedTime = DateTime.Now.TimeOfDay.Add(TimeSpan.FromMinutes(10));
this.SendNow = ReactiveCommand.CreateFromTask(() => this.BuildAndSend(
"Test Now",
"This is a test of the sendnow stuff",
null
));
this.Send = ReactiveCommand.CreateFromTask(
async() =>
{
await this.BuildAndSend(
this.NotificationTitle,
this.NotificationMessage,
this.ScheduledTime
);
await dialogs.Alert("Notification Sent Successfully");
},
this.WhenAny(
x => x.NotificationTitle,
x => x.NotificationMessage,
x => x.ScheduledTime,
(title, msg, sch) =>
!title.GetValue().IsEmpty() &&
!msg.GetValue().IsEmpty() &&
sch.GetValue() > DateTime.Now
)
);
this.PermissionCheck = ReactiveCommand.CreateFromTask(async() =>
{
var result = await notificationManager.RequestAccess();
await dialogs.Snackbar("Permission Check Result: " + result);
});
this.StartChat = ReactiveCommand.CreateFromTask(() =>
notificationManager.Send(
"Shiny Chat",
"Hi, What's your name?",
"ChatName",
DateTime.Now.AddSeconds(10)
)
);
}
public AdapterViewModel(INavigationService navigator,
IDialogs dialogs,
IBleManager?bleManager = null)
{
this.IsScanning = bleManager?.IsScanning ?? false;
this.CanControlAdapterState = bleManager?.CanControlAdapterState() ?? false;
this.WhenAnyValue(x => x.SelectedPeripheral)
.Skip(1)
.Where(x => x != null)
.Subscribe(async x => await navigator.Navigate("Peripheral", ("Peripheral", x.Peripheral)));
this.ToggleAdapterState = ReactiveCommand.CreateFromTask(
async() =>
{
if (bleManager == null)
{
await dialogs.Alert("Platform Not Supported");
}
else
{
var poweredOn = bleManager.Status == AccessState.Available;
if (!bleManager.TrySetAdapterState(!poweredOn))
{
await dialogs.Alert("Cannot change bluetooth adapter state");
}
}
}
);
this.ScanToggle = ReactiveCommand.CreateFromTask(
async() =>
{
if (bleManager == null)
{
await dialogs.Alert("Platform Not Supported");
return;
}
if (this.IsScanning)
{
this.Deactivate();
}
else
{
this.IsScanning = true;
this.Peripherals.Clear();
bleManager
.Scan()
.Buffer(TimeSpan.FromSeconds(1))
.SubOnMainThread(
results =>
{
var list = new List <PeripheralItemViewModel>();
foreach (var result in results)
{
var peripheral = this.Peripherals.FirstOrDefault(x => x.Equals(result.Peripheral));
if (peripheral == null)
{
peripheral = list.FirstOrDefault(x => x.Equals(result.Peripheral));
}
if (peripheral != null)
{
peripheral.Update(result);
}
else
{
peripheral = new PeripheralItemViewModel(result.Peripheral);
peripheral.Update(result);
list.Add(peripheral);
}
}
if (list.Any())
{
// XF is not able to deal with an observablelist/addrange properly
foreach (var item in list)
{
this.Peripherals.Add(item);
}
}
},
ex => dialogs.Alert(ex.ToString(), "ERROR")
)
.DisposeWith(this.DeactivateWith);
}
}
);
}
public GpsViewModel(IGpsManager manager, IDialogs dialogs)
{
this.manager = manager;
this.IsUpdating = this.manager.IsListening;
this.WhenAnyValue(x => x.UseBackground)
.Subscribe(x => this.Access = this.manager.GetCurrentStatus(
new GpsRequest {
UseBackground = this.UseBackground
}).ToString()
);
this.WhenAnyValue(x => x.IsUpdating)
.Select(x => x ? "Stop Listening" : "Start Updating")
.ToPropertyEx(this, x => x.ListenerText);
this.GetCurrentPosition = ReactiveCommand.CreateFromTask(async _ =>
{
var result = await dialogs.RequestAccess(() => this.manager.RequestAccess(new GpsRequest()));
if (!result)
{
return;
}
var reading = await this.manager.GetLastReading();
if (reading == null)
{
await dialogs.Alert("Could not getting GPS coordinates");
}
else
{
this.SetValues(reading);
}
});
this.BindBusyCommand(this.GetCurrentPosition);
ReactiveCommand.Create(() => dialogs.ActionSheet(
"Select Priority",
false,
("Highest", () => this.Priority = GpsPriority.Highest),
("Normal", () => this.Priority = GpsPriority.Normal),
("Low", () => this.Priority = GpsPriority.Low)
));
this.ToggleUpdates = ReactiveCommand.CreateFromTask(
async() =>
{
if (this.manager.IsListening)
{
await this.manager.StopListener();
this.gpsListener?.Dispose();
}
else
{
var result = await dialogs.RequestAccess(() => this.manager.RequestAccess(new GpsRequest {
UseBackground = this.UseBackground
}));
if (!result)
{
await dialogs.Alert("Insufficient permissions");
return;
}
var request = new GpsRequest
{
UseBackground = this.UseBackground,
Priority = this.Priority,
};
if (IsInterval(this.DesiredInterval))
{
request.Interval = ToInterval(this.DesiredInterval);
}
if (IsInterval(this.ThrottledInterval))
{
request.ThrottledInterval = ToInterval(this.ThrottledInterval);
}
await this.manager.StartListener(request);
}
this.IsUpdating = this.manager.IsListening;
},
this.WhenAny(
x => x.IsUpdating,
x => x.DesiredInterval,
x => x.ThrottledInterval,
(u, i, t) =>
{
if (u.GetValue())
{
return(true);
}
var isdesired = IsInterval(i.GetValue());
var isthrottled = IsInterval(t.GetValue());
if (isdesired && isthrottled)
{
var desired = ToInterval(i.GetValue());
var throttle = ToInterval(t.GetValue());
if (throttle.TotalSeconds >= desired.TotalSeconds)
{
return(false);
}
}
return(true);
}
)
);
this.UseRealtime = ReactiveCommand.Create(() =>
{
var rt = GpsRequest.Realtime(false);
this.ThrottledInterval = String.Empty;
this.DesiredInterval = rt.Interval.TotalSeconds.ToString();
this.Priority = rt.Priority;
});
this.RequestAccess = ReactiveCommand.CreateFromTask(async() =>
{
var access = await this.manager.RequestAccess(new GpsRequest {
UseBackground = this.UseBackground
});
this.Access = access.ToString();
});
this.BindBusyCommand(this.RequestAccess);
}
public AdapterViewModel(IBleManager central,
INavigationService navigator,
IDialogs dialogs)
{
this.CanControlAdapterState = central.CanControlAdapterState();
this.WhenAnyValue(x => x.SelectedPeripheral)
.Skip(1)
.Where(x => x != null)
.SubOnMainThread(x => navigator.Navigate("Peripheral", ("Peripheral", x.Peripheral)));
this.ToggleAdapterState = ReactiveCommand.CreateFromTask(
async() =>
{
var poweredOn = central.Status == AccessState.Available;
if (!central.TrySetAdapterState(!poweredOn))
{
await dialogs.Alert("Cannot change bluetooth adapter state");
}
}
);
this.ScanToggle = ReactiveCommand.Create(
() =>
{
if (this.IsScanning)
{
this.IsScanning = false;
this.scan?.Dispose();
}
else
{
this.Peripherals.Clear();
this.scan = central
.Scan()
.Buffer(TimeSpan.FromSeconds(1))
.Synchronize()
.SubOnMainThread(
results =>
{
var list = new List <PeripheralItemViewModel>();
foreach (var result in results)
{
var peripheral = this.Peripherals.FirstOrDefault(x => x.Equals(result.Peripheral));
if (peripheral == null)
{
peripheral = list.FirstOrDefault(x => x.Equals(result.Peripheral));
}
if (peripheral != null)
{
peripheral.Update(result);
}
else
{
peripheral = new PeripheralItemViewModel(result.Peripheral);
peripheral.Update(result);
list.Add(peripheral);
}
}
if (list.Any())
{
this.Peripherals.AddRange(list);
}
},
ex => dialogs.Alert(ex.ToString(), "ERROR")
)
.DisposeWith(this.DeactivateWith);
this.IsScanning = true;
}
}
);
}
public ListViewModel(IJobManager jobManager,
INavigationService navigator,
IDialogs dialogs)
{
this.jobManager = jobManager;
this.dialogs = dialogs;
this.Create = navigator.NavigateCommand("CreateJob");
this.LoadJobs = ReactiveCommand.CreateFromTask(async() =>
{
var jobs = await jobManager.GetJobs();
this.Jobs = jobs
.Select(x => new CommandItem
{
Text = x.Identifier,
Detail = x.LastRunUtc?.ToLocalTime().ToString("G") ?? "Never Run",
PrimaryCommand = ReactiveCommand.CreateFromTask(() => jobManager.Run(x.Identifier)),
SecondaryCommand = ReactiveCommand.CreateFromTask(async() =>
{
await jobManager.Cancel(x.Identifier);
this.LoadJobs.Execute(null);
})
})
.ToList();
});
this.BindBusyCommand(this.LoadJobs);
this.RunAllJobs = ReactiveCommand.CreateFromTask(async() =>
{
if (!await this.AssertJobs())
{
return;
}
if (this.jobManager.IsRunning)
{
await dialogs.Alert("Job Manager is already running");
}
else
{
await this.jobManager.RunAll();
await dialogs.Snackbar("Job Batch Started");
}
});
this.CancelAllJobs = ReactiveCommand.CreateFromTask(async _ =>
{
if (!await this.AssertJobs())
{
return;
}
var confirm = await dialogs.Confirm("Are you sure you wish to cancel all jobs?");
if (confirm)
{
await this.jobManager.CancelAll();
this.LoadJobs.Execute(null);
}
});
}
public CreateViewModel(INavigationService navigationService,
IHttpTransferManager httpTransfers,
IDialogs dialogs,
IPlatform platform,
AppSettings appSettings)
{
this.platform = platform;
this.Url = appSettings.LastTransferUrl;
this.WhenAnyValue(x => x.IsUpload)
.Subscribe(upload =>
{
if (!upload && this.FileName.IsEmpty())
{
this.FileName = Guid.NewGuid().ToString();
}
this.Title = upload ? "New Upload" : "New Download";
});
this.ManageUploads = navigationService.NavigateCommand("ManageUploads");
this.ResetUrl = ReactiveCommand.Create(() =>
{
appSettings.LastTransferUrl = null;
this.Url = appSettings.LastTransferUrl;
});
this.SelectUpload = ReactiveCommand.CreateFromTask(async() =>
{
var files = platform.AppData.GetFiles("upload.*", SearchOption.TopDirectoryOnly);
if (!files.Any())
{
await dialogs.Alert("There are not files to upload. Use 'Manage Uploads' below to create them");
}
else
{
var cfg = new Dictionary <string, Action>();
foreach (var file in files)
{
cfg.Add(file.Name, () => this.FileName = file.Name);
}
await dialogs.ActionSheet("Actions", cfg);
}
});
this.Save = ReactiveCommand.CreateFromTask(
async() =>
{
var path = Path.Combine(this.platform.AppData.FullName, this.FileName);
var request = new HttpTransferRequest(this.Url, path, this.IsUpload)
{
UseMeteredConnection = this.UseMeteredConnection
};
await httpTransfers.Enqueue(request);
appSettings.LastTransferUrl = this.Url;
await navigationService.GoBackAsync();
},
this.WhenAny
(
x => x.IsUpload,
x => x.Url,
x => x.FileName,
(up, url, fn) =>
{
this.ErrorMessage = String.Empty;
if (!Uri.TryCreate(url.GetValue(), UriKind.Absolute, out _))
{
this.ErrorMessage = "Invalid URL";
}
else if (up.GetValue() && fn.GetValue().IsEmpty())
{
this.ErrorMessage = "You must select or enter a filename";
}
return(this.ErrorMessage.IsEmpty());
}
)
);
}
public GpsViewModel(IGpsManager manager, IDialogs dialogs)
{
this.manager = manager;
var l = this.manager.CurrentListener;
this.IsUpdating = l != null;
this.UseBackground = l?.UseBackground ?? true;
this.Priority = l?.Priority ?? GpsPriority.Normal;
this.DesiredInterval = l?.Interval.TotalSeconds.ToString() ?? String.Empty;
this.ThrottledInterval = l?.ThrottledInterval?.TotalSeconds.ToString() ?? String.Empty;
this.MinimumDistanceMeters = l?.MinimumDistance?.TotalMeters.ToString() ?? String.Empty;
this.NotificationTitle = manager.Title;
this.NotificationMessage = manager.Message;
this.WhenAnyValue(x => x.IsUpdating)
.Select(x => x ? "Stop Listening" : "Start Updating")
.ToPropertyEx(this, x => x.ListenerText);
this.WhenAnyValue(x => x.NotificationTitle)
.Skip(1)
.Subscribe(x => this.manager.Title = x)
.DisposedBy(this.DestroyWith);
this.WhenAnyValue(x => x.NotificationMessage)
.Skip(1)
.Subscribe(x => this.manager.Message = x)
.DisposedBy(this.DestroyWith);
this.GetCurrentPosition = this.CreateOneReading(dialogs, LocationRetrieve.Current);
this.GetLastReading = this.CreateOneReading(dialogs, LocationRetrieve.Last);
this.GetLastOrCurrent = this.CreateOneReading(dialogs, LocationRetrieve.LastOrCurrent);
ReactiveCommand.Create(() => dialogs.ActionSheet(
"Select Priority",
false,
("Highest", () => this.Priority = GpsPriority.Highest),
("Normal", () => this.Priority = GpsPriority.Normal),
("Low", () => this.Priority = GpsPriority.Low)
));
this.ToggleUpdates = ReactiveCommand.CreateFromTask(
async() =>
{
if (this.manager.CurrentListener != null)
{
await this.manager.StopListener();
this.gpsListener?.Dispose();
}
else
{
var result = await dialogs.RequestAccess(async() =>
{
var access = await this.manager.RequestAccess(new GpsRequest
{
UseBackground = this.UseBackground
});
this.Access = access.ToString();
return(access);
});
if (!result)
{
await dialogs.Alert("Insufficient permissions");
return;
}
var request = new GpsRequest
{
UseBackground = this.UseBackground,
Priority = this.Priority,
};
if (IsNumeric(this.DesiredInterval))
{
request.Interval = ToInterval(this.DesiredInterval);
}
if (IsNumeric(this.ThrottledInterval))
{
request.ThrottledInterval = ToInterval(this.ThrottledInterval);
}
if (IsNumeric(this.MinimumDistanceMeters))
{
request.MinimumDistance = Distance.FromMeters(Int32.Parse(this.MinimumDistanceMeters));
}
await this.manager.StartListener(request);
}
this.IsUpdating = this.manager.CurrentListener != null;
},
this.WhenAny(
x => x.IsUpdating,
x => x.DesiredInterval,
x => x.ThrottledInterval,
x => x.MinimumDistanceMeters,
(u, i, t, d) =>
{
if (u.GetValue())
{
return(true);
}
var isdesired = IsNumeric(i.GetValue());
var isthrottled = IsNumeric(t.GetValue());
var ismindist = IsNumeric(d.GetValue());
if (isdesired && isthrottled)
{
var desired = ToInterval(i.GetValue());
var throttle = ToInterval(t.GetValue());
if (throttle.TotalSeconds >= desired.TotalSeconds)
{
return(false);
}
}
return(true);
}
)
);
this.UseRealtime = ReactiveCommand.Create(() =>
{
var rt = GpsRequest.Realtime(false);
this.ThrottledInterval = String.Empty;
this.DesiredInterval = rt.Interval.TotalSeconds.ToString();
this.Priority = rt.Priority;
});
this.RequestAccess = ReactiveCommand.CreateFromTask(async() =>
{
var access = await this.manager.RequestAccess(new GpsRequest {
UseBackground = this.UseBackground
});
this.Access = access.ToString();
});
this.BindBusyCommand(this.RequestAccess);
}