public override void ViewDidLoad()
        {
            base.ViewDidLoad();

            // Perform any additional setup after loading the view, typically from a nib.
            ConfigureView();

            _iPhoneLocationManager = new CLLocationManager();
            if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0))
            {
                _iPhoneLocationManager.RequestWhenInUseAuthorization();
            }

            mapView.ShowsUserLocation = true;

            if (mapView.UserLocationVisible)
            {
                UpdateUiCoords();
            }

            _iPhoneLocationManager.DesiredAccuracy = 1000; // 1000 meters/1 kilometer

            mapView.DidUpdateUserLocation += (sender, e) =>
            {
                if (mapView.UserLocation != null)
                {
                    CLLocationCoordinate2D coords = mapView.UserLocation.Coordinate;
                    MKCoordinateSpan span = new MKCoordinateSpan(MilesToLatitudeDegrees(2), MilesToLongitudeDegrees(2, coords.Latitude));
                    mapView.Region = new MKCoordinateRegion(coords, span);
                    UpdateUiCoords();
                }
            };
        }

        public override bool FinishedLaunching(UIApplication app, NSDictionary options)
        {
            global::Xamarin.Forms.Forms.Init();
            global::Xamarin.FormsMaps.Init();

            locationManager = new CLLocationManager
            {
                DesiredAccuracy = CLLocation.AccuracyBest
            };

            locationManager.Failed += (object sender, NSErrorEventArgs e) =>
            {
                var alert = new UIAlertView(){ Title = "Location manager failed", Message = "The location updater has failed" };
                alert.Show();
                locationManager.StopUpdatingLocation();
            };

            locationManager.LocationsUpdated += (object sender, CLLocationsUpdatedEventArgs e) =>
            {
                var newloc = string.Format("{0},{1}", e.Locations[0].Coordinate.Longitude, e.Locations[0].Coordinate.Latitude);
                App.Self.ChangedClass.BroadcastIt("location", newloc);
            };

            locationManager.StartUpdatingLocation();

            LoadApplication(new App());

            return base.FinishedLaunching(app, options);
        }

        /// <summary>
        /// get the location of user and update to server
        /// </summary>
        public static void DoLocationAndUpdated()
        {
            Location.iPhoneLocationManager = new CLLocationManager ();
            Location.iPhoneLocationManager.DesiredAccuracy = 5; // 1000 meters/1 kilometer
            // if this is iOs6
            if (UIDevice.CurrentDevice.CheckSystemVersion (6, 0)) {
                Location.iPhoneLocationManager.LocationsUpdated += (object sender, CLLocationsUpdatedEventArgs e) => {
                    CLLocation newLocation = e.Locations [e.Locations.Length - 1];
                    Utils.Log("ios6");
                    Location.UpdateLocationToServer(newLocation.Coordinate.Latitude.ToString (), newLocation.Coordinate.Longitude.ToString ());
                    //iPhoneLocationManager.StopUpdatingLocation();
                };
            }
            // if it is iOs 5 or lower
            else {
                Location.iPhoneLocationManager.UpdatedLocation += (object sender, CLLocationUpdatedEventArgs e) => {
                    CLLocation newLocation =  e.NewLocation;
                    Utils.Log("ios5");
                    Location.UpdateLocationToServer(newLocation.Coordinate.Latitude.ToString (), newLocation.Coordinate.Longitude.ToString ());
                    //iPhoneLocationManager.StopUpdatingLocation();
                };
            }

            if (CLLocationManager.LocationServicesEnabled) iPhoneLocationManager.StartUpdatingLocation ();
        }

		public void Start ()
		{
			if (CLLocationManager.LocationServicesEnabled) {
				lman = new CLLocationManager {
					DesiredAccuracy = CLLocation.AccuracyBest,
				};

				lman.RequestWhenInUseAuthorization ();

				lman.LocationsUpdated += (sender, e) => {
					var loc = e.Locations [0];
					Timestamp = loc.Timestamp;
					Location = new Location (loc.Coordinate.Latitude, loc.Coordinate.Longitude, loc.Altitude);
//					Console.WriteLine (Location);
					HorizontalAccuracy = loc.HorizontalAccuracy;
					VerticalAccuracy = loc.VerticalAccuracy;
					LocationReceived (this, EventArgs.Empty);
				};

				lman.UpdatedHeading += (sender, e) => {
					Heading = e.NewHeading.TrueHeading;
//					Console.WriteLine ("Heading: {0}", Heading);
				};

				lman.StartUpdatingLocation ();
				lman.StartUpdatingHeading ();
			}
		}

 public GPSTracker()
 {
     if (CLLocationManager.LocationServicesEnabled)
     {
         _manager = new CLLocationManager();
     }
 }

        public void Init(Action<PLVPaylevenStatus> action, string currency)
        {
            locationManager = new CLLocationManager();
            // TODO: Get current location

            paylevenManager = new PaylevenManager(action, currency, 52.252505, 21.023012);
        }

        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();

            int speedSystem = 0;

            kmhourButton.ValueChanged += (sender,e) => {
                speedSystem = kmhourButton.SelectedSegment;
            };

            _iPhoneLocationManager = new CLLocationManager ();
            _iPhoneLocationManager.DesiredAccuracy = 1000; // 1000 meters/1 kilometer

            //update location based on the specified metric system
            _iPhoneLocationManager.LocationsUpdated += (object sender, CLLocationsUpdatedEventArgs e) => {
                UpdateLocation (speedSystem, e.Locations [e.Locations.Length - 1].Speed);
            };

            if (CLLocationManager.LocationServicesEnabled)
                _iPhoneLocationManager.StartUpdatingLocation ();

            //if viewmap button is touched then display the map
            ViewMap.TouchUpInside += (object sender, EventArgs e) => {
                if (_speedController == null)
                    _speedController = new SpeedController();
                    //_speedController = new MapController();
                NavigationController.PushViewController(_speedController, true);
            };
        }

        public override void FinishedLaunching(UIApplication application)
        {
            locationManager = new CLLocationManager ();

            if (UIDevice.CurrentDevice.CheckSystemVersion (8, 0)) {
                locationManager.RequestWhenInUseAuthorization ();
            }
            // A user can transition in or out of a region while the application is not running.
            // When this happens CoreLocation will launch the application momentarily, call this delegate method
            // and we will let the user know via a local notification.
            locationManager.DidDetermineState += (sender, e) => {
                string body = null;
                if (e.State == CLRegionState.Inside)
                    body = "You're inside the region";
                else if (e.State == CLRegionState.Outside)
                    body = "You're outside the region";

                if (body != null) {
                    var notification = new UILocalNotification () { AlertBody = body };

                    // If the application is in the foreground, it will get called back to ReceivedLocalNotification
                    // If its not, iOS will display the notification to the user.
                    UIApplication.SharedApplication.PresentLocalNotificationNow (notification);
                }
            };
        }

        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();
            locMan = new CLLocationManager();
            locMan.RequestWhenInUseAuthorization();
            locMan.RequestAlwaysAuthorization();
            // Geocode a city to get a CLCircularRegion,
            // and then use our location manager to set up a geofence
            button.TouchUpInside += (o, e) => {

                // clean up monitoring of old region so they don't pile up
                if(region != null)
                {
                    locMan.StopMonitoring(region);
                }

                // Geocode city location to create a CLCircularRegion - what we need for geofencing!
                var taskCoding = geocoder.GeocodeAddressAsync ("Cupertino");
                taskCoding.ContinueWith ((addresses) => {
                    CLPlacemark placemark = addresses.Result [0];
                    region = (CLCircularRegion)placemark.Region;
                    locMan.StartMonitoring(region);

                });
            };

            // This gets called even when the app is in the background - try it!
            locMan.RegionEntered += (sender, e) => {
                Console.WriteLine("You've entered the region");
            };

            locMan.RegionLeft += (sender, e) => {
                Console.WriteLine("You've left the region");
            };
        }

        public GeolocationSingleUpdateDelegate(CLLocationManager manager, double desiredAccuracy, bool includeHeading, int timeout, CancellationToken cancelToken)
        {
            this.manager = manager;
            this.tcs = new TaskCompletionSource<Position>(manager);
            this.desiredAccuracy = desiredAccuracy;
            this.includeHeading = includeHeading;

            if (timeout != Timeout.Infinite)
            {
                Timer t = null;
                t = new Timer(s =>
                {
                    if (this.haveLocation)
                        this.tcs.TrySetResult(new Position(this.position));
                    else
                        this.tcs.TrySetCanceled();

                    StopListening();
                    t.Dispose();
                }, null, timeout, 0);
            }

            cancelToken.Register(() =>
            {
                StopListening();
                this.tcs.TrySetCanceled();
            });
        }

 public override void LocationsUpdated(CLLocationManager manager, CLLocation[] locations)
 {
     Task.Run (async () =>  {await AppDelegate.FlicService.RefreshPendingConnections();});
     foreach(var loc in locations) {
         Console.WriteLine(loc);
     }
 }

 public LocationTestService()
 {
     locationManager = new CLLocationManager();
     locationManager.LocationsUpdated += LocationsUpdated;
     locationManager.DistanceFilter = 10;
     locationManager.DesiredAccuracy = CLLocation.AccuracyBest;
 }

 public override void UpdatedLocation (CLLocationManager manager, CLLocation newLocation, CLLocation oldLocation)
 {                
     _helper.Locations.Add (newLocation);
     
     if (_helper.LocationAdded != null)
         _helper.LocationAdded (_helper, new LocationEventArgs (newLocation));
 }

		public override void ViewDidLoad ()
		{
			base.ViewDidLoad ();

			locationManager = new CLLocationManager ();
			locationManager.AuthorizationChanged += OnAuthorizationChanged;
			locationManager.LocationsUpdated += OnLocationsUpdated;
			locationManager.DesiredAccuracy = CLLocation.AccuracyBest;
			locationManager.ActivityType = CLActivityType.Other;

			// We setup a pair of anchors that will define how the floorplan image, maps to geographic co-ordinates
			var anchor1 = new GeoAnchor {
				LatitudeLongitude = new CLLocationCoordinate2D (37.770511, -122.465810),
				Pixel = new CGPoint (12, 18)
			};

			var anchor2 = new GeoAnchor {
				LatitudeLongitude = new CLLocationCoordinate2D (37.769125, -122.466356),
				Pixel = new CGPoint (481, 815)
			};

			anchorPair = new Tuple<GeoAnchor, GeoAnchor> (anchor1, anchor2);

			// Initialize the coordinate system converter with two anchor points.
			coordinateConverter = new CoordinateConverter (anchorPair);
		}

        public void StartTimer(CLLocationManager manager)
        {
            hasLastAttempt = false;

            Manager = manager;
            locationTimer = NSTimer.CreateScheduledTimer(TimeSpan.FromSeconds(30), TerminateLocationUpdate);
        }

		public TCLocationManager ()
		{
			locationManager = new CLLocationManager ();

			locationManager.DistanceFilter = 10;
			locationManager.Delegate = new TCLocationDelegate ();
		}

		public override bool FinishedLaunching (UIApplication app, NSDictionary options)
		{
			window = new UIWindow (UIScreen.MainScreen.Bounds);

			var what = new EntryElement ("What ?", "e.g. pizza", String.Empty);
			var where = new EntryElement ("Where ?", "here", String.Empty);

			var section = new Section ();
			if (CLLocationManager.LocationServicesEnabled) {
				lm = new CLLocationManager ();
				lm.LocationsUpdated += delegate (object sender, CLLocationsUpdatedEventArgs e) {
					lm.StopUpdatingLocation ();
					here = e.Locations [e.Locations.Length - 1];
					var coord = here.Coordinate;
					where.Value = String.Format ("{0:F4}, {1:F4}", coord.Longitude, coord.Latitude);
				};
				section.Add (new StringElement ("Get Current Location", delegate {
					lm.StartUpdatingLocation ();
				}));
			}

			section.Add (new StringElement ("Search...", async delegate {
				await SearchAsync (what.Value, where.Value);
			}));

			var root = new RootElement ("MapKit Search Sample") {
				new Section ("MapKit Search Sample") { what, where },
				section
			};
			window.RootViewController = new UINavigationController (new DialogViewController (root, true));
			window.MakeKeyAndVisible ();
			return true;
		}

        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();

            manager = new CLLocationManager ();

            // handle the updated location method and update the UI
            if (UIDevice.CurrentDevice.CheckSystemVersion (6, 0)) {
                manager.LocationsUpdated += LocationsUpdated;
            } else {
                // this won't be called on iOS 6 (deprecated)
                manager.UpdatedLocation += UpdatedLocation;
            }

            if (CLLocationManager.LocationServicesEnabled)
                manager.StartUpdatingLocation ();

            //if (CLLocationManager.HeadingAvailable)
            //	manager.StartUpdatingHeading ();

            mapView.GetViewForAnnotation += GetAirportAnnotationView;
            mapView.RegionChanged += MapRegionChanged;
            mapType.ValueChanged += MapTypeChanged;
            MapTypeChanged (null, null);
        }

        public void LocationManagerDidUpdateToLocationFromLocation(CLLocationManager manager, CLLocation newLocation, CLLocation oldLocation)
        {
            // Ignore updates where nothing we care about changed
            if (oldLocation != null &&
                newLocation.Coordinate.longitude == oldLocation.Coordinate.longitude &&
                newLocation.Coordinate.latitude == oldLocation.Coordinate.latitude &&
                newLocation.HorizontalAccuracy == oldLocation.HorizontalAccuracy)
            {
                return;
            }

            // Load the HTML for displaying the Google map from a file and replace the
            // format placeholders with our location data
            NSError error;
            NSString htmlString = NSString.StringWithFormat(
                NSString.StringWithContentsOfFileEncodingError(
                NSBundle.MainBundle.PathForResourceOfType("HTMLFormatString", @"html"),
                NSStringEncoding.NSUTF8StringEncoding,out error),
                newLocation.Coordinate.latitude,
                newLocation.Coordinate.longitude,
                LatitudeRangeForLocation(newLocation),
                LongitudeRangeForLocation(newLocation));

            // Load the HTML in the WebView and set the labels
            this.webView.MainFrame.LoadHTMLStringBaseURL(htmlString, null);
            this.locationLabel.StringValue = NSString.StringWithFormat("%f, %f",
                                                                       newLocation.Coordinate.latitude, newLocation.Coordinate.longitude);
            this.accuracyLabel.StringValue = NSString.StringWithFormat("%f",
                                                                       newLocation.HorizontalAccuracy);
        }

		public MonitoringViewController (IntPtr handle) : base (handle)
		{
			locationManger = new CLLocationManager ();
			numberFormatter = new NSNumberFormatter () {
				NumberStyle = NSNumberFormatterStyle.Decimal
			};
			uuid = Defaults.DefaultProximityUuid;
		}