expo-location

npx expo install expo-location

// app.config.ts - disclosure strings (required for store review)
export default {
  plugins: [
    [
      "expo-location",
      {
        locationWhenInUsePermission:
          "FieldTrack shows nearby job sites while you use the app.",
        locationAlwaysAndWhenInUsePermission:
          "FieldTrack records visit coordinates in the background so supervisors see arrival times.",
        isIosBackgroundLocationEnabled: true,
        isAndroidBackgroundLocationEnabled: true,
      },
    ],
  ],
};

import * as Location from "expo-location";
 
export async function requestForegroundLocation(): Promise<boolean> {
  const { status } = await Location.requestForegroundPermissionsAsync();
  return status === "granted";
}
 
export async function watchPosition(onUpdate: (loc: Location.LocationObject) => void) {
  const granted = await requestForegroundLocation();
  if (!granted) return null;
 
  return await Location.watchPositionAsync(
    {
      accuracy: Location.Accuracy.Balanced,
      distanceInterval: 25, // meters - reduce churn vs timeInterval alone
      timeInterval: 10_000,
    },
    onUpdate
  );
}

npx expo install expo-location

// src/location/LocationPermissionGate.tsx
import { useState } from "react";
import { Linking, Pressable, Text, View } from "react-native";
import * as Location from "expo-location";
 
type Props = {
  onGranted: () => void;
  needsBackground?: boolean;
};
 
export function LocationPermissionGate({ onGranted, needsBackground }: Props) {
  const [denied, setDenied] = useState(false);
 
  async function request() {
    const fg = await Location.requestForegroundPermissionsAsync();
    if (fg.status !== "granted") {
      setDenied(true);
      return;
    }
 
    if (needsBackground) {
      const bg = await Location.requestBackgroundPermissionsAsync();
      if (bg.status !== "granted") {
        setDenied(true);
        return;
      }
    }
 
    onGranted();
  }
 
  return (
    <View style={{ padding: 24, gap: 12 }}>
      <Text style={{ fontWeight: "600" }}>Location access</Text>
      <Text>
        We attach GPS to inspection photos so disputes resolve with proof of
        on-site presence.
        {needsBackground
          ? " Background access keeps visit logs accurate when you switch apps."
          : ""}
      </Text>
      <Pressable onPress={request}>
        <Text style={{ color: "#2563eb" }}>Continue</Text>
      </Pressable>
      {denied && (
        <Pressable onPress={() => Linking.openSettings()}>
          <Text>Open Settings</Text>
        </Pressable>
      )}
    </View>
  );
}

// src/location/useCurrentPosition.ts
import { useEffect, useState } from "react";
import * as Location from "expo-location";
 
export function useCurrentPosition(enabled: boolean) {
  const [coords, setCoords] = useState<Location.LocationObjectCoords | null>(
    null
  );
 
  useEffect(() => {
    if (!enabled) return;
 
    let subscription: Location.LocationSubscription | null = null;
 
    (async () => {
      subscription = await Location.watchPositionAsync(
        { accuracy: Location.Accuracy.Balanced, distanceInterval: 20 },
        (loc) => setCoords(loc.coords)
      );
    })();
 
    return () => subscription?.remove();
  }, [enabled]);
 
  return coords;
}

// src/location/getOneShotPosition.ts
import * as Location from "expo-location";
 
export async function getOneShotPosition() {
  const { status } = await Location.getForegroundPermissionsAsync();
  if (status !== "granted") return null;
 
  return Location.getCurrentPositionAsync({
    accuracy: Location.Accuracy.Balanced,
  });
}

Accuracy.Highest     → GPS lock, heaviest battery
Accuracy.Balanced    → Default for field apps
Accuracy.Low         → City-level, cheapest

// src/location/geofenceTask.ts - global scope import at entry
import * as Location from "expo-location";
import * as TaskManager from "expo-task-manager";
 
export const GEOFENCE_TASK = "site-geofence";
 
TaskManager.defineTask(GEOFENCE_TASK, ({ data, error }) => {
  if (error) {
    console.error(error);
    return;
  }
  const { eventType, region } = data as Location.GeofencingEvent;
  if (eventType === Location.GeofencingEventType.Enter) {
    console.log("Entered", region.identifier);
  }
});

await Location.startGeofencingAsync(GEOFENCE_TASK, [
  {
    identifier: "warehouse-a",
    latitude: 37.7749,
    longitude: -122.4194,
    radius: 200,
    notifyOnEnter: true,
    notifyOnExit: false,
  },
]);