Absolutely! You can definitely pull the wear state (on/off ear detection) data from AirPods Pro or Max. Let’s break down how to do this properly across Apple’s platforms—since that’s where these devices integrate most tightly:

iOS/macOS via AVAudioSession (Recommended & App Store-Safe) #

This is the go-to approach, especially if your app works with audio. It leverages system-level audio session changes that directly tie to AirPods wear detection, and it’s fully compliant with App Store guidelines.

• Step 1: Import the AVFoundation framework
  Start by adding this to your code:

  import AVFoundation
  

• Step 2: Set up a listener for route change notifications
  When you put on or take off AirPods, the system’s audio route changes. You can observe this event and parse the reason to detect wear state:

  func setupAirPodsWearDetection() {
      // Register for route change notifications
      NotificationCenter.default.addObserver(
          self,
          selector: #selector(handleAudioRouteChange(_:)),
          name: AVAudioSession.routeChangeNotification,
          object: AVAudioSession.sharedInstance()
      )
      
      // Activate the audio session to start receiving updates
      do {
          try AVAudioSession.sharedInstance().setActive(true)
      } catch {
          print("Failed to activate audio session: \(error.localizedDescription)")
      }
  }
  
  @objc private func handleAudioRouteChange(_ notification: Notification) {
      guard let userInfo = notification.userInfo,
            let reasonRawValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
            let reason = AVAudioSession.RouteChangeReason(rawValue: reasonRawValue) else {
          return
      }
      
      switch reason {
      case .oldDeviceUnavailable:
          // This usually means AirPods were taken off
          print("AirPods removed from ears")
      case .newDeviceAvailable:
          // This usually means AirPods were put on
          print("AirPods put on ears")
      default:
          // Ignore other route changes (like switching to a speaker)
          break
      }
  }
  

  Pro tip: To confirm the route change is actually from AirPods, you can check the currentRoute or previousRoute in the notification’s user info to verify the device type.

iOS/macOS via CoreBluetooth (For Per-Ear Detection, Not Officially Supported) #

If you need granular per-ear state (left/right ear on/off), you can use CoreBluetooth to connect directly to AirPods and read their proprietary GATT characteristics. Note: Apple doesn’t document these UUIDs, so this relies on reverse-engineered data and may break with OS updates or get your app rejected from the App Store.

• Step 1: Import CoreBluetooth

  import CoreBluetooth
  

• Step 2: Set up scanning and connection logic
  Here’s a simplified outline of how to detect AirPods, connect, and listen for wear state updates:

  class AirPodsWearDetector: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {
      private var centralManager: CBCentralManager!
      private var targetAirPods: CBPeripheral?
      
      override init() {
          super.init()
          centralManager = CBCentralManager(delegate: self, queue: DispatchQueue.main)
      }
      
      func centralManagerDidUpdateState(_ central: CBCentralManager) {
          if central.state == .poweredOn {
              // Scan for Bluetooth LE devices (filter by AirPods name or UUID)
              central.scanForPeripherals(withServices: nil, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
          }
      }
      
      func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
          // Check if the device is AirPods (adjust the name check to match your user's custom name if needed)
          if let deviceName = peripheral.name, deviceName.starts(with: "AirPods") {
              targetAirPods = peripheral
              peripheral.delegate = self
              central.connect(peripheral, options: nil)
              central.stopScan()
          }
      }
      
      func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
          // Discover all services (we're looking for Apple's proprietary AirPods service)
          peripheral.discoverServices(nil)
      }
      
      func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
          guard let services = peripheral.services else { return }
          for service in services {
              // Use the reverse-engineered service UUID for AirPods wear detection
              if service.uuid == CBUUID(string: "0000FE2C-0000-1000-8000-00805F9B34FB") {
                  peripheral.discoverCharacteristics(nil, for: service)
              }
          }
      }
      
      func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
          guard let characteristics = service.characteristics else { return }
          for characteristic in characteristics {
              // Use the reverse-engineered characteristic UUID for wear state
              if characteristic.uuid == CBUUID(string: "00000001-0000-1000-8000-00805F9B34FB") {
                  peripheral.setNotifyValue(true, for: characteristic)
              }
          }
      }
      
      func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
          guard let data = characteristic.value else { return }
          // Parse the raw data (format is reverse-engineered: first byte indicates left/right state)
          let leftEarOn = (data[0] & 0x01) != 0
          let rightEarOn = (data[0] & 0x02) != 0
          print("Left ear: \(leftEarOn ? "On" : "Off"), Right ear: \(rightEarOn ? "On" : "Off")")
      }
  }
  

Key Considerations #

• App Store Safety: Stick with the AVAudioSession method if you plan to submit your app to the App Store. The CoreBluetooth approach uses undocumented APIs/characteristics and risks rejection.
• Pairing Requirement: AirPods must be paired with the iOS/macOS device for either method to work.
• Accuracy: The AVAudioSession method is reliable for general on/off detection, while CoreBluetooth gives you per-ear detail (at the cost of official support).

内容的提问来源于stack exchange，提问作者David Thery