def _find_handle(self, vendor_id=None, product_id=None, attempts_left=5):
handle = None
found_dev = None
for device in self._context.getDeviceList():
if vendor_id and product_id:
# match by vendor and product id
if (device.getVendorID() == vendor_id and
device.getProductID == product_id):
handle = self._open_device(device)
if handle:
found_dev = device
break
elif device.getVendorID() in COMPATIBLE_VIDS:
# attempt to get the first compatible vendor id
handle = self._open_device(device)
if handle:
found_dev = device
break
if handle:
eprint("Device Found: {0}".format(found_dev))
eprint("Product: {0}".format(
handle.getASCIIStringDescriptor(found_dev.device_descriptor.iProduct)))
if found_dev.getProductID() in ACCESSORY_PID:
return True, handle
else:
return False, handle
elif attempts_left:
time.sleep(1)
return self._find_handle(vendor_id, product_id, attempts_left-1)
else:
raise usb1.USBError('Device not available')
def _configure_accessory_mode(self):
# Don't need to claim interface to do control read/write, and the
# original driver prevents it
# self._handle.claimInterface(0)
version = self._handle.controlRead(
usb1.TYPE_VENDOR | usb1.RECIPIENT_DEVICE, 51, 0, 0, 2)
adk_ver = unpack('<H', version)[0]
print("ADK version is: %d" % adk_ver)
assert adk_ver == 2
# enter accessory information
for i, data in enumerate((MANUFACTURER, MODEL_NAME, DESCRIPTION,
VERSION, URI, SERIAL_NUMBER)):
assert self._handle.controlWrite(
usb1.TYPE_VENDOR | usb1.RECIPIENT_DEVICE, 52, 0, i,
data.encode()) == len(data)
# enable 2 channel audio
assert self._handle.controlWrite(
usb1.TYPE_VENDOR | usb1.RECIPIENT_DEVICE, 58, 1, 0, b'') == 0
# start device in accessory mode
self._handle.controlWrite(usb1.TYPE_VENDOR | usb1.RECIPIENT_DEVICE, 53,
0, 0, b'')
time.sleep(1)
isconfigured, newhandle = self._find_handle()
if isconfigured:
return newhandle
else:
raise usb1.USBError('Error configuring accessory mode')
def __init__(self,
usb_context,
write_queue,
vendor_id=None,
product_id=None):
self.app_connected = False
self._context = usb_context
isconfigured, self._handle = self._find_handle(vendor_id, product_id)
if isconfigured:
print("Device is in accessory mode")
# TODO: should I reset the device?
# self._handle.claimInterface(0)
# self._handle.resetDevice()
# time.sleep(2)
# isconfigured, self._handle = self._find_handle(vendor_id, product_id)
# self._handle = self._configure_accessory_mode()
else:
self._handle = self._configure_accessory_mode()
self._handle.claimInterface(0)
# pause for one second so the android device can react to changes
time.sleep(1)
device = self._handle.getDevice()
config = device[0]
interface = config[0]
self._in_endpoint, self._out_endpoint = self._get_endpoints(
interface[0])
if self._in_endpoint is None or self._out_endpoint is None:
self._handle.releaseInterface(0)
raise usb1.USBError(
'Unable to retreive endpoints for accessory device')
read_callback = usb1.USBTransferHelper()
callback_obj = ReadCallback(self, write_queue)
read_callback.setEventCallback(
usb1.TRANSFER_COMPLETED,
callback_obj,
)
self._read_list = []
for _ in range(64):
data_reader = self._handle.getTransfer()
data_reader.setBulk(
self._in_endpoint,
0x4000,
callback=read_callback,
)
data_reader.submit()
self._read_list.append(data_reader)
self._write_queue = write_queue
self._is_running = True
self._write_thread = threading.Thread(target=self._write_thread_proc)
self._write_thread.start()
def rw_callback(self, transfer):
self.callback_active = True
if transfer.getStatus() != usb1.TRANSFER_COMPLETED:
print 'rw_callback: transfer fail, status = %s' % transfer.getStatus(
)
print 'Actual length = %d buffer size = %d' % (
transfer.getActualLength(), len(transfer.getBuffer()))
raise usb1.USBError(transfer.getStatus())
data = transfer.getBuffer()[:transfer.getActualLength()]
# Don't resubmit... though that would be smart
# NOTE: should this handle the case of an odd number of bytes?
self.read_data_pending = numpy.frombuffer(data, dtype=self.dtype)
self.callback_active = False
def __init__(self, usb_context, vendor_id=None, product_id=None):
self._context = usb_context
isconfigured, self._handle = self._find_handle(vendor_id, product_id)
if isconfigured:
print("Device already in accessory mode, attempting reset")
# TODO: should I reset the device?
#self._handle.claimInterface(0)
#self._handle.resetDevice()
#time.sleep(2)
#isconfigured, self._handle = self._find_handle(vendor_id, product_id)
else:
self._handle = self._configure_accessory_mode()
self._handle.claimInterface(0)
# pause for one second so the android device can react to changes
time.sleep(1)
device = self._handle.getDevice()
config = device[0]
interface = config[0]
self._in_endpoint, self._out_endpoint = self._get_endpoints(
interface[0])
if self._in_endpoint is None or self._out_endpoint is None:
self._handle.releaseInterface(0)
raise usb1.USBError(
'Unable to retreive endpoints for accessory device')
self.port = 8000 # port to forward sockets to
self.app_connected = False
self._is_running = True
self._read_callback = ReadCallback(self)
self._accessory_read_thread = threading.Thread(
target=self._accessory_read_thread_proc)
self._accessory_read_thread.start()
self._socket_dict = {}
self._socket_selector = selectors.DefaultSelector()
self._socket_read_thread = threading.Thread(
target=self._socket_read_thread_proc)
self._socket_read_thread.start()
def __init__(self, usb_context, vendor_id=None, product_id=None):
self.app_connected = False
self._context = usb_context
isconfigured, self._handle = self._find_handle(vendor_id, product_id)
if isconfigured:
print("Device is in accessory mode")
# TODO: should I reset the device?
# self._handle.claimInterface(0)
# self._handle.resetDevice()
# time.sleep(2)
# isconfigured, self._handle = self._find_handle(vendor_id, product_id)
# self._handle = self._configure_accessory_mode()
else:
self._handle = self._configure_accessory_mode()
self._handle.claimInterface(0)
# pause for one second so the android device can react to changes
time.sleep(1)
device = self._handle.getDevice()
config = device[0]
interface = config[0]
self._in_endpoint, self._out_endpoint = self._get_endpoints(
interface[0])
if self._in_endpoint is None or self._out_endpoint is None:
self._handle.releaseInterface(0)
raise usb1.USBError(
'Unable to retreive endpoints for accessory device')
self._is_running = True
self._accessory_read_thread = threading.Thread(
target=self._accessory_read_thread_proc)
self._accessory_read_thread.start()
self._sio_client_socket = socket.socket()
self._sio_read_thread = None
self._socket_connected = False
def _find_handle(self, vendor_id=None, product_id=None, attempts_left=5):
handle = None
found_pid = None
for device in self._context.getDeviceList():
if vendor_id and product_id:
# match by vendor and product id
if (device.getVendorID() == vendor_id
and device.getProductID == product_id):
try:
handle = device.open()
found_vid = vendor_id
found_pid = device.getProductID()
except usb1.USBError as err:
print(err.args)
break
elif device.getVendorID() in COMPATIBLE_VIDS:
# attempt to get the first compatible vendor id
try:
handle = device.open()
found_vid = device.getVendorID()
found_pid = device.getProductID()
except usb1.USBError as err:
print(err.args)
break
if handle:
print('Found {0:x}:{1:x}'.format(found_vid, found_pid))
if found_pid in ACCESSORY_PID:
return True, handle
else:
return False, handle
elif attempts_left:
time.sleep(1)
return self._find_handle(vendor_id, product_id, attempts_left - 1)
else:
raise usb1.USBError('Device not connected')
def getPortNumberList(self):
if self.port_list is None:
raise usb1.USBError('omg no port list')
return self.port_list
def getSerialNumber(self):
if self.serial is None:
raise usb1.USBError('omg no serial')
return self.serial
def fakeHandleEventsLocked():
raise usb1.USBError(0)
