iOS SDK

import UIKit
import RadarSDK

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        Radar.initialize(publishableKey: "prj_test_pk_...")

        return true
    }

}

import UIKit
import RadarSDK
import CoreLocation

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, CLLocationManagerDelegate {

    let locationManager = CLLocationManager()

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        Radar.initialize(publishableKey: "prj_test_pk_...")
        self.locationManager.delegate = self
        self.requestLocationPermissions()

        return true
    }

    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
        self.requestLocationPermissions()
    }

    func requestLocationPermissions() {
        let status = self.locationManager.authorizationStatus

        if status == .notDetermined {
            self.locationManager.requestWhenInUseAuthorization()
        } else if status == .authorizedWhenInUse {
            self.locationManager.requestAlwaysAuthorization()
        }
    }

}

Radar.trackOnce { (status: RadarStatus, location: CLLocation?, events: [RadarEvent]?, user: RadarUser?) in
    // do something with location, events, user
}

Radar.startTracking(trackingOptions: RadarTrackingOptions.presetResponsive)

Radar.isTracking()

Radar.stopTracking()

Radar.startTrip(options: tripOptions, trackingOptions: .presetContinuous) { (status: RadarStatus, trip: RadarTrip?, events: [RadarEvent]?) in
  if status == .success {
    // do something
  } else {
    // handle error
  }
}

// complete trip
Radar.completeTrip()

// cancel trip
Radar.cancelTrip()

Radar.mockTracking(
  origin: CLLocation(latitude: 40.714708, longitude: -74.035807),
  destination: CLLocation(latitude: 40.717410, longitude: -74.053334),
  mode: .car,
  steps: 10,
  interval: 3) { (status: RadarStatus, location: CLLocation?, events: [RadarEvent]?, user: RadarUser?) in
    // do something with location, events, user
}

import UIKit
import RadarSDK

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, RadarDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        Radar.initialize(publishableKey: "prj_test_pk_...")
        Radar.setDelegate(self)

        return true
    }

    func didReceiveEvents(_ events: [RadarEvent], user: RadarUser?) {
        // do something with events, user
    }

    func didUpdateLocation(_ location: CLLocation, user: RadarUser) {
        // do something with location, user
    }

    func didUpdateClientLocation(_ location: CLLocation, stopped: Bool, source: RadarLocationSource) {
        // do something with location, stopped, source
    }

    func didFail(status: RadarStatus) {
        // do something with status
    }

    func didLog(message: String) {
        // print message for debug logs
    }

}

Radar.trackOnce(
  location: location
) { (status: RadarStatus, location: CLLocation?, events: [RadarEvent]?, user: RadarUser?) in
    // do something with location, events, user
}

Radar.setUserId(userId)

Radar.setMetadata(metadata)

Radar.setDescription(description)

Radar.setLogLevel(RadarLogLevel.debug)

import UIKit
import RadarSDK

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, RadarDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        Radar.initialize(publishableKey: "prj_test_pk_...")
        Radar.setDelegate(self)

        return true
    }

  func applicationWillResignActive(_ application: UIApplication) {
    // existing code
    Radar.logResigningActive()
  }

  func applicationDidEnterBackground(_ application: UIApplication) {
    // existing code
    Radar.logBackgrounding()
  }

  func applicationWillTerminate(_ application: UIApplication) {
    // existing code
    Radar.logTermination()
  }
}

Radar.trackOnce(desiredAccuracy: .high, beacons: true) { (status: RadarStatus, location: CLLocation?, events: [RadarEvent]?, user: RadarUser?) in
    // do something with user.beacons
}

let trackingOptions = RadarTrackingOptions.presetResponsive
trackingOptions.beacons = true
Radar.startTracking(trackingOptions: trackingOptions)

Radar.getLocation { (status: RadarStatus, location: CLLocation?, stopped: Bool) in
    // do something with location
}

Radar.getContext { (status: RadarStatus, location: CLLocation?, context: RadarContext?) in
    // do something with context
}

Radar.geocode(
    address: "20 jay st brooklyn ny"
) { (status: RadarStatus, addresses: [RadarAddress]?) in
    // do something with addresses
}

Radar.reverseGeocode(
    location: location
) { (status: RadarStatus, addresses: [RadarAddress]?) in
    // do something with addresses
}

Radar.ipGeocode { (status: RadarStatus, address: RadarAddress, proxy: Bool) in
    // do something with address, proxy
}

Radar.autocomplete(
    query: "brooklyn roasting",
    near: location,
    limit: 10
) { (status: RadarStatus, addresses: [RadarAddress]?) in
  // do something with addresses
}

Radar.searchGeofences(
    near: location,
    radius: 1000, // meters
    tags: ["store"],
    metadata: nil,
    limit: 10
) { (status: RadarStatus, location: CLLocation?, geofences: [RadarGeofence]?) in
  // do something with geofences
}

Radar.searchPlaces(
    near: location,
    radius: 1000, // meters
    chains: ["starbucks"],
    categories: nil,
    groups: nil,
    limit: 10
) { (status: RadarStatus, location: CLLocation?, places: [RadarPlace]?) in
  // do something with places
}

Radar.validateAddress(
    address: address
) { (status: RadarStatus, address: RadarAddress?, result: ValidationResult) in
    // do something with validation result and address
}

Radar.getDistance(
    origin: origin,
    destination: destination,
    modes: [.foot, .car],
    units: .imperial
) { (status: RadarStatus, routes: RadarRoutes?) in
  // do something with routes
}

Radar.getMatrix(
    origins: origins,
    destinations: destinations,
    mode: .car,
    units: .imperial
) { (status: RadarStatus, matrix: RadarRouteMatrix?) in
  // do something with matrix.routeBetween(originIndex:destinationIndex:)
}

Radar.logConversion(
  name: name,
  metadata: metadata,
) { (status: RadarStatus, event: RadarEvent?) in
  // do something with the conversion event
}

// conversion with revenue
Radar.logConversion(
  name: name,
  revenue: revenue,
  metadata: metadata,
) { (status: RadarStatus, event: RadarEvent?) in
  // do something with the conversion event
}

import UIKit
import RadarSDK

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        let radarInitializeOptions = RadarInitializeOptions()
        radarInitializeOptions.autoLogNotificationConversions = true
        Radar.initialize(publishableKey: "prj_test_pk_...", options: radarInitializeOptions)

        return true
    }

}

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse) async {
   Radar.logConversion(response: response) 
}