Premiers pas

@capgo/background-geolocation combine un suivi de localisation précis en arrière-plan avec le geofencing natif pour iOS et Android. Utilisez-le pour les zones de livraison, les stores, les chantiers, les campus, les check-ins, les alertes d'itinéraire et tout workflow nécessitant des événements d'entrée ou de sortie, même lorsque la WebView ne tourne pas.

Installer

Vous pouvez utiliser notre configuration assistée par IA pour installer le plugin. Ajoutez les skills Capgo à votre outil d'IA avec la commande suivante :

npx skills add https://github.com/Cap-go/capgo-skills --skill capacitor-plugins

Utilisez ensuite le prompt suivant :

Use the `capacitor-plugins` skill from `Cap-go/capgo-skills` to install the `@capgo/background-geolocation` plugin in my project.

Si vous préférez la configuration manuelle, installez le plugin avec les commandes suivantes, puis suivez les instructions spécifiques à chaque plateforme ci-dessous :

bun add @capgo/background-geolocation
bunx cap sync

Importer

import { BackgroundGeolocation } from '@capgo/background-geolocation';

Démarrage rapide

Demandez la permission de localisation en arrière-plan, lancez les mises à jour avec une notification Android visible par l'utilisateur, et envoyez des correctifs POST vers votre API depuis le code natif.

import { BackgroundGeolocation } from '@capgo/background-geolocation';

await BackgroundGeolocation.requestPermissions({
  permissions: ['location', 'backgroundLocation', 'notification'],
});

await BackgroundGeolocation.start(
  {
    backgroundMessage: 'Tracking delivery route',
    backgroundTitle: 'Location active',
    requestPermissions: true,
    stale: false,
    url: 'https://api.example.com/locations',
    headers: { Authorization: 'Bearer fleet-token' },
    distanceFilter: 25,
  },
  (location, error) => {
    if (error) {
      console.error('Location error', error);
      return;
    }
    if (location) {
      console.log('Fix', location.latitude, location.longitude);
    }
  },
);

Chaque correctif est livré en parallèl’au JavaScript (tant que la WebView est active) et à url avec "source": "native" dans le corps JSON.

Exemple : webhook de geofence

await BackgroundGeolocation.setupGeofencing({
  url: 'https://api.example.com/geofence-hit',
  backgroundLocation: true,
});

Sur Android, déclarez ACCESS_BACKGROUND_LOCATION dans votre manifest lorsque vous avez besoin de POST de geofencing en arrière-plan (voir la section geofencing native ci-dessous).

await BackgroundGeolocation.addGeofence({
  identifier: 'warehouse',
  latitude: 32.7,
  longitude: -117.1,
  radius: 200,
});

Exemple : arrêter le suivi

await BackgroundGeolocation.stop();

Erreurs courantes

• Notification Android: les mises à jour en arrière-plan nécessitent backgroundMessage (and title) so users see why location is active.
• Stale fixes: définissez stale: false when you need GPS fresh fixes only.
• Autorisations: requête backgroundLocation séparément sur les versions Android modernes.

Aperçu de API

start

Pour commencer à écouter les changements de localisation de l'appareil, appelez cette méthode. Une Promise est renvoyée pour indiquer que l'appel est terminé. Le callback sera appelé chaque fois qu'une nouvelle localisation est disponible, ou s'il y a eu une erreur lors de l'appel de cette méthode. Ne vous reposez pas sur le rejet de la promise pour cela.

import { BackgroundGeolocation } from '@capgo/background-geolocation';

await BackgroundGeolocation.start(
  {
    backgroundMessage: "App is using your location in the background",
    backgroundTitle: "Location Service",
    requestPermissions: true,
    stale: false,
    distanceFilter: 10
  },
  (location, error) => {
    if (error) {
      console.error('Location error:', error);
      return;
    }
    if (location) {
      console.log('New location:', location.latitude, location.longitude);
    }
  }
);

stop

Arrête les mises à jour de localisation.

import { BackgroundGeolocation } from '@capgo/background-geolocation';

await BackgroundGeolocation.stop();

openSettings

Ouvre la page des paramètres de localisation de l'appareil. Utile pour diriger les utilisateurs vers l'activation des services de localisation ou l'ajustement des permissions.

import { BackgroundGeolocation } from '@capgo/background-geolocation';

// Direct user to location settings
await BackgroundGeolocation.openSettings();

setPlannedRoute

Joue un fichier sonore lorsque l'utilisateur s'écarte de l'itinéraire prévu. À utiliser pour jouer un son (également en arrière-plan, uniquement pour le natif).

import { BackgroundGeolocation } from '@capgo/background-geolocation';

await BackgroundGeolocation.setPlannedRoute({
  soundFile: "notification.mp3",
  route: [[-74.0060, 40.7128], [-118.2437, 34.0522]]
});

Geofencing natif

Le geofencing s'exécute dans la couche native, ce qui permet à iOS et Android de déclencher les événements d'entrée et de sortie sans dépendre de la WebView pour rester active. Configurez une URL de webhook HTTP ou HTTPS lorsque votre backend doit recevoir les transitions même lorsque l'interface de l'application est suspendue.

import { BackgroundGeolocation } from '@capgo/background-geolocation';

await BackgroundGeolocation.setupGeofencing({
  url: 'https://api.example.com/geofences',
  notifyOnEntry: true,
  notifyOnExit: true,
  payload: { userId: '123' },
});

await BackgroundGeolocation.addGeofence({
  identifier: 'store-42',
  latitude: 37.33182,
  longitude: -122.03118,
  radius: 150,
  payload: { storeId: '42' },
});

const handle = await BackgroundGeolocation.addListener(
  'geofenceTransition',
  (event) => {
    console.log(event.identifier, event.transition);
  },
);

const errorHandle = await BackgroundGeolocation.addListener(
  'geofenceError',
  (event) => {
    console.error(event.identifier, event.message);
  },
);

const { regions } = await BackgroundGeolocation.getMonitoredGeofences();
console.log(regions);

await BackgroundGeolocation.removeGeofence({ identifier: 'store-42' });
await handle.remove();
await errorHandle.remove();

Sur iOS, le geofencing nécessite l'autorisation de localisation « Always ». Sur Android 10 et versions ultérieures, ajoutez la permission de localisation en arrière-plan à votre manifeste d'application lorsque vous avez besoin du geofencing en arrière-plan :

<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

Référence de type

StartOptions

Les options pour configurer les mises à jour de localisation.

export interface StartOptions {
  /**
   * If the "backgroundMessage" option is defined, the plugin will
   * provide location updates whether the app is in the background or the
   * foreground. If it is not defined, location updates are only
   * guaranteed in the foreground. This is true on both platforms.
   *
   * On Android, a notification must be shown to continue receiving
   * location updates in the background. This option specifies the text of
   * that notification.
   *
   * @since 7.0.9
   * @example "Getting your location to provide better service"
   */
  backgroundMessage?: string;
  /**
   * The title of the notification mentioned above.
   *
   * @since 7.0.9
   * @default "Using your location"
   * @example "Location Service"
   */
  backgroundTitle?: string;
  /**
   * Whether permissions should be requested from the user automatically,
   * if they are not already granted.
   *
   * @since 7.0.9
   * @default true
   * @example
   * // Auto-request permissions
   * requestPermissions: true
   *
   * // Don't auto-request, handle manually
   * requestPermissions: false
   */
  requestPermissions?: boolean;
  /**
   * If "true", stale locations may be delivered while the device
   * obtains a GPS fix. You are responsible for checking the "time"
   * property. If "false", locations are guaranteed to be up to date.
   *
   * @since 7.0.9
   * @default false
   * @example
   * // Allow stale locations for faster initial response
   * stale: true
   *
   * // Only fresh locations
   * stale: false
   */
  stale?: boolean;
  /**
   * The distance in meters that the device must move before a new location update is triggered.
   * This is used to filter out small movements and reduce the number of updates.
   *
   * @since 7.0.9
   * @default 0
   * @example
   * // Update every 10 meters
   * distanceFilter: 10
   *
   * // Update on any movement
   * distanceFilter: 0
   */
  distanceFilter?: number;
}

Location

Représente une localisation géographique avec divers attributs. Contient toutes les propriétés de localisation standards renvoyées par les fournisseurs GPS/réseau.

export interface Location {
  /**
   * Latitude in degrees.
   * Range: -90.0 to +90.0
   *
   * @since 7.0.0
   * @example 40.7128
   */
  latitude: number;
  /**
   * Longitude in degrees.
   * Range: -180.0 to +180.0
   *
   * @since 7.0.0
   * @example -74.0060
   */
  longitude: number;
  /**
   * Radius of horizontal uncertainty in metres, with 68% confidence.
   * Lower values indicate more accurate location.
   *
   * @since 7.0.0
   * @example 5.0
   */
  accuracy: number;
  /**
   * Metres above sea level (or null if not available).
   *
   * @since 7.0.0
   * @example 10.5
   */
  altitude: number | null;
  /**
   * Vertical uncertainty in metres, with 68% confidence (or null if not available).
   *
   * @since 7.0.0
   * @example 3.0
   */
  altitudeAccuracy: number | null;
  /**
   * `true` if the location was simulated by software, rather than GPS.
   * Useful for detecting mock locations in development or testing.
   *
   * @since 7.0.0
   * @example false
   */
  simulated: boolean;
  /**
   * Deviation from true north in degrees (or null if not available).
   * Range: 0.0 to 360.0
   *
   * @since 7.0.0
   * @example 45.5
   */
  bearing: number | null;
  /**
   * Speed in metres per second (or null if not available).
   *
   * @since 7.0.0
   * @example 2.5
   */
  speed: number | null;
  /**
   * Time the location was produced, in milliseconds since the unix epoch.
   * Use this to check if a location is stale when using stale: true.
   *
   * @since 7.0.0
   * @example 1640995200000
   */
  time: number | null;
}

CallbackError

Objet d'erreur qui peut être passé au callback de démarrage de la localisation. Étend l'objet Error standard avec des codes d'erreur optionnels.

export interface CallbackError extends Error {
  /**
   * Optional error code for more specific error handling.
   *
   * @since 7.0.0
   * @example "PERMISSION_DENIED"
   */
  code?: string;
}

SetPlannedRouteOptions

export interface SetPlannedRouteOptions {
  /**
   * The name of the sound file to play.
   * Must be a valid sound relative path in the app's public folder to work for both web and native platforms.
   * There's no need to include the public folder in the path.
   * @since 7.0.10
   * @example "notification.mp3"
   * */
  soundFile: string;
  /**
   * The planned route as an array of longitude and latitude pairs.
   * Each pair represents a point on the route.
   * This is used to define a route that the user can follow.
   * The route is used to play a sound when the user deviates from it.
   * @since 7.0.11
   * @example [[-74.0060, 40.7128], [-118.2437, 34.0522]]
   */
  route: [number, number][];

  /**
   * The distance in meters that the user must deviate from the planned route to trigger the sound.
   * This is used to determine how far off the route the user can be before the sound is played.
   * If not specified, a default value of 50 meters is used.
   * @since 7.0.11
   * @default 50
   * @example 50
   */
  distance: number;
}

Source de vérité

Cette page est générée à partir du src/definitions.ts. Relancez la synchronisation lorsque l’API public change en amont.

Continuer depuis Getting Started

Si vous utilisez Premiers pas pour planifier le travail sur un plugin natif, connectez-l’à Utiliser @capgo/background-geolocation pour la capacité native dans l'utilisation de @capgo/background-geolocation, Répertoire des plugins Capgo pour le workflow produit dans le répertoire des plugins Capgo, Plugins Capacitor par Capgo pour les détails d'implémentation dans les plugins Capacitor par Capgo, Ajouter ou mettre à jour des plugins pour les détails d'implémentation dans « Ajouter ou mettre à jour des plugins », et Alternatives aux plugins Ionic Enterprise pour le workflow produit dans les alternatives aux plugins Ionic Enterprise.