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; }