Geofencing

Getting Started

GitHub
Downloads

Operating Systems

Android

iOS

Windows

Not available on Blazor / Web

Browsers do not expose a geofencing API, so geofencing is not available in Shiny.Locations.Blazor. If you need region-entry behavior on the web, do the work server-side: have the client report GPS while it is in the foreground and evaluate regions on your backend, then notify the user via Web Push (Shiny.Push.Blazor).

Geofencing lets your app react when a user enters or exits a geographic area — even when the app is not running. Unlike GPS tracking, geofencing is managed by the operating system and is highly battery efficient, making it ideal for location-triggered background tasks.

Platform Notes

Feature	Android	iOS	Windows
Max Regions	60	20	Unlimited
Background Support	Yes	Yes	Yes
Google Play Fallback	GPS-direct when unavailable	N/A	N/A

Region Limits

Each platform enforces a maximum number of simultaneously monitored geofence regions. Android supports up to 60, iOS supports up to 20, and Windows has no limit. If you need to monitor more regions than the platform allows, consider using Spatial Geofencing which has no region limits.

Android Emulator Testing

Testing geofences on the Android emulator can be unreliable. When Google Play Services is available, Shiny uses the native geofencing API which has known issues with emulated locations. You may need to run Google Maps in the background for the emulated position tool to work properly. For reliable testing, use a physical device.

Setup

Changed files

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

Delegates/MyGeofenceDelegate.cs

MyGeofenceDelegate.csCopy

1using Shiny.Locations;2​3namespace MyApp.Delegates;4​5public partial class MyGeofenceDelegate : IGeofenceDelegate6{7    public MyGeofenceDelegate()8    {9    }10​11    public Task OnStatusChanged(GeofenceState newStatus, GeofenceRegion region)12    {13        throw new NotImplementedException();14    }15}16​17#if ANDROID18public partial class MyGeofenceDelegate : IAndroidForegroundServiceDelegate19{20    public void Configure(AndroidX.Core.App.NotificationCompat.Builder builder)21    {22        23    }24}25#endif

Creating Your Delegate

Implement IGeofenceDelegate to handle geofence enter/exit events. This delegate fires in the background when a boundary is crossed.

public class MyGeofenceDelegate : IGeofenceDelegate
{
    readonly ILogger<MyGeofenceDelegate> logger;

    // Full dependency injection support - treat as a singleton
    public MyGeofenceDelegate(ILogger<MyGeofenceDelegate> logger)
    {
        this.logger = logger;
    }

    public async Task OnStatusChanged(GeofenceState newStatus, GeofenceRegion region)
    {
        if (newStatus == GeofenceState.Entered)
        {
            this.logger.LogInformation("Entered region: {Region}", region.Identifier);
            // send a notification, sync data, trigger an action, etc.
        }
        else if (newStatus == GeofenceState.Exited)
        {
            this.logger.LogInformation("Exited region: {Region}", region.Identifier);
        }
    }
}

iOS Background Time

On iOS, your delegate has approximately 4 seconds of execution time (including DI initialization). Keep your processing fast or offload heavy work to a Job.

Using the Geofence Manager

Inject IGeofenceManager to manage geofence regions at runtime.

Requesting Permission

Always request access before starting monitoring:

IGeofenceManager geofenceManager; // injected

var access = await geofenceManager.RequestAccess();
if (access != AccessState.Available)
{
    // Handle denied/restricted - show user messaging
    return;
}

Starting & Stopping Monitoring

// Start monitoring a region
await geofenceManager.StartMonitoring(new GeofenceRegion(
    "work",
    new Position(43.6532, -79.3832),  // latitude, longitude
    Distance.FromMeters(200)           // radius
));

// Stop monitoring a specific region
await geofenceManager.StopMonitoring("work");

// Stop monitoring all regions
await geofenceManager.StopAllMonitoring();

If you re-register the same regions on every launch, use TryStartMonitoring to avoid duplicates. It only starts monitoring when a region with that identifier isn’t already monitored, and — when replaceIfExists is true (the default) — stops and restarts an existing region so changed position or notification settings take effect. It returns true if the region already existed, false if it was newly added.

var region = new GeofenceRegion(
    "work",
    new Position(43.6532, -79.3832),
    Distance.FromMeters(200)
);

// Idempotent: safe to call repeatedly without duplicating or throwing
bool alreadyExisted = await geofenceManager.TryStartMonitoring(region);

// Add without replacing an existing region of the same identifier
await geofenceManager.TryStartMonitoring(region, replaceIfExists: false);

GeofenceRegion Options

var region = new GeofenceRegion(
    Identifier: "coffee-shop",
    Center: new Position(43.6532, -79.3832),
    Radius: Distance.FromMeters(100),
    SingleUse: false,       // true = auto-remove after first trigger
    NotifyOnEntry: true,    // fire delegate on enter
    NotifyOnExit: true      // fire delegate on exit
);

Parameter	Type	Default	Description
Identifier	string	required	Unique ID for the region
Center	Position	required	Latitude/longitude of the circle center
Radius	Distance	required	Radius of the circular geofence
SingleUse	bool	false	Automatically stop monitoring after first trigger
NotifyOnEntry	bool	true	Fire delegate when entering the region
NotifyOnExit	bool	true	Fire delegate when exiting the region

Querying State

// Get all currently monitored regions
var regions = geofenceManager.GetMonitorRegions();

// Request the current state of a region (inside or outside)
var state = await geofenceManager.RequestState(region);
// GeofenceState.Entered, GeofenceState.Exited, or GeofenceState.Unknown

// Check current permission status without prompting
var status = geofenceManager.CurrentStatus;

GPS-Direct Geofencing

By default, AddGeofencing uses the native OS geofencing APIs. On Android, if Google Play Services is unavailable, Shiny automatically falls back to GPS-direct geofencing.

You can also explicitly opt into GPS-direct mode:

services.AddGpsDirectGeofencing<MyGeofenceDelegate>();

Battery Impact

GPS-direct geofencing runs the GPS in realtime background mode which is significantly more battery intensive than native OS geofencing. Only use this when native geofencing is unavailable or when your app already requires continuous GPS tracking.

How It Works

Shiny handles all the platform complexity behind a single API:

• Android: Uses Google Play Services geofencing when available, falls back to GPS-direct otherwise
• iOS 18+: Uses the modern CLMonitor API
• iOS < 18: Uses the legacy CLLocationManager region monitoring API
• Windows: Uses Windows.Devices.Geolocation.Geofencing

Monitored regions are automatically persisted and restored on app restart — you don’t need to re-register them.

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-client@shiny

Step 1 — Add the marketplace:

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

Step 2 — Install the plugin:

copilot plugin install shiny-client@shiny

View shiny-client Plugin

Samples

• Main Samples