GPS

Getting Started

GitHub
Downloads

Frameworks

.NET MAUI

Blazor

Operating Systems

Android

iOS

Windows

Web

Packages

GPS, motion activity and geocoding ship in Shiny.Gps; geofencing ships in Shiny.Geofencing. The two are independent, so install only what you use. Shiny.Locations is now a meta-package with no code of its own that references both, so existing apps keep working by updating the version. Every type kept the Shiny.Locations namespace, and Position/Distance moved into Shiny.Core.

Shiny makes realtime background location updates easy on MAUI. A Blazor WebAssembly implementation for foreground GPS in the browser is part of Shiny.Gps too.

Note

While Shiny is built to support background operations, GPS can work in strictly a foreground perspective by simply registering

services.AddGps();

without any GPS delegate.

Platform Notes

Feature	iOS	Android	Windows	Blazor (Web)
Foreground GPS	Full	Full	Full	Full
Background GPS	Full	Full (foreground service)	Not Supported	Not Supported
Geofencing	Full	Full	Not Supported	Not Supported

Caution

Windows only supports foreground GPS. Background location tracking is not available on Windows.

Blazor / Web

The browser does not expose a true background API for location, and there is no geofencing API at all. On Blazor, Shiny.Gps wraps navigator.geolocation and only delivers readings while the page/tab is alive and focused. IGpsDelegate will be invoked, but only while the app is running in the foreground — registering a delegate does not keep the app alive in the background. If you set GpsBackgroundMode.Standard or Realtime on a Blazor request, it will be silently treated as foreground and a warning will be logged. There is no IGeofenceManager implementation on Blazor.

iOS — ask for background access from the thing that needs it

iOS authorization escalates: when in use first, always only as an upgrade, and the system presents that upgrade prompt once. So call RequestAccess with the background request from the feature that actually needs background location — the switch the user just moved — rather than at launch. That is also the only moment you can explain why the dialog is there.

Until 5.5.0 a background RequestAccess that followed a foreground one returned AccessState.Restricted without prompting at all. If you are on an earlier build and your “always” prompt never appears, that is the bug, and upgrading is the fix.

Note that AccessState.Restricted is what when in use reports as when a background request asks about it — it means “granted, but not for what you asked for”, not “blocked”. Treat it as a prompt-able state, not a dead end.

Setup

MAUIBlazor

Changed files

• MyApp/
  • ▸Delegates
    • MyGpsDelegate.cs
  • ▸Platforms
    • ▸Android
      • AndroidManifest.xml
    • ▸iOS
      • Info.plist
      • PrivacyInfo.xcprivacy
  • MauiProgram.cs
  • MyApp.csproj

Delegates/MyGpsDelegate.cs

MyGpsDelegate.csCopy

1using Shiny.Locations;2​3namespace MyApp.Delegates;4​5public partial class MyGpsDelegate : GpsDelegate6{7    public MyGpsDelegate(ILogger<MyGpsDelegate> logger) : base(logger)8    {9        // settings as you need10        // this.MinimumDistance = Distance.FromMeters(200);11        // this.MinimumTime = TimeSpan.FromSeconds(15);12    }13​14    protected override async Task OnGpsReading(GpsReading reading)15    {16    }17}18​19#if ANDROID20public partial class MyGpsDelegate : IAndroidForegroundServiceDelegate21{22    public void Configure(AndroidX.Core.App.NotificationCompat.Builder builder)23    {24        25    }26}27#endif

Blazor WebAssembly Setup

Install Shiny.Gps and register it in your Program.cs - on WebAssembly AddGps() uses the browser Geolocation API:

using Shiny;

var builder = WebAssemblyHostBuilder.CreateDefault(args);
// ...
builder.Services.AddGps();
// or with a (foreground-only) delegate:
builder.Services.AddGps<MyGpsDelegate>();

Then inject IGpsManager into your component just like on MAUI:

@inject IGpsManager GpsService

@code {
    protected override async Task OnInitializedAsync()
    {
        var status = await GpsService.RequestAccess(GpsRequest.Foreground);
        if (status == AccessState.Available)
            await GpsService.StartListener(GpsRequest.Foreground);
    }
}

The first call to RequestAccess will trigger the browser’s permission prompt. A working sample lives at samples/Sample.Blazor/Pages/Gps.razor.

Starting/Stopping the GPS Service

IGpsManager gpsManager; // injected, resolved, etc
var request = GpsRequest.Background; // or GpsRequest.Foreground, GpsRequest.Realtime(true)

var access = await gpsManager.RequestAccess(request);
if (access == AccessState.Available)
    await gpsManager.StartListener(request);

await gpsManager.StopListener();

StartListener throws if a listener is already running. Check gpsManager.CurrentListener == null (or the IsListening() extension) first.

Surviving a process restart

A listener started with GpsBackgroundMode.Standard or Realtime is saved to Shiny’s settings store. When the OS ends the process and the app starts again, Shiny restarts that listener at startup if the request has AutoRestart set (the default), and CurrentListener returns it again. StopListener() clears it. Foreground-only listeners (GpsBackgroundMode.None) are not saved, so they end with the process. If the restart fails, for example because Android won’t allow a Realtime foreground service to start from the background, the saved listener is cleared and a warning is logged.

Observing in the background

First, create the delegate that implements IGpsDelegate

public partial class MyGpsDelegate : Shiny.Locations.IGpsDelegate
{
    public MyGpsDelegate()
    {
        // like all other shiny delegates, dependency injection works here
        // treat this as a singleton
    }


    public Task OnReading(GpsReading reading)
    {
        // do something with the reading
        return Task.CompletedTask;
    }
}

Note

Pay attention to the partial on the delegate above. If you want some more control on the Android side of things, the partial will be needed for the additional setup below

Controlling GPS Notification on Android

#if ANDROID
public partial class MyGpsDelegate : Shiny.IAndroidForegroundServiceDelegate
{
    public void Configure(AndroidX.Core.App.NotificationCompat.Builder builder)
    {
        builder
            .SetContentTitle("MyApp")
            .SetContentText("My App is following you!!")
            .SetSmallIcon(Resource.Mipmap.youricon);
    }
}
#endif

Next, let’s register that with your app builder/hosting/service collection

services.AddGps<MyGpsDelegate>();

Lastly, start it up with a background request. On Android, Realtime runs the foreground service whose notification you configured above.

IGpsManager gpsManager; // injected, resolved, etc
var request = GpsRequest.Realtime(true);

var access = await gpsManager.RequestAccess(request);
if (access == AccessState.Available)
    await gpsManager.StartListener(request);

Stationary Detection

All GPS providers automatically detect when the user is stationary and set GpsReading.IsStationary on each reading before it reaches your delegate or the GpsReadingReceived event.

• iOS 18+ uses native CLLocationUpdater stationary detection provided by the OS.
• iOS legacy and Android use a distance + time threshold algorithm: if the user moves less than a configurable number of meters within a configurable number of seconds, they are marked stationary.

The default thresholds are 10 meters and 30 seconds. You can configure these via the platform-specific request types:

#if ANDROID
var request = new AndroidGpsRequest(
    BackgroundMode: GpsBackgroundMode.Realtime,
    StationaryMetersThreshold: 15,
    StationarySecondsThreshold: 60
);
#elif IOS
var request = new AppleGpsRequest(
    BackgroundMode: GpsBackgroundMode.Realtime,
    StationaryMetersThreshold: 15,
    StationarySecondsThreshold: 60
);
#endif

Then check the reading in your delegate or via the foreground GpsReadingReceived event:

gpsManager.GpsReadingReceived += (sender, reading) =>
{
    if (reading.IsStationary)
    {
        // user is stationary
    }
};

Rx has been removed from Shiny.Locations — GpsReadingReceived is a plain C# event EventHandler<GpsReading>. Remember to -= your handler on disappear/dispose.

Easier Delegate

The platform mechanics don’t always play by the rules for time & distance filters that you may expect especially with a more ‘real time’ setup.
To work around these issues, you can use the GpsDelegate class which will handle the filtering for you.

Minimum Filters (AND)

When both MinimumDistance and MinimumTime are set, both conditions must be met before OnGpsReading fires. If only one is set, that single condition is used.

public class MyGpsDelegate : GpsDelegate
{
    public MyGpsDelegate(ILogger<MyGpsDelegate> logger) : base(logger)
    {
        // BOTH of these must be satisfied for OnGpsReading to fire
        this.MinimumDistance = Distance.FromMeters(200);
        this.MinimumTime = TimeSpan.FromMinutes(1);
    }


    protected override Task OnGpsReading(GpsReading reading)
    {
        // do something with the filtered reading
        return Task.CompletedTask;
    }
}

Maximum Filters (OR, overrides minimums)

MaximumDistance and MaximumTime act as safety nets. If either maximum threshold is crossed, OnGpsReading fires immediately regardless of whether the minimum conditions are met. This ensures readings are never suppressed for too long.

public class MyGpsDelegate : GpsDelegate
{
    public MyGpsDelegate(ILogger<MyGpsDelegate> logger) : base(logger)
    {
        // Both minimums must be met (AND)
        this.MinimumDistance = Distance.FromMeters(200);
        this.MinimumTime = TimeSpan.FromMinutes(1);

        // Either maximum crossed will always fire (OR), overriding minimums
        this.MaximumDistance = Distance.FromKilometers(2);
        this.MaximumTime = TimeSpan.FromMinutes(10);
    }


    protected override Task OnGpsReading(GpsReading reading)
    {
        // do something with the filtered reading
        return Task.CompletedTask;
    }
}

AI Coding Assistant

Claude CodeGitHub Copilot

Step 1 — Add the marketplace:

claude plugin marketplace add shinyorg/skills

Step 2 — Install the plugin:

claude plugin install shiny@shiny

One plugin installs all 48 Shiny skills. Your agent loads only the skill relevant to what you're building, so there's no cost to having them all available.

Step 1 — Add the marketplace:

copilot plugin marketplace add https://github.com/shinyorg/skills

Step 2 — Install the plugin:

copilot plugin install shiny@shiny

One plugin installs all 48 Shiny skills. Your agent loads only the skill relevant to what you're building, so there's no cost to having them all available.

View shiny-locations Skill

Samples

• Main Samples
• GPS Sync