logo标签列表

如何调用IOCFPlugInInterface.QueryInterface()来查询USB设备。

swiftiokit
3
我希望将这个USB检测器转换为Swift 3 https://gist.github.com/zachbadgett/471d72e83fee413d0f38 但是我卡在这一行：
let deviceInterfaceResult = plugInInterface.QueryInterface(
        plugInInterfacePtrPtr,
        CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID),
&deviceInterfaceVoidPtr)

无法调用非函数类型的值'(@convention(c) (UnsafeMutableRawPointer?, REFIID, UnsafeMutablePointer?) -> HRESULT)!'

enter image description here

源 QueryInterface：

public var QueryInterface: (@convention(c) (UnsafeMutableRawPointer?, REFIID, UnsafeMutablePointer<LPVOID?>?) -> HRESULT)!

我该如何调用这个函数？在Swift中使用CFNotificationCallback，或者，在Swift中使用@convention(c)块 这个答案对我没有帮助。
@JAL ```let deviceInterfaceResult:HRESULT = {(_: plugInInterfacePtrPtr, _: CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), _: &deviceInterfaceVoidPtr) -> HRESULT in }()``` 没有起作用。 - Arti
2个回答
3
Cœur的答案非常接近。 plugInInterface.QueryInterface() 的最后一个参数期望是一个双重间接指针的地址。
UnsafeMutablePointer<UnsafeMutablePointer<IOUSBDeviceInterface>?>?

但它被“伪装”成指向LPVOID?，也就是UnsafeMutableRawPointer的指针。 因此，必须对获取的指针进行两次解引用。 可以使用withMemoryRebound()进行指针转换。
我对代码进行了一些更改：
  • 使用defer继续下一个USB设备的操作，即使由于错误而“中止”当前迭代。
  • 删除不必要的类型注释。
  • 使用MemoryLayout<io_name_t>.size代替128。
  • 在使用后释放usbDevice和接口指针，以避免内存泄漏。
  • 将一些变量声明从顶部移到需要它们的位置。
把它们整合起来：
import Foundation
import IOKit
import IOKit.usb
import IOKit.usb.IOUSBLib

print("Scanning USB Bus.....\n\n\n")

//
// These constants are not imported into Swift from IOUSBLib.h as they
// are all #define constants
//

let kIOUSBDeviceUserClientTypeID = CFUUIDGetConstantUUIDWithBytes(kCFAllocatorDefault,
                                                                  0x9d, 0xc7, 0xb7, 0x80, 0x9e, 0xc0, 0x11, 0xD4,
                                                                  0xa5, 0x4f, 0x00, 0x0a, 0x27, 0x05, 0x28, 0x61)

let kIOCFPlugInInterfaceID = CFUUIDGetConstantUUIDWithBytes(kCFAllocatorDefault,
                                                            0xC2, 0x44, 0xE8, 0x58, 0x10, 0x9C, 0x11, 0xD4,
                                                            0x91, 0xD4, 0x00, 0x50, 0xE4, 0xC6, 0x42, 0x6F)

let kIOUSBDeviceInterfaceID = CFUUIDGetConstantUUIDWithBytes(kCFAllocatorDefault,
                                                             0x5c, 0x81, 0x87, 0xd0, 0x9e, 0xf3, 0x11, 0xD4,
                                                             0x8b, 0x45, 0x00, 0x0a, 0x27, 0x05, 0x28, 0x61)


// Create dictionary with IOUSBDevice as IOProviderClass.
let matchingDictionary: NSMutableDictionary = IOServiceMatching(kIOUSBDeviceClassName)

// Get iterator for matching USB devices.
var usbIterator = io_iterator_t()
let matchingServicesResult = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDictionary, &usbIterator)
if matchingServicesResult != kIOReturnSuccess {
    print("Error getting deviceList!")
    exit(EXIT_FAILURE)
}

// Iterate devices until usbDevice == 0.
var usbDevice = IOIteratorNext(usbIterator)
while usbDevice != 0 {
    defer {
        usbDevice = IOIteratorNext(usbIterator)
    }

    // io_name_t imports to Swift as a tuple (Int8, ..., Int8) with 128 ints
    // although in device_types.h it is defined as
    //      typedef char io_name_t[128];
    var deviceNameCString = [CChar](repeating: 0, count: MemoryLayout<io_name_t>.size)
    let deviceNameResult = IORegistryEntryGetName(usbDevice, &deviceNameCString)
    if deviceNameResult != kIOReturnSuccess {
        print("Error getting device name")
        continue
    }
    let deviceName = String(cString: &deviceNameCString)
    print("USB device name: \(deviceName)")

    // Get plug-in interface for current USB device
    var plugInInterfacePtrPtr: UnsafeMutablePointer<UnsafeMutablePointer<IOCFPlugInInterface>?>?
    var score: Int32 = 0
    let plugInInterfaceResult = IOCreatePlugInInterfaceForService(
        usbDevice,
        kIOUSBDeviceUserClientTypeID,
        kIOCFPlugInInterfaceID,
        &plugInInterfacePtrPtr,
        &score)

    // USB device object is no longer needed.
    IOObjectRelease(usbDevice)

    // Dereference pointer for the plug-in interface
    guard plugInInterfaceResult == kIOReturnSuccess,
        let plugInInterface = plugInInterfacePtrPtr?.pointee?.pointee else {
            print("Unable to get Plug-In Interface")
            continue
    }

    // Use plug-in interface to get a device interface.
    var deviceInterfacePtrPtr: UnsafeMutablePointer<UnsafeMutablePointer<IOUSBDeviceInterface>?>?
    let deviceInterfaceResult = withUnsafeMutablePointer(to: &deviceInterfacePtrPtr) {
        $0.withMemoryRebound(to: Optional<LPVOID>.self, capacity: 1) {
            plugInInterface.QueryInterface(
                plugInInterfacePtrPtr,
                CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID),
                $0)
        }
    }

    // Plug-in interface is no longer needed.
    _ = plugInInterface.Release(plugInInterfacePtrPtr)

    // Dereference pointer for the device interface.
    guard deviceInterfaceResult == kIOReturnSuccess,
        let deviceInterface = deviceInterfacePtrPtr?.pointee?.pointee else {
            print("Unable to get Device Interface")
            continue
    }

    // Use device interface to get vendor ID.
    var usbVendorID: UInt16 = 0
    let vendorResult = deviceInterface.GetDeviceVendor(deviceInterfacePtrPtr, &usbVendorID)

    // Device interface is no longer needed:
    _ = deviceInterface.Release(deviceInterfacePtrPtr)

    if vendorResult != kIOReturnSuccess {
        print("Unable to get device Vendor ID")
        continue
    }

    print("USB Vendor ID: \(usbVendorID)")
}

exit(EXIT_SUCCESS)
@Arti：不用谢。我已经再次编辑了代码以修复一些内存泄漏问题。我还修改了您的问题标题，"@convention(c)" 对于这个问题并不是很相关。 - Martin R
2

我不知道是否完全正确，但是这个可以在Swift 3和Xcode 8.0下构建。关键是要写 var deviceInterfaceVoidPtr: UnsafeMutableRawPointer? = nil。

import IOKit
import IOKit.usb
import IOKit.usb.IOUSBLib

print("Scanning USB Bus.....\n\n\n")

//
// These constants are not imported into Swift from IOUSBLib.h as they
// are all #define constants
//

let kIOUSBDeviceUserClientTypeID:   CFUUID = CFUUIDGetConstantUUIDWithBytes(kCFAllocatorDefault,
                                                                        0x9d, 0xc7, 0xb7, 0x80, 0x9e, 0xc0, 0x11, 0xD4,
                                                                        0xa5, 0x4f, 0x00, 0x0a, 0x27, 0x05, 0x28, 0x61)

let kIOCFPlugInInterfaceID:         CFUUID = CFUUIDGetConstantUUIDWithBytes(kCFAllocatorDefault,
                                                                        0xC2, 0x44, 0xE8, 0x58, 0x10, 0x9C, 0x11, 0xD4,
                                                                        0x91, 0xD4, 0x00, 0x50, 0xE4, 0xC6, 0x42, 0x6F)

let kIOUSBDeviceInterfaceID:        CFUUID = CFUUIDGetConstantUUIDWithBytes(kCFAllocatorDefault,
                                                                        0x5c, 0x81, 0x87, 0xd0, 0x9e, 0xf3, 0x11, 0xD4,
                                                                        0x8b, 0x45, 0x00, 0x0a, 0x27, 0x05, 0x28, 0x61)

var usbIterator:    io_iterator_t   = io_iterator_t()
var usbDevice:      io_service_t    = io_service_t()
var usbVendorID:    UInt16          = 0
var score:          Int32           = 0

func ptrFromAddress<T>(_ p: UnsafeMutablePointer<T>) -> UnsafeMutablePointer<T> {
    return p
}
var myInterface:IOCFPlugInInterface = IOCFPlugInInterface()
var plugInInterfacePtr: UnsafeMutablePointer<IOCFPlugInInterface>? = ptrFromAddress(&myInterface)
var plugInInterfacePtrPtr: UnsafeMutablePointer<UnsafeMutablePointer<IOCFPlugInInterface>?>? = ptrFromAddress(&plugInInterfacePtr)

// From: CFPlugInCOM.h: public typealias LPVOID =  UnsafeMutablePointer<Void>()
var deviceInterfaceVoidPtr: UnsafeMutableRawPointer? = nil

// create dictionary with IOUSBDevice as IOProviderClass
let matchingDictionary: NSMutableDictionary = IOServiceMatching(kIOUSBDeviceClassName)

// get iterator for matching USB devices
let matchingServicesResult = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDictionary, &usbIterator)
if matchingServicesResult != kIOReturnSuccess {
    print("Error getting deviceList!")
    exit(EXIT_FAILURE)
}

// usbDevice = 0 when finished iterating all devices
repeat {
    usbDevice = IOIteratorNext(usbIterator)
    // io_name_t imports to swift as a tuple (Int8, ..., Int8) 128 ints
    // although in device_types.h it's defined:
    // typedef  char io_name_t[128];
    var deviceNameCString: [CChar] = [CChar](repeating: 0, count: 128)
    let deviceNameResult = IORegistryEntryGetName(usbDevice, &deviceNameCString)

    if deviceNameResult != kIOReturnSuccess {
        print("Error getting device name")
        exit(EXIT_FAILURE)
    }

    let deviceName = String(cString: &deviceNameCString)
    print("usb Device Name: \(deviceName)")

    // Get plugInInterface for current USB device
    let plugInInterfaceResult = IOCreatePlugInInterfaceForService(
        usbDevice,
        kIOUSBDeviceUserClientTypeID,
        kIOCFPlugInInterfaceID,
        &plugInInterfacePtrPtr,
        &score)

    if (plugInInterfacePtrPtr == nil) || (plugInInterfaceResult != kIOReturnSuccess) {
        print("Unable to get Plug-In Interface")
        continue
    }

    // dereference pointer for the plug in interface
    let plugInInterface: IOCFPlugInInterface = plugInInterfacePtrPtr!.pointee!.pointee

    // use plug in interface to get a device interface
    // public var QueryInterface: (@convention(c) (UnsafeMutablePointer<Void>, REFIID, UnsafeMutablePointer<LPVOID>) -> HRESULT)!

    let deviceInterfaceResult = plugInInterface.QueryInterface(
        plugInInterfacePtrPtr,
        CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID),
        &deviceInterfaceVoidPtr)

    if (deviceInterfaceResult != kIOReturnSuccess) || (deviceInterfaceVoidPtr == nil) {
        print("Unable to get Device Interface")
        exit(EXIT_FAILURE)
    }

    // dereference the IOUSBDeviceInterface struct from pointer var after
    // converting from a void to a IOUSBDeviceInterface pointer
    let opaquePtr = OpaquePointer(deviceInterfaceVoidPtr!)
    let deviceInterface = UnsafeMutablePointer<IOUSBDeviceInterface>(opaquePtr).pointee

    // get USB Vendor ID --> CRASH
    let vendorResult = deviceInterface.GetDeviceVendor(deviceInterfaceVoidPtr!, &usbVendorID)

    if vendorResult != kIOReturnSuccess {
        print("Unable to get Device Vendor ID")
        exit(EXIT_FAILURE)
    }

    print("usb Vendor ID: \(usbVendorID)")

    usbDevice = IOIteratorNext(usbIterator)
} while (usbDevice != 0)

exit(EXIT_SUCCESS)

另外，请注意根据cellininicholas的gist评论，您应该删除两个出现中的一个。
usbDevice = IOIteratorNext(usbIterator)
哦，真是遗憾。我忘记导入 IOKit，所以我遇到了很多麻烦。 - Arti
我在这里遇到了崩溃：// 获取USB供应商ID --> 崩溃 let vendorResult = deviceInterface.GetDeviceVendor(deviceInterfaceVoidPtr!, &usbVendorID) - Arti
好的，我想这个崩溃是在原始的Gist中。让我们为Martin更好的回答表示赞赏。 :) - Cœur
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接