public void StartLocationService(GeoPositionAccuracy accuracy)
{
Debug.WriteLine("StartLocationService");
_watcher.MovementThreshold = 1;
// Start data acquisition
_watcher.Start();
}
private void StartLocationService(GeoPositionAccuracy accuracy, bool toggle)
{
if (toggle == true) // Reinitialize the GeoCoordinateWatcher
{
watcher = new GeoCoordinateWatcher(accuracy);
settings = IsolatedStorageSettings.ApplicationSettings;
if (settings.Contains("slider"))
{
watcher.MovementThreshold = Convert.ToDouble(settings["slider"]);
path = Convert.ToDouble(settings["slider"]);
var = Convert.ToDouble(settings["slider"]);
}
else
{
settings["slider"] = 5;
path = 5; var = 5;
}
// Add event handlers for StatusChanged and PositionChanged events
watcher.PositionChanged += new EventHandler <GeoPositionChangedEventArgs <GeoCoordinate> >(watcher_PositionChanged);
// Start data acquisition
watcher.Start();
}
else if (toggle == false)
{
// if(watcher.Status)
watcher.Stop();
//watcher.Dispose();
}
}
private void StartLocationService(GeoPositionAccuracy precision)
{
txtEstado.Text = "Iniciando, " + txtPrecision;
watch = new GeoCoordinateWatcher(precision);
this.watch.MovementThreshold = 10;
this.watch.PositionChanged += watcher_PositionChanged;
this.watch.Start();
}
public LocationWrapper(GeoPositionAccuracy accuracy, double movementThreshold)
{
_watcher = new GeoCoordinateWatcher(accuracy)
{
MovementThreshold = movementThreshold
};
_watcher.StatusChanged += WatcherStatusChanged;
_watcher.PositionChanged += WatcherPositionChanged;
}
public LocationFinder(bool includeAllCities = true, GeoPositionAccuracy accuracy = GeoPositionAccuracy.High, double movementThreshold = 5.0)
{
_geoCoordinates = new GeoCoordinateObservable(accuracy, movementThreshold);
// There is no usefully-implemented CivicAddressResolver in Windows Phone 7.1. Maybe Windows 8?
_resolver = new VegasResolver(includeAllCities);
// Testing code for Rx - make darn sure I have a reference to something in System.Reactive.Linq.
new[] { 1, 2, 3 }.ToObservable();
}
/// <summary>
/// Helper method to start up the location data acquisition
/// </summary>
/// <param name="accuracy">The accuracy level </param>
private void StartLocationService(GeoPositionAccuracy accuracy)
{
// Reinitialize the GeoCoordinateWatcher
watcher = new GeoCoordinateWatcher(accuracy);
watcher.MovementThreshold = 20;
// Add event handlers for StatusChanged and PositionChanged events
watcher.StatusChanged += new EventHandler <GeoPositionStatusChangedEventArgs>(watcher_StatusChanged);
watcher.PositionChanged += new EventHandler <GeoPositionChangedEventArgs <GeoCoordinate> >(watcher_PositionChanged);
// Start data acquisition
watcher.Start();
}
public static LocationServiceAccuracy ToLocationServiceAccuracy(this GeoPositionAccuracy positionAccuracy)
{
switch (positionAccuracy)
{
case GeoPositionAccuracy.Default:
return(LocationServiceAccuracy.Default);
case GeoPositionAccuracy.High:
return(LocationServiceAccuracy.High);
default:
throw new ArgumentOutOfRangeException("positionAccuracy");
}
}
/// <summary>
/// Helper method to start up the location data acquisition
/// </summary>
/// <param name="accuracy">The accuracy level </param>
private void StartLocationService(GeoPositionAccuracy accuracy)
{
// Reinitialize the GeoCoordinateWatcher
StatusTextBlock.Text = "starting, " + accuracyText;
watcher = new GeoCoordinateWatcher(accuracy);
watcher.MovementThreshold = 20;
// Add event handlers for StatusChanged and PositionChanged events
watcher.StatusChanged += new EventHandler<GeoPositionStatusChangedEventArgs>(watcher_StatusChanged);
watcher.PositionChanged += new EventHandler<GeoPositionChangedEventArgs<GeoCoordinate>>(watcher_PositionChanged);
// Start data acquisition
watcher.Start();
}
// <summary>
// Creates an instance of GeoCoordinateWatcherInternal with the specified desired accuracy
// </summary>
public GeoCoordinateWatcherInternal(GeoPositionAccuracy desiredAccuracy)
{
//
// Create the native location object on a worker thread, so that it exists
// in a multithreaded apartment.
//
ThreadPool.QueueUserWorkItem(new WaitCallback(this.CreateHandler), desiredAccuracy);
Utility.Trace("GeoCoordinateWatcherInternal.ctor:" +
" desiredAccuracy: " + desiredAccuracy.ToString() +
" m_latLongRegistered: " + m_latLongRegistered.ToString() +
" m_civicAddrRegistered: " + m_civicAddrRegistered.ToString() +
" m_latLongStatus: " + m_latLongStatus.ToString() +
" m_curStatus: " + m_curStatus.ToString());
}
public void GetCurrentLocation(GeoPositionAccuracy accuracy)
{
try
{
Start(accuracy);
CheckCurrentState();
}
catch (Exception ex)
{
Stop();
_actionToExecute(null, ex);
}
}
private void StartLocationService(GeoPositionAccuracy accuracy)
{
mMainPageViewModel.IsLoading = true;
// Reinitialize the GeoCoordinateWatcher
mWatcher = new GeoCoordinateWatcher(accuracy);
mWatcher.MovementThreshold = 20;
// Add event handler
mWatcher.StatusChanged += new EventHandler <GeoPositionStatusChangedEventArgs>(watcher_StatusChanged);
mWatcher.PositionChanged += new EventHandler <GeoPositionChangedEventArgs <GeoCoordinate> >(watcher_PositionChanged);
// Start data acquisition
mWatcher.Start();
}
private void StartLocationService(GeoPositionAccuracy accuracy)
{
Debug.WriteLine("StartLocationService");
// Reinitialize the GeoCoordinateWatcher
//StatusTextBlock.Text = "starting, " + accuracyText;
watcher = new GeoCoordinateWatcher(accuracy);
watcher.MovementThreshold = 10;
// Add event handlers for StatusChanged and PositionChanged events
watcher.StatusChanged += new EventHandler <GeoPositionStatusChangedEventArgs>(watcher_StatusChanged);
watcher.PositionChanged += new EventHandler <GeoPositionChangedEventArgs <GeoCoordinate> >(watcher_PositionChanged);
// Start data acquisition
watcher.Start();
}
public void GetCurrentLocation(GeoPositionAccuracy accuracy)
{
try
{
Start(accuracy);
CheckCurrentState();
}
catch (Exception ex)
{
Stop();
_actionToExecute(null, ex);
}
}
protected void Start(GeoPositionAccuracy desiredAccuracy, double movementThreshold)
{
if (GeoCoordinateWatcher != null)
{
return;
}
GeoCoordinateWatcher = new GeoCoordinateWatcher(desiredAccuracy)
{
MovementThreshold = movementThreshold
};
GeoCoordinateWatcher.PositionChanged += GeoCoordinateWatcherPositionChanged;
GeoCoordinateWatcher.StatusChanged += GeoCoordinateWatcherStatusChanged;
GeoCoordinateWatcher.Start();
}
public void Start(GeoPositionAccuracy accuracy, double movementThreshold)
{
if (_watcher != null)
{
return;
}
_watcher = new GeoCoordinateWatcher(accuracy)
{
MovementThreshold = movementThreshold
};
_watcher.PositionChanged += Watcher_PositionChanged;
_watcher.StatusChanged += Watcher_StatusChanged;
_watcher.Start();
State = LocationServiceState.Started;
}
private void StartService(GeoPositionAccuracy accuracy)
{
if (service != null)
{
StopService();
}
service = new GeoCoordinateWatcher(accuracy);
service.MovementThreshold = 1.0;
service.PositionChanged += service_PositionChanged;
service.StatusChanged += service_StatusChanged;
status.Text = string.Format("Permission: {0}\n", service.Permission);
position.Text = string.Empty;
if (service.Permission == GeoPositionPermission.Granted)
{
service.Start();
}
}
public GeoCoordinateWatcher(GeoPositionAccuracy desiredAccuracy)
{
m_desiredAccuracy = desiredAccuracy;
m_watcher = new GeoCoordinateWatcherInternal(desiredAccuracy);
if (SynchronizationContext.Current == null)
{
//
// Create a SynchronizationContext if there isn't one on calling thread
//
m_synchronizationContext = new SynchronizationContext();
}
else
{
m_synchronizationContext = SynchronizationContext.Current;
}
m_watcher.StatusChanged += new EventHandler <GeoPositionStatusChangedEventArgs>(OnInternalStatusChanged);
m_watcher.PermissionChanged += new EventHandler <GeoPermissionChangedEventArgs>(OnInternalPermissionChanged);
m_watcher.PositionChanged += new EventHandler <GeoPositionChangedEventArgs <GeoCoordinate> >(OnInternalLocationChanged);
}
public void Start(GeoPositionAccuracy desiredAccuracy)
{
try
{
Start(desiredAccuracy, 0);
CheckCurrentState();
_timer = new DispatcherTimer()
{
Interval = _timeout
};
_timer.Tick += TimerTick;
_timer.Start();
}
catch (Exception ex)
{
Stop();
_actionToExecute(null, ex);
}
}
public void Start(GeoPositionAccuracy desiredAccuracy)
{
try
{
Start(desiredAccuracy, 0);
CheckCurrentState();
_timer = new DispatcherTimer()
{
Interval = _timeout
};
_timer.Tick += TimerTick;
_timer.Start();
}
catch (Exception ex)
{
Stop();
_actionToExecute(null, ex);
}
}
public IObservable<GeoCoordinate> LocationByTimeThreshold(TimeSpan frequency, GeoPositionAccuracy accuracy)
{
return this.location;
}
public GeoCoordinateWatcherAdapter(GeoPositionAccuracy desiredAccuracy)
: base(desiredAccuracy)
{
}
private void StartService(GeoPositionAccuracy accuracy)
{
if (service != null)
StopService();
service = new GeoCoordinateWatcher(accuracy);
service.MovementThreshold = 1.0;
service.PositionChanged += service_PositionChanged;
service.StatusChanged += service_StatusChanged;
status.Text = string.Format("Permission: {0}\n", service.Permission);
position.Text = string.Empty;
if (service.Permission == GeoPositionPermission.Granted)
service.Start();
}
public GeoCoordinateObservable(GeoPositionAccuracy accuracy, double movementThreshold)
{
_watcher = new GeoCoordinateWatcher(accuracy);
_watcher.MovementThreshold = movementThreshold;
}
private void StartLocationService(GeoPositionAccuracy accuracy)
{
mMainPageViewModel.IsLoading = true;
// Reinitialize the GeoCoordinateWatcher
mWatcher = new GeoCoordinateWatcher(accuracy);
mWatcher.MovementThreshold = 20;
// Add event handler
mWatcher.StatusChanged += new EventHandler<GeoPositionStatusChangedEventArgs>(watcher_StatusChanged);
mWatcher.PositionChanged += new EventHandler<GeoPositionChangedEventArgs<GeoCoordinate>>(watcher_PositionChanged);
// Start data acquisition
mWatcher.Start();
}
public GeoCoordinateWatcher(GeoPositionAccuracy desiredAccuracy)
{
DesiredAccuracy = desiredAccuracy;
Status = GeoPositionStatus.Initializing;
Position = new GeoPosition<GeoCoordinate>(DateTimeOffset.Now, InitialPosition);
}
public IObservable<GeoCoordinate> Location(GeoPositionAccuracy accuracy)
{
return this.location;
}
public IObservable<GeoCoordinate> Location(GeoPositionAccuracy accuracy, TimeSpan locationTimeout)
{
return this.location;
}
public GeoCoordinateWatcher(GeoPositionAccuracy desiredAccuracy)
{
DesiredAccuracy = desiredAccuracy;
Status = GeoPositionStatus.Initializing;
Position = new GeoPosition <GeoCoordinate>(DateTimeOffset.Now, InitialPosition);
}
public GLocationService(GeoPositionAccuracy geoPositionAccuracy)
{
geoWatcher = new GeoCoordinateWatcher(geoPositionAccuracy);
_locationServiceStatus = gSystemSettings.GLocationServiceStatus.NotStarted;
}
/// <summary>
/// Thread pool callback used to ensure location COM API is instantiated from
/// multi-thread apartment, and register for location events.
/// </summary>
/// <param name="state"></param>
private void CreateHandler(object state)
{
lock (this.InternalSyncObject)
{
try
{
m_location = new COMLocation() as ILocation;
}
catch (COMException)
{
Utility.Trace("Failed to CoCreate ILocation COM object.");
}
if (null != m_location)
{
Utility.Trace("Successfully created ILocation COM object");
//
// Mapping to platform accuracy
//
GeoPositionAccuracy desiredAccuracy = (GeoPositionAccuracy)state;
DesiredAccuracy accuracy = (desiredAccuracy == GeoPositionAccuracy.Default) ?
DesiredAccuracy.DefaultAccuracy : DesiredAccuracy.HighAccuracy;
Guid reportKey = LocationReportKey.LatLongReport;
m_location.SetDesiredAccuracy(ref reportKey, accuracy);
//
// Always listen for latlong reports
//
if (m_location.RegisterForReport(this, ref reportKey, 0) == 0)
{
m_latLongRegistered = true;
}
//
// Check the latlong status. If latlong reports are not supported, then register
// for civic address reports.
//
m_location.GetReportStatus(ref reportKey, ref m_latLongStatus);
if (ReportStatus.NotSupported == m_latLongStatus)
{
reportKey = LocationReportKey.CivicAddressReport;
if (m_location.RegisterForReport(this, ref reportKey, 0) == 0)
{
m_civicAddrRegistered = true;
m_location.GetReportStatus(ref reportKey, ref m_civicAddrStatus);
}
}
//
// set the current status to the available report type status
//
ReportStatus status = (ReportStatus.NotSupported != m_latLongStatus) ? m_latLongStatus : m_civicAddrStatus;
m_curStatus = m_geoStatusMap[(int)status];
ChangePermissionFromReportStatus(status);
}
else
{
m_curStatus = GeoPositionStatus.Disabled;
}
}
}
public GeoCoordinateWatcherAdapter(GeoPositionAccuracy accuracy)
: base(accuracy)
{
}
public FakeGeoCoordinateWatcher(GeoPositionAccuracy accuracy)
{
}
public IObservable<GeoCoordinate> LocationByDistanceThreshold(int distance, GeoPositionAccuracy accuracy)
{
return this.location;
}
public LocationWrapper(GeoPositionAccuracy accuracy, double movementThreshold)
{
_watcher = new GeoCoordinateWatcher(accuracy) { MovementThreshold = movementThreshold };
_watcher.StatusChanged += WatcherStatusChanged;
_watcher.PositionChanged += WatcherPositionChanged;
}
protected void Start(GeoPositionAccuracy desiredAccuracy, double movementThreshold)
{
if (GeoCoordinateWatcher != null)
{
return;
}
GeoCoordinateWatcher = new GeoCoordinateWatcher(desiredAccuracy)
{
MovementThreshold = movementThreshold
};
GeoCoordinateWatcher.PositionChanged += GeoCoordinateWatcherPositionChanged;
GeoCoordinateWatcher.StatusChanged += GeoCoordinateWatcherStatusChanged;
GeoCoordinateWatcher.Start();
}
/// <summary>
/// Gets the current location, using the specified accuracy.
/// </summary>
/// <param name="accuracy">The desired accuracy.</param>
/// <returns>The <see cref="Task"/> object representing the asynchronous operation.</returns>
public Task<GeoCoordinate> GetCurrentLocationTaskAsync(GeoPositionAccuracy accuracy)
{
var taskCompletionSource = new TaskCompletionSource<GeoCoordinate>();
new CurrentLocationHelper((x, e) =>
{
if (e != null)
{
taskCompletionSource.SetException(e);
}
else
{
taskCompletionSource.SetResult(x);
}
}).GetCurrentLocation(accuracy);
return taskCompletionSource.Task;
}
private void StartLocationService(GeoPositionAccuracy accuracy, bool toggle)
{
if (toggle == true) // Reinitialize the GeoCoordinateWatcher
{
watcher = new GeoCoordinateWatcher(accuracy);
settings = IsolatedStorageSettings.ApplicationSettings;
if (settings.Contains("slider"))
{
watcher.MovementThreshold = Convert.ToDouble(settings["slider"]);
path = Convert.ToDouble(settings["slider"]);
var = Convert.ToDouble(settings["slider"]);
}
else
{
settings["slider"] = 5;
path = 5; var = 5;
}
// Add event handlers for StatusChanged and PositionChanged events
watcher.PositionChanged += new EventHandler<GeoPositionChangedEventArgs<GeoCoordinate>>(watcher_PositionChanged);
// Start data acquisition
watcher.Start();
}
else if (toggle == false)
{
// if(watcher.Status)
watcher.Stop();
//watcher.Dispose();
}
}
public GLocation(GeoPositionAccuracy geoPositionAccuracy)
{
geoWatcher = new GeoCoordinateWatcher(geoPositionAccuracy);
}
private void StartLocationService(GeoPositionAccuracy accuracy) {
this._watcher = new GeoCoordinateWatcher(accuracy);
this._watcher.MovementThreshold = 20;
this._watcher.StatusChanged += new EventHandler<GeoPositionStatusChangedEventArgs>(watcher_StatusChanged);
this._watcher.PositionChanged += new EventHandler<GeoPositionChangedEventArgs<GeoCoordinate>>(watcher_PositionChanged);
this._watcher.Start();
}
/// <summary>
/// Starts the acquisition of data from the location service, using the specified accuracy.
/// </summary>
/// <param name="accuracy">The desired accuracy.</param>
public void Start(GeoPositionAccuracy accuracy)
{
Start(accuracy, DefaultMovementThreshold);
}
public GeoCoordinateWatcherAdapter(GeoPositionAccuracy accuracy)
: base(accuracy)
{
}
public FakeGeoCoordinateWatcher(GeoPositionAccuracy accuracy)
{
}
/// <summary>
/// Starts the acquisition of data from the location service, using the specified accuracy.
/// </summary>
/// <param name="accuracy">The desired accuracy.</param>
public void Start(GeoPositionAccuracy accuracy)
{
Start(accuracy, DefaultMovementThreshold);
}
/// <summary>
/// Gets the current location, using the specified accuracy.
/// </summary>
/// <param name="accuracy">The desired accuracy.</param>
/// <param name="locationResult">The <see cref="Action{GeoCoordinate, Exception}" /> to be called once the operation is finished.</param>
public void GetCurrentLocation(GeoPositionAccuracy accuracy, Action <GeoCoordinate, Exception> locationResult)
{
new CurrentLocationHelper(locationResult).GetCurrentLocation(accuracy);
}
public GeoCoordinateWatcherAdapter(GeoPositionAccuracy desiredAccuracy)
{
WrappedSubject = new GeoCoordinateWatcher(desiredAccuracy);
AttachToEvents();
}
public void Start(GeoPositionAccuracy accuracy, double movementThreshold)
{
if (_watcher != null)
{
return;
}
_watcher = new GeoCoordinateWatcher(accuracy)
{
MovementThreshold = movementThreshold
};
_watcher.PositionChanged += Watcher_PositionChanged;
_watcher.StatusChanged += Watcher_StatusChanged;
_watcher.Start();
State = LocationServiceState.Started;
}
public GeoCoordinateWatcherAdapter(GeoPositionAccuracy desiredAccuracy)
: base(desiredAccuracy)
{
}
/// <summary>
/// Gets the current location, using the specified accuracy.
/// </summary>
/// <param name="accuracy">The desired accuracy.</param>
/// <param name="locationResult">The <see cref="Action{GeoCoordinate, Exception}" /> to be called once the operation is finished.</param>
public void GetCurrentLocation(GeoPositionAccuracy accuracy, Action<GeoCoordinate, Exception> locationResult)
{
new CurrentLocationHelper(locationResult).GetCurrentLocation(accuracy);
}
public GLocationService(GeoPositionAccuracy geoPositionAccuracy)
{
geoWatcher = new GeoCoordinateWatcher(geoPositionAccuracy);
_locationServiceStatus = gSystemSettings.GLocationServiceStatus.NotStarted;
}
