Android support via fileDescriptor

fakelibusb_devices.go

@@ -16,9 +16,10 @@ package gousb
 
 // fake devices connected through the fakeLibusb stack.
 type fakeDevice struct {
-	devDesc *DeviceDesc
-	strDesc map[int]string
-	alt     uint8
+	devDesc   *DeviceDesc
+	strDesc   map[int]string
+	alt       uint8
+	sysDevPtr uintptr
 }
 
 var fakeDevices = []fakeDevice{
@@ -64,6 +65,7 @@ var fakeDevices = []fakeDevice{
 				}},
 			}},
 		},
+		sysDevPtr: 78,
 	},
 	// Bus 001 Device 002: ID 8888:0002
 	// One config, two interfaces. interface #0 with no endpoints,
@@ -186,6 +188,7 @@ var fakeDevices = []fakeDevice{
 			8: "Slower streaming",
 			9: "Interface for https://github.com/google/gousb/issues/65",
 		},
+		sysDevPtr: 94,
 	},
 	// Bus 001 Device 003: ID 9999:0002
 	// One config, one interface, one setup,

fakelibusb_test.go

@@ -87,6 +87,8 @@ type fakeLibusb struct {
 	mu sync.Mutex
 	// fakeDevices has a map of devices and their descriptors.
 	fakeDevices map[*libusbDevice]*fakeDevice
+	// fakeSysDevices keeps the order of devices to be accessd by wrapSysDevice
+	fakeSysDevices map[uintptr]*libusbDevice
 	// ts has a map of all allocated transfers, indexed by the pointer of
 	// underlying libusbTransfer.
 	ts map[*libusbTransfer]*fakeTransfer
@@ -108,6 +110,21 @@ func (f *fakeLibusb) getDevices(*libusbContext) ([]*libusbDevice, error) {
 	return ret, nil
 }
 
+func (f *fakeLibusb) wrapSysDevice(ctx *libusbContext, systemDeviceHandle uintptr) (*libusbDevHandle, error) {
+	if _, ok := f.fakeSysDevices[systemDeviceHandle]; !ok {
+		return nil, fmt.Errorf("The passed file descriptor %d does not point to a valid device", systemDeviceHandle)
+	}
+	h := newDevHandlePointer()
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.handles[h] = f.fakeSysDevices[systemDeviceHandle]
+	return h, nil
+}
+
+func (f *fakeLibusb) getDevice(handle *libusbDevHandle) *libusbDevice {
+	return f.handles[handle]
+}
+
 func (f *fakeLibusb) exit(*libusbContext) error {
 	close(f.submitted)
 	if got := len(f.ts); got > 0 {
@@ -288,11 +305,12 @@ func (f *fakeLibusb) empty() bool {
 
 func newFakeLibusb() *fakeLibusb {
 	fl := &fakeLibusb{
-		fakeDevices: make(map[*libusbDevice]*fakeDevice),
-		ts:          make(map[*libusbTransfer]*fakeTransfer),
-		submitted:   make(chan *fakeTransfer, 10),
-		handles:     make(map[*libusbDevHandle]*libusbDevice),
-		claims:      make(map[*libusbDevice]map[uint8]bool),
+		fakeDevices:    make(map[*libusbDevice]*fakeDevice),
+		fakeSysDevices: make(map[uintptr]*libusbDevice),
+		ts:             make(map[*libusbTransfer]*fakeTransfer),
+		submitted:      make(chan *fakeTransfer, 10),
+		handles:        make(map[*libusbDevHandle]*libusbDevice),
+		claims:         make(map[*libusbDevice]map[uint8]bool),
 	}
 	for _, d := range fakeDevices {
 		// libusb does not export a way to allocate a new libusb_device struct
@@ -301,7 +319,11 @@ func newFakeLibusb() *fakeLibusb {
 		// The contents of these pointers is never accessed.
 		fd := new(fakeDevice)
 		*fd = d
-		fl.fakeDevices[newDevicePointer()] = fd
+		devPointer := newDevicePointer()
+		fl.fakeDevices[devPointer] = fd
+		if fd.sysDevPtr != 0 { // the sysDevPtr not being set in the fakeDevices list
+			fl.fakeSysDevices[fd.sysDevPtr] = devPointer
+		}
 	}
 	return fl
 }

libusb.go

@@ -40,6 +40,7 @@ type libusbDevice C.libusb_device
 type libusbDevHandle C.libusb_device_handle
 type libusbTransfer C.struct_libusb_transfer
 type libusbEndpoint C.struct_libusb_endpoint_descriptor
+type libusbLogLevel C.enum_libusb_log_level
 
 func (ep libusbEndpoint) endpointDesc(dev *DeviceDesc) EndpointDesc {
 	ei := EndpointDesc{
@@ -143,6 +144,7 @@ type libusbIntf interface {
 	dereference(*libusbDevice)
 	getDeviceDesc(*libusbDevice) (*DeviceDesc, error)
 	open(*libusbDevice) (*libusbDevHandle, error)
+	wrapSysDevice(*libusbContext, uintptr) (*libusbDevHandle, error)
 
 	close(*libusbDevHandle)
 	reset(*libusbDevHandle) error
@@ -152,6 +154,7 @@ type libusbIntf interface {
 	getStringDesc(*libusbDevHandle, int) (string, error)
 	setAutoDetach(*libusbDevHandle, int) error
 	detachKernelDriver(*libusbDevHandle, uint8) error
+	getDevice(*libusbDevHandle) *libusbDevice
 
 	// interface
 	claim(*libusbDevHandle, uint8) error
@@ -169,13 +172,24 @@ type libusbIntf interface {
 }
 
 // libusbImpl is an implementation of libusbIntf using real CGo-wrapped libusb.
-type libusbImpl struct{}
+type libusbImpl struct {
+	discovery DeviceDiscovery
+}
 
-func (libusbImpl) init() (*libusbContext, error) {
+func (impl libusbImpl) init() (*libusbContext, error) {
 	var ctx *C.libusb_context
-	if err := fromErrNo(C.libusb_init(&ctx)); err != nil {
+
+	var libusb_options [4]C.struct_libusb_init_option // fixed to 4 - there are maximum 4 options
+	n_options := 0
+	if impl.discovery == DisableDeviceDiscovery {
+		libusb_options[n_options].option = C.LIBUSB_OPTION_NO_DEVICE_DISCOVERY
+		n_options += 1
+	}
+
+	if err := fromErrNo(C.libusb_init_context(&ctx, &(libusb_options[0]), C.int(n_options))); err != nil {
 		return nil, err
 	}
+
 	return (*libusbContext)(ctx), nil
 }
 
@@ -217,6 +231,20 @@ func (libusbImpl) getDevices(ctx *libusbContext) ([]*libusbDevice, error) {
 	return ret, nil
 }
 
+func (libusbImpl) wrapSysDevice(ctx *libusbContext, fd uintptr) (*libusbDevHandle, error) {
+	var handle *C.libusb_device_handle
+	if ret := C.libusb_wrap_sys_device((*C.libusb_context)(ctx), C.intptr_t(fd), &handle); ret < 0 {
+		return nil, fromErrNo(C.int(ret))
+	}
+
+	return (*libusbDevHandle)(handle), nil
+}
+
+func (libusbImpl) getDevice(d *libusbDevHandle) *libusbDevice {
+	device := C.libusb_get_device((*C.libusb_device_handle)(d))
+	return (*libusbDevice)(device)
+}
+
 func (libusbImpl) exit(c *libusbContext) error {
 	C.libusb_exit((*C.libusb_context)(c))
 	return nil

usb.go

@@ -168,6 +168,23 @@ func NewContext() *Context {
 	return newContextWithImpl(libusbImpl{})
 }
 
+type DeviceDiscovery int
+
+const (
+	EnableDeviceDiscovery = iota
+	DisableDeviceDiscovery
+)
+
+type ContextOptions struct {
+	DeviceDiscovery DeviceDiscovery
+}
+
+func (o ContextOptions) New() *Context {
+	return newContextWithImpl(libusbImpl{
+		discovery: o.DeviceDiscovery,
+	})
+}
+
 // OpenDevices calls opener with each enumerated device.
 // If the opener returns true, the device is opened and a Device is returned if the operation succeeds.
 // Every Device returned (whether an error is also returned or not) must be closed.
@@ -210,6 +227,27 @@ func (c *Context) OpenDevices(opener func(desc *DeviceDesc) bool) ([]*Device, er
 	return ret, reterr
 }
 
+func (c *Context) OpenDeviceWithFileDescriptor(fd uintptr) (*Device, error) {
+	handle, err := c.libusb.wrapSysDevice(c.ctx, fd)
+	if err != nil {
+		return nil, fmt.Errorf("Error opening device from file descriptor: %d, %s", fd, err.Error())
+	}
+
+	dev := c.libusb.getDevice(handle)
+
+	desc, err := c.libusb.getDeviceDesc(dev)
+	if err != nil {
+		return nil, err
+	}
+
+	o := &Device{handle: handle, ctx: c, Desc: desc}
+	c.mu.Lock()
+	c.devices[o] = true
+	c.mu.Unlock()
+
+	return o, nil
+}
+
 // OpenDeviceWithVIDPID opens Device from specific VendorId and ProductId.
 // If none is found, it returns nil and nil error. If there are multiple devices
 // with the same VID/PID, it will return one of them, picked arbitrarily.

usb_test.go

@@ -94,3 +94,45 @@ func TestOpenDeviceWithVIDPID(t *testing.T) {
 		}
 	}
 }
+
+func TestOpenDeviceWithFileDescriptor(t *testing.T) {
+	ctx := newContextWithImpl(newFakeLibusb())
+	defer ctx.Close()
+
+	// file descriptor is an index to the FakeDevices array
+	for _, d := range []struct {
+		vid, pid  ID
+		sysDevPtr uintptr
+	}{
+		{0x9999, 0x0001, 78},
+		{0x8888, 0x0002, 94},
+	} {
+		dev, err := ctx.OpenDeviceWithFileDescriptor(d.sysDevPtr)
+		if dev == nil {
+			t.Errorf("OpenDeviceWithFileDescriptor(%d): device == nil for a valid device", d.sysDevPtr)
+		}
+		if err != nil {
+			t.Errorf("OpenDeviceWithFileDescriptor(%d): err != nil for a valid device: %v", d.sysDevPtr, err)
+		}
+	}
+
+}
+
+func TestOpenDeviceWithFileDescriptorOnMissingDevice(t *testing.T) {
+	ctx := newContextWithImpl(newFakeLibusb())
+	defer ctx.Close()
+
+	for _, sysDevPtr := range []uintptr{
+		7, // set, but does not exist in the fakeDevices array
+		0, // unset
+	} {
+		dev, err := ctx.OpenDeviceWithFileDescriptor(sysDevPtr)
+		if err == nil {
+			t.Errorf("OpenDeviceWithFileDescriptor(%d): got nil error for invalid device", sysDevPtr)
+		}
+		if dev != nil {
+			t.Errorf("OpenDeviceWithFileDescriptor(%d): got non-nil device for invalid device", sysDevPtr)
+		}
+	}
+
+}