iPhone连接MaOS时检测USB

如何解决iPhone连接MaOS时检测USB

这段 Swift 代码效果很好，结果是：

连接 iPhone：Event Matched 断开 iPhone：Event Terminated

import Darwin
import IOKit
import IOKit.usb
import Foundation


class IoUSBDetector {

    enum Event {
        case Matched
        case Terminated
    }

    let vendorID: Int
    let productID: Int

    var callbackQueue: dispatchQueue?

    var callback: (
        ( _ detector: IoUSBDetector,_ event: Event,_ service: io_service_t
        ) -> Void
    )?


    private
    let internalQueue: dispatchQueue

    private
    let notifyPort: IONotificationPortRef

    private
    var matchedIterator: io_iterator_t = 0

    private
    var terminatedIterator: io_iterator_t = 0


    private
    func dispatchEvent (
        event: Event,iterator: io_iterator_t
    ) {
        repeat {
            let nextService = IOIteratorNext(iterator)
            guard nextService != 0 else { break }
            if let cb = self.callback,let q = self.callbackQueue {
                q.async {
                    cb(self,event,nextService)
                    IOObjectRelease(nextService)
                }
            } else {
                IOObjectRelease(nextService)
            }
        } while (true)
    }


    init? ( vendorID: Int,productID: Int ) {
        self.vendorID = vendorID
        self.productID = productID
        self.internalQueue = dispatchQueue(label: "IODetector")

        guard let notifyPort = IONotificationPortCreate(kIOMasterPortDefault) else {
            return nil
        }

        self.notifyPort = notifyPort
        IONotificationPortSetdispatchQueue(notifyPort,self.internalQueue)
    }

    deinit {
        self.stopDetection()
    }


    func startDetection ( ) -> Bool {
        guard matchedIterator == 0 else { return true }

        let matchingDict = IOServiceMatching(kIoUSBDeviceClassName)
            as NSMutableDictionary
        matchingDict[kUSBvendorID] = NSNumber(value: vendorID)
        matchingDict[kUSBProductID] = NSNumber(value: productID)

        let matchCallback: IOServiceMatchingCallback = {
            (userData,iterator) in
                let detector = Unmanaged<IoUSBDetector>
                    .fromOpaque(userData!).takeUnretainedValue()
                detector.dispatchEvent(
                    event: .Matched,iterator: iterator
                )
        };
        let termCallback: IOServiceMatchingCallback = {
            (userData,iterator) in
                let detector = Unmanaged<IoUSBDetector>
                    .fromOpaque(userData!).takeUnretainedValue()
                detector.dispatchEvent(
                    event: .Terminated,iterator: iterator
                )
        };

        let selfPtr = Unmanaged.passUnretained(self).toOpaque()

        let addMatchError = IOServiceAddMatchingNotification(
            self.notifyPort,kIOFirstMatchNotification,matchingDict,matchCallback,selfPtr,&self.matchedIterator
        )
        let addTermError = IOServiceAddMatchingNotification(
            self.notifyPort,kIOTerminatednotification,termCallback,&self.terminatedIterator
        )

        guard addMatchError == 0 && addTermError == 0 else {
            if self.matchedIterator != 0 {
                IOObjectRelease(self.matchedIterator)
                self.matchedIterator = 0
            }
            if self.terminatedIterator != 0 {
                IOObjectRelease(self.terminatedIterator)
                self.terminatedIterator = 0
            }
            return false
        }

        // This is required even if nothing was found to "arm" the callback
        self.dispatchEvent(event: .Matched,iterator: self.matchedIterator)
        self.dispatchEvent(event: .Terminated,iterator: self.terminatedIterator)

        return true
    }


    func stopDetection ( ) {
        guard self.matchedIterator != 0 else { return }
        IOObjectRelease(self.matchedIterator)
        IOObjectRelease(self.terminatedIterator)
        self.matchedIterator = 0
        self.terminatedIterator = 0
    }
}


let test = IoUSBDetector(vendorID: 0x05ac,productID: 0x12a8)
test?.callbackQueue = dispatchQueue.global()
test?.callback = {
    (detector,service) in
        print("Event \(event)")
};
_ = test?.startDetection()
while true { sleep(1) }

这段 Swift 代码效果很好，结果是：

连接 iPhone：Event Matched 断开 iPhone：Event Terminated

如何：如果 iPhone 已连接，则执行一些命令 你能帮我写下命令放在哪里吗？

从 iPhone 获取信息的命令我已经有了，但不知道把它放在哪里

我尝试用

替换print("Event (event)")

if event == Matched { 
} else { 
} 

但不工作