UWB Find My precise item finder in mobile app

Implementing UWB Find My (Precise Item Search) in Mobile App

AirTag works exactly this way: iPhone with U1 chip guides user with arrow directly to lost item with 10-centimeter precision. This is Precision Finding via UWB, and Apple opened this API for third-party accessories through Find My Network Accessory Program. Similar experience can be implemented in custom app — for tool trackers, medical devices, industrial equipment.

Two Scenarios: Find My Network vs Standalone UWB

Fundamentally different approaches:

Find My Network — tracker registers in Apple Find My network. Any iPhone nearby anonymously reports tracker location to Apple servers. User sees tracker on map in Locator app. Proximity Precision Finding via UWB nearby. Requires: MFi Find My Network Accessory Program (paid, through Apple), specific Bluetooth chip with Apple H2 or compatible.

Standalone UWB search — only when phone and tracker are near. No global tracking via other devices. Requires: UWB chip in tracker (Qorvo DW3000, NXP SR150), NearbyInteraction support on iPhone (U1 chip). Available without MFi program.

For most B2B tasks (finding tools on site, tracking medical equipment in hospital), standalone UWB suits best.

iOS: Precision Finding via NearbyInteraction

import NearbyInteraction
import CoreBluetooth

class ItemFinderSession: NSObject {
    private var niSession: NISession?
    private var currentDistance: Float = 0
    private var currentDirection: SIMD3<Float>?

    func startFinding(accessoryToken: Data, bluetoothId: UUID) {
        niSession = NISession()
        niSession?.delegate = self
        niSession?.delegateQueue = .main

        let config = NINearbyAccessoryConfiguration(
            accessoryData: accessoryToken,
            bluetoothPeerIdentifier: bluetoothId
        )
        niSession?.run(config)
    }
}

extension ItemFinderSession: NISessionDelegate {
    func session(_ session: NISession, didUpdate nearbyObjects: [NINearbyObject]) {
        guard let obj = nearbyObjects.first else { return }

        if let distance = obj.distance {
            currentDistance = distance
            // Update UI: distance to item
            updateDistanceDisplay(meters: distance)
        }

        if let direction = obj.direction {
            currentDirection = direction
            // direction — unit vector in ARKit coordinate space
            // direction.x: left-right, direction.y: up-down, direction.z: forward-back
            updateDirectionalArrow(direction: direction)
        }
    }

    func session(_ session: NISession, didUpdateAlgorithmConvergence convergence: NIAlgorithmConvergence, for object: NINearbyObject?) {
        // convergence.status: .converged / .notConverged([reasons])
        // When notConverged — ask user to move phone
        handleConvergence(convergence.status)
    }
}

convergence.status is critical for UX. UWB algorithm requires several seconds of phone movement to determine direction. If user stands still, direction won't be determined. On .notConverged(.insufficientMovement) show animation "move phone".

Direction Arrow: ARKit vs UIKit

ARKit approach (like AirTag): arrow renders in AR space, anchored to real world. Uses ARWorldTrackingConfiguration + NINearbyObject.direction to compute item position in AR scene. Most immersive UX.

UIKit approach: regular arrow on screen, rotates by compass considering NearbyInteraction direction. Simpler, works without AR initialization.

// UIKit arrow via CMMotionManager + NearbyInteraction direction
func updateArrow(direction: SIMD3<Float>) {
    // Convert UWB vector to screen angle
    let angle = atan2(direction.x, -direction.z) // angle in horizontal plane
    let deviceHeading = motionManager.deviceMotion?.attitude.yaw ?? 0
    let arrowAngle = angle - Float(deviceHeading)
    arrowImageView.transform = CGAffineTransform(rotationAngle: CGFloat(arrowAngle))
}

Distance → vibration intensity: UIImpactFeedbackGenerator(style: .heavy) at < 0.3 m, .medium at 0.3–1 m. Haptic feedback is standard for item search.

Tracker Based on DW3000

For standalone UWB tracker without MFi: Qorvo DWM3001C development module — ready UWB transceiver with BLE for initial handshake. Firmware implements UWB Initiator role, exchanges token via BLE, responds to TWR requests from phone.

On Android: androidx.core.uwb:uwb + custom tracker with FiRa Consortium specification support. Same principles, different API:

val rangingParams = UwbRangingParameters(
    uwbConfigType = UwbRangingParameters.CONFIG_UNICAST_DS_TWR,
    complexChannel = controllerScope.uwbComplexChannel,
    peerDevices = listOf(UwbDevice.createForAddress(trackerUwbAddress)),
    updateRateType = UwbRangingParameters.RANGING_UPDATE_RATE_FREQUENT,
    sessionKeyInfo = sharedSessionKey
)

Timeline

Mobile app with UWB Precision Finding (with UWB tracker available): 1–3 weeks. Tracker firmware development on DW3000 + mobile app: 1–3 months. Cost determined by hardware requirements and device support count.