FAQ

<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>We track your location to provide real-time updates</string>

// Choose based on your needs
Radar.startTracking(trackingOptions: .presetContinuous)  // Most frequent
Radar.startTracking(trackingOptions: .presetResponsive)  // Recommended
Radar.startTracking(trackingOptions: .presetEfficient)   // Battery-friendly

let options = RadarTrackingOptions.presetResponsive
options.desiredAccuracy = .high  // or .medium, .low
Radar.startTracking(trackingOptions: options)

let options = RadarTrackingOptions.presetResponsive
options.replay = .all  // Replay all failed updates
// or .stops  // Only replay when stopped
// or .none   // Don't replay failed updates

// One-time tracking (foreground only)
Radar.trackOnce { (status, location, events, user) in
    print("Location: \(location?.coordinate ?? CLLocationCoordinate2D())")
}

func applicationWillEnterForeground(_ application: UIApplication) {
    Radar.startTracking(trackingOptions: .presetResponsive)
}

func applicationDidEnterBackground(_ application: UIApplication) {
    Radar.stopTracking()
}

// Called for EVERY location update, even if not synced
func didUpdateClientLocation(
    _ location: CLLocation,
    stopped: Bool,
    source: RadarLocationSource
) {
    // Use this for UI updates
}

// Called only when location is synced to Radar servers
func didUpdateLocation(_ location: CLLocation, user: RadarUser) {
    // Use this for server-synced state
}

// Called when geofence, place, or trip events occur
func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
    // Handle business logic based on events
}

curl https://api.radar.io/v1/geofences \
  -H "Authorization: prj_live_sk_..." \
  -X POST \
  -d "description=Store #123" \
  -d "tag=store" \
  -d "externalId=store-123" \
  -d "type=circle" \
  -d "coordinates=[[-73.975363,40.783826]]" \
  -d "radius=100"

let options = RadarTrackingOptions.presetResponsive
options.syncGeofences = true  // Enable geofence syncing
Radar.startTracking(trackingOptions: options)

// Search for specific geofences
Radar.searchGeofences(
    near: location,
    radius: 1000,
    tags: ["store"],  // Filter by tag
    metadata: ["region": "west"],  // Filter by metadata
    limit: 10,
    includeGeometry: false
) { (status, location, geofences) in
    // Handle results
}

func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
    for event in events {
        if event.type == .userEnteredGeofence,
           let geofence = event.geofence,
           geofence.tag == "store" {
            // Handle store entry
        }
    }
}

// Configure in dashboard or via API
// Dwell time: 5 minutes

curl https://api.radar.io/v1/geofences \
  -H "Authorization: prj_live_sk_..." \
  -d "metadata[dwellTime]=300"  # 5 minutes in seconds

let tripOptions = RadarTripOptions(
    externalId: "order-12345",  // Your unique trip ID
    destinationGeofenceTag: "store",
    destinationGeofenceExternalId: "store-456"
)
tripOptions.mode = .car
tripOptions.scheduledArrivalAt = Date(timeIntervalSinceNow: 1800)  // 30 min

Radar.startTrip(options: tripOptions) { (status, trip, events) in
    if status == .success {
        print("Trip started: \(trip?._id ?? "")")
    }
}

func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
    for event in events {
        switch event.type {
        case .userApproachingTripDestination:
            sendNotification("Driver is 5 minutes away")
            
        case .userArrivedAtTripDestination:
            sendNotification("Driver has arrived")
            completeOrder()
            
        default:
            break
        }
    }
}

let leg1 = RadarTripLeg(
    externalId: "pickup-1",
    destinationGeofenceTag: "pickup",
    destinationGeofenceExternalId: "location-1"
)

let leg2 = RadarTripLeg(
    externalId: "delivery-1",
    destinationGeofenceTag: "delivery",
    destinationGeofenceExternalId: "location-2"
)

let tripOptions = RadarTripOptions(
    externalId: "route-123",
    destinationGeofenceTag: nil,
    destinationGeofenceExternalId: nil
)
tripOptions.legs = [leg1, leg2]

Radar.startTrip(options: tripOptions) { (status, trip, events) in
    // Trip started with multiple legs
}

// Update leg status as you progress
Radar.updateTripLeg(legId: "pickup-1", status: .completed) { (status, trip, leg, events) in
    print("Pickup completed")
}

// Trip completed successfully
Radar.completeTrip { (status, trip, events) in
    print("Trip completed")
}

// Or cancel the trip
Radar.cancelTrip { (status, trip, events) in
    print("Trip cancelled")
}

let tripTrackingOptions = RadarTrackingOptions.presetResponsive
tripTrackingOptions.desiredMovingUpdateInterval = 60  // 1 minute

Radar.startTrip(
    options: tripOptions,
    trackingOptions: tripTrackingOptions
) { (status, trip, events) in
    // Trip with custom tracking
}

Radar.setAnonymousTrackingEnabled(true)

Radar.setUserId("user-123")  // Optional
Radar.setMetadata(["plan": "premium"])  // Optional
Radar.setAdIdEnabled(false)  // Ad ID disabled by default

curl https://api.radar.io/v1/users/:id \
  -H "Authorization: prj_live_sk_..." \
  -X DELETE

Radar.trackVerified { (status, token) in
    if token?.passed == true {
        // Location verified - allow feature access
        sendToServer(token?.token)  // JWT to verify server-side
    } else {
        // Verification failed - possible fraud
        showError("Unable to verify your location")
    }
}

#if DEBUG
let apiKey = "prj_test_pk_..."
#else
let apiKey = "prj_live_pk_..."
#endif

Radar.initialize(publishableKey: apiKey)

let options = RadarTrackingOptions.presetResponsive

// Only sync stops and exits (fewer API calls)
options.syncLocations = .stopsAndExits

// Or don't sync location updates automatically
options.syncLocations = .none

// Increase sync interval
options.desiredSyncInterval = 300  // 5 minutes

Radar.startTracking(trackingOptions: options)

let options = RadarTrackingOptions.presetResponsive
options.desiredMovingUpdateInterval = 300  // Longer intervals
options.syncLocations = .stopsAndExits     // Sync less frequently