Explore ARKit 5

// Check device support for geo-tracking
guard ARGeoTrackingConfiguration.isSupported else {
    // Geo-tracking not supported on this device
    return
}

// Check current location is supported for geo-tracking
ARGeoTrackingConfiguration.checkAvailability { (available, error) in
    guard available else {
        // Geo-tracking is not available at this location
        return
    }

    // Run ARSession
    let arView = ARView()
    arView.session.run(ARGeoTrackingConfiguration())
}

// Create Location Anchor and add to session
let coordinate = CLLocationCoordinate2D(latitude: 37.795313, longitude: -122.393792)
let geoAnchor = ARGeoAnchor(name: “Ferry Building”, coordinate: coordinate)
arView.session.add(anchor: geoAnchor)

// Monitor geo-tracking status updates
func session(_ session: ARSession, didChange geoTrackingStatus: ARGeoTrackingStatus) {
    …
}

// Declare coaching view
let coachingOverlay = ARCoachingOverlayView()

// Set up coaching view (assuming ARView already exists)
coachingOverlay.session = self.arView.session
coachingOverlay.delegate = self
coachingOverlay.goal = .geoTracking
     
coachingOverlay.translatesAutoresizingMaskIntoConstraints = false
self.arView.addSubview(coachingOverlay)

NSLayoutConstraint.activate([
    coachingOverlay.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    coachingOverlay.centerYAnchor.constraint(equalTo: view.centerYAnchor),
    coachingOverlay.widthAnchor.constraint(equalTo: view.widthAnchor),
    coachingOverlay.heightAnchor.constraint(equalTo: view.heightAnchor),
])

// Method to compute distance (in meters) between points
func distance(from location: CLLocation) -> CLLocationDistance

func viewDidLoad() {
    // Check device support for app clip code tracking
    guard ARWorldTrackingConfiguration.supportsAppClipCodeTracking else { return }
    
    let worldConfig = ARWorldTrackingConfiguration()
    worldConfig.appClipCodeTrackingEnabled = true
    arSession.run(worldConfig)
}

/// Accessing the URL of an App Clip Code 
override func session(_ session: ARSession, didUpdate anchors: [ARAnchor]) {
    for anchor in anchors {
        guard let appClipCodeAnchor = anchor as? ARAppClipCodeAnchor, appClipCodeAnchor.isTracked else { return }
        
        switch appClipCodeAnchor.urlDecodingState {
        case .decoding:
            displayPlaceholderVisualizationOnTopOf(anchor: appClipCodeAnchor)
        case .failed:
            displayNoURLErrorMessageOnTopOf(anchor: appClipCodeAnchor)
        case .decoded:
            let url = appClipCodeAnchor.url!
            let anchorEntity = AnchorEntity(anchor: appClipCodeAnchor)
            arView.scene.addAnchor(anchorEntity)
            let visualization = AppClipCodeVisualization(url: url, radius: appClipCodeAnchor.radius)
            anchorEntity.addChild(visualization)
          }
    }
}

/// Adding a gesture recognizer for user interaction
func viewDidLoad() {
    initializeARView()
    initializeCoachingOverlays()
        
    // Place sunflower on the ground when the user taps the screen
    let tapGestureRecognizer = UITapGestureRecognizer(
     target: self,
     action: #selector(handleTap(recognizer:)))
    arView.addGestureRecognizer(tapGestureRecognizer)
}

func handleTap(recognizer: UITapGestureRecognizer) {
    let location = recognizer.location(in: arView)
    // Attempt to find a 3D location on a horizontal
    // surface underneath the user's touch location.
    let results = arView.raycast(
      from: location, 
      allowing: .estimatedPlane,
      alignment: .horizontal)
    guard let firstResult = results.first else { return }
    // Fetch the last decoded app clip code URL
    guard let appClipCodeURL = decodedURLs.last else { return }
    // Add an ARAnchor & AnchorEntity at the touch location
    let anchor = ARAnchor(transform: firstResult.worldTransform)
    arView.session.add(anchor: anchor)
    let anchorEntity = AnchorEntity(anchor: anchor)
    arView.scene.addAnchor(anchorEntity)    
    // Download the 3D model associated with this app clip code.
    downloadAndDisplay(appClipCodeURL, on: anchorEntity)
}

// Check if the ultra wide video format is available.
// If so, set it on a face tracking configuration & run the session with that.

let config = ARFaceTrackingConfiguration()
for videoFormat in ARFaceTrackingConfiguration.supportedVideoFormats {
    if videoFormat.captureDeviceType == .builtInUltraWideCamera {
        config.videoFormat = videoFormat
        break
    }
}
session.run(config)