Xamarin Forms - Get device location every 10 seconds (when app runs in foreground/background)

I passed for that headache in the past, a cross-platform app that update location every x seconds and it should run in the background. I had developed a template in Xamarin Forms that support Background Location Updates, Background permissions, these capabilities need to be adjusted depending on the OS (iOs/Android).

Check my Github repo here

I used Xamarin Essentials and Messaging Center for this purpose. Please let me know if the template works for your needs. Thanks.

You can do it with device timer. The timer will run periodically & will check for location updates and notify if location updated. I have used Xam.Plugins.Notifier to generate local notification on location update.

Here is the code for it :

public partial class MainPage : ContentPage
{
    Location oldLocation = null;
    CancellationTokenSource cts;
    public MainPage()
    {
        InitializeComponent();
        Device.StartTimer(TimeSpan.FromSeconds(10), () =>
        {
            GetCurrentLocation();
            return true;
        });
    }

    protected async override void OnAppearing()
    {
        base.OnAppearing();
        await GetCurrentLocation();
    }

    async Task GetCurrentLocation()
    {
        try
        {
            var request = new GeolocationRequest(GeolocationAccuracy.Medium, TimeSpan.FromSeconds(10));
            cts = new CancellationTokenSource();
            var location = await Geolocation.GetLocationAsync(request, cts.Token);

            if (location != null)
            {
                Debug.WriteLine($"Latitude: {location.Latitude}, Longitude: {location.Longitude}, Altitude: {location.Altitude}");
                if (oldLocation == null)
                {
                    oldLocation = location;
                    map.MoveToRegion(MapSpan.FromCenterAndRadius(
                   new Position(location.Latitude, location.Longitude), Distance.FromMiles(0.3)));
                }
                if (location.Latitude != oldLocation.Latitude || location.Longitude != oldLocation.Longitude)
                {
                    map.MoveToRegion(MapSpan.FromCenterAndRadius(
                   new Position(location.Latitude, location.Longitude), Distance.FromMiles(0.3)));

                    oldLocation = location;
                    double zoomLevel = 0.5;
                    double latlongDegrees = 360 / (Math.Pow(2, zoomLevel));
                    if (map.VisibleRegion != null)
                    {
                        map.MoveToRegion(new MapSpan(map.VisibleRegion.Center, latlongDegrees, latlongDegrees));
                    }

                    var placemarks = await Geocoding.GetPlacemarksAsync(location.Latitude, location.Longitude);
                    var placemark = placemarks?.FirstOrDefault();
                    if (placemark != null)
                    {
                        var geocodeAddress =
                            $"AdminArea:       {placemark.AdminArea}\n" +
                            $"CountryCode:     {placemark.CountryCode}\n" +
                            $"CountryName:     {placemark.CountryName}\n" +
                            $"FeatureName:     {placemark.FeatureName}\n" +
                            $"Locality:        {placemark.Locality}\n" +
                            $"PostalCode:      {placemark.PostalCode}\n" +
                            $"SubAdminArea:    {placemark.SubAdminArea}\n" +
                            $"SubLocality:     {placemark.SubLocality}\n" +
                            $"SubThoroughfare: {placemark.SubThoroughfare}\n" +
                            $"Location :       {placemark.Location}\n" +
                            $"Thoroughfare:    {placemark.Thoroughfare}\n";

                        Debug.WriteLine(geocodeAddress);
                    }
                    
                    CrossLocalNotifications.Current.Show("Location Updated", "You checked in to " + placemark.FeatureName + " " + placemark.Locality + " " + placemark.SubLocality, 101, DateTime.Now.AddSeconds(5));
                }
            }
        }
        catch (FeatureNotSupportedException)
        {
            // Handle not supported on device exception
        }
        catch (FeatureNotEnabledException)
        {
            // Handle not enabled on device exception
        }
        catch (PermissionException)
        {
            // Handle permission exception
        }
        catch (Exception)
        {
            // Unable to get location
        }
    }
}

For Android you can try to start a Service that uses the LocationManager of Android to start listening to Location changes. You can specify a timeinterval and a minimum distance you want to track.

This section helped me fiqure out how to use it. For me it was sending location updates even when the app was suspended (physical device running Android 6.1).

To get the location I made my Service a 'LocationListener' and implemented the ILocationListener-Interface like so:

[Service]
public class TestService : Service, ILocationListener
{
    public override IBinder OnBind(Intent intent)
    {
        return null;
    }


    public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
    {
        // start your location updates with the locationManager here

        return StartCommandResult.Sticky; // remember to return sticky for the service to run when app is suspended
    }


    public override void OnDestroy() { }

    ...

    public void OnLocationChanged(Location location)
    {
        // react to location changes here
    }

    public void OnProviderDisabled(string provider) { }

    public void OnProviderEnabled(string provider) { }

    public void OnStatusChanged(string provider, Availability status, Bundle extras) { }
}

For more information on Backgrounding and how to set up a service read this.

Important to note is that the locationUpdates where not consistantly timed (sometimes took more that 10 seconds), since you just give a minimumTime and the OS processes the Request based on its' capacities. But it wasn't too bad.

Update: this doesnt seem to work for Android 8.0 and above. see here