Troubleshooting

// Most frequent updates (~30 seconds)
Radar.startTracking(trackingOptions: .presetContinuous)

// Moderate frequency (~2.5 minutes when moving)
Radar.startTracking(trackingOptions: .presetResponsive)

// Least frequent (only on visits)
Radar.startTracking(trackingOptions: .presetEfficient)

let options = RadarTrackingOptions.presetResponsive
options.desiredStoppedUpdateInterval = 120  // 2 minutes when stopped
options.desiredMovingUpdateInterval = 60    // 1 minute when moving
options.desiredAccuracy = .high             // Use best accuracy
Radar.startTracking(trackingOptions: options)

DispatchQueue.main.async {
    let locationManager = CLLocationManager()
    locationManager.requestWhenInUseAuthorization()
}

let status = CLLocationManager.authorizationStatus()
if status == .denied || status == .restricted {
    // Direct user to Settings app
    if let url = URL(string: UIApplication.openSettingsURLString) {
        UIApplication.shared.open(url)
    }
}

let tripOptions = RadarTripOptions(
    externalId: "trip-123",  // Must be unique
    destinationGeofenceTag: "store",
    destinationGeofenceExternalId: "store-456"
)
tripOptions.mode = .car

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

if !Radar.isTracking() {
    print("Need to start tracking first")
    Radar.startTracking(trackingOptions: .presetResponsive)
}

// Or use automatic tracking
let tripOptions = RadarTripOptions(...)
tripOptions.startTracking = true  // Auto-start tracking
Radar.startTrip(options: tripOptions)

class MyRadarDelegate: NSObject, RadarDelegate {
    func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
        for event in events {
            print("Event: \(RadarEvent.stringForType(event.type) ?? "unknown")")
            if let geofence = event.geofence {
                print("Geofence: \(geofence.tag)")
            }
        }
    }
    
    func didUpdateLocation(_ location: CLLocation, user: RadarUser) {
        print("Location updated, user: \(user._id)")
    }
    
    func didUpdateClientLocation(
        _ location: CLLocation,
        stopped: Bool,
        source: RadarLocationSource
    ) {
        print("Client location updated")
    }
    
    func didFail(status: RadarStatus) {
        print("Error: \(Radar.stringForStatus(status))")
    }
    
    func didLog(message: String) {
        print("Radar log: \(message)")
    }
}

// ❌ Delegate will be deallocated
Radar.setDelegate(MyRadarDelegate())

// ✅ Keep a strong reference
class MyViewController: UIViewController {
    let radarDelegate = MyRadarDelegate()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        Radar.setDelegate(radarDelegate)
    }
}

// Configure SSL pinning in initialize options
let options = RadarInitializeOptions()
// Add your SSL pinning configuration here
Radar.initialize(publishableKey: "prj_test_pk_...", options: options)

// Then call trackVerified
Radar.trackVerified { (status, token) in
    if let token = token, token.passed {
        print("Location verified: \(token.token)")
    }
}

Radar.trackVerified(beacons: false, desiredAccuracy: .high) { (status, token) in
    if status != .success {
        print("Verification failed: \(Radar.stringForStatus(status))")
    } else if let token = token {
        print("Passed: \(token.passed)")
        print("Expires: \(token.expiresAt ?? Date())")
    }
}

Radar.trackVerified { (status, token) in
    guard status == .success else {
        // Handle API error
        return
    }
    
    if token?.passed == true {
        // Verification passed
        sendTokenToServer(token?.token)
    } else {
        // Verification failed - may indicate fraud
        showErrorMessage("Location verification failed")
    }
}

// ⚡ Highest battery usage
Radar.startTracking(trackingOptions: .presetContinuous)

// ⚡⚡ Moderate battery usage (recommended)
Radar.startTracking(trackingOptions: .presetResponsive)

// ⚡⚡⚡ Lowest battery usage
Radar.startTracking(trackingOptions: .presetEfficient)

let options = RadarTrackingOptions.presetResponsive
options.desiredMovingUpdateInterval = 300  // 5 minutes
options.desiredStoppedUpdateInterval = 0   // Shut down when stopped
options.desiredAccuracy = .low             // Use lower accuracy
Radar.startTracking(trackingOptions: options)

let options = RadarTrackingOptions.presetResponsive
options.beacons = false          // Disable beacon ranging
options.useIndoorScan = false    // Disable indoor positioning
options.syncGeofences = false    // Disable geofence sync
Radar.startTracking(trackingOptions: options)

func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
    // Initialize Radar first (required)
    Radar.initialize(publishableKey: "prj_test_pk_...")
    
    // Defer tracking start until after UI loads
    DispatchQueue.main.async {
        if CLLocationManager.authorizationStatus() == .authorizedAlways {
            Radar.startTracking(trackingOptions: .presetResponsive)
        }
    }
    
    return true
}

let options = RadarInitializeOptions()
options.autoLogNotificationConversions = false  // If not using notifications
options.autoHandleNotificationDeepLinks = false
Radar.initialize(publishableKey: "prj_test_pk_...", options: options)