/**
 * 接続されているUSBの機器リストをLogCatに出力
 * @param context
 */
public static void dumpDevices(@NonNull final Context context) {
	final UsbManager usbManager = ContextUtils.requireSystemService(context, UsbManager.class);
	final HashMap<String, UsbDevice> list = usbManager.getDeviceList();
	if ((list != null) && !list.isEmpty()) {
		final Set<String> keys = list.keySet();
		if (keys != null && keys.size() > 0) {
			final StringBuilder sb = new StringBuilder();
			for (final String key: keys) {
				final UsbDevice device = list.get(key);
				final int num_interface = device != null ? device.getInterfaceCount() : 0;
				sb.setLength(0);
				for (int i = 0; i < num_interface; i++) {
					sb.append(String.format(Locale.US, "interface%d:%s",
						i, device.getInterface(i).toString()));
				}
				Log.i(TAG, "key=" + key + ":" + device + ":" + sb.toString());
			}
		} else {
			Log.i(TAG, "no device");
		}
	} else {
		Log.i(TAG, "no device");
	}
}
 

public static UsbSerialDevice createUsbSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
  {
/*
 * It checks given vid and pid and will return a custom driver or a CDC serial driver.
 * When CDC is returned open() method is even more important, its response will inform about if it can be really
 * opened as a serial device with a generic CDC serial driver
 */
      int vid = device.getVendorId();
      int pid = device.getProductId();

      if(FTDISioIds.isDeviceSupported(device))
          return new FTDISerialDevice(device, connection, iface);
      else if(CP210xIds.isDeviceSupported(vid, pid))
          return new CP2102SerialDevice(device, connection, iface);
      else if(PL2303Ids.isDeviceSupported(vid, pid))
          return new PL2303SerialDevice(device, connection, iface);
      else if(CH34xIds.isDeviceSupported(vid, pid))
          return new CH34xSerialDevice(device, connection, iface);
      else if(isCdcDevice(device))
          return new CDCSerialDevice(device, connection, iface);
      else
          return null;
  }
 

/**
 * Checks the devices connected to android and finds the radio. It then attempts to get
 * permission to connect to the radio.
 */
private void requestConnection() {
    Log.v(TAG, "Requesting connection to device");
    UsbDevice device = getDevice();
    if (device != null) {
        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
        filter.addAction(ACTION_USB_PERMISSION);
        filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
        context.registerReceiver(usbBroadcastReceiver, filter);

        if (usbManager.hasPermission(device)) {
            usbDevice = device;
            openConnection();
        } else {
            Log.v(TAG, "Requesting permission for device");
            usbManager.requestPermission(device, usbPermissionIntent);
        }
    } else {
        if (connectionStateListener != null) {
            connectionStateListener.onFail();
        }
        Log.v(TAG, "No device found");
    }
}
 

public static boolean isSupported(UsbDevice device)
{
    int vid = device.getVendorId();
    int pid = device.getProductId();

    if(FTDISioIds.isDeviceSupported(device))
        return true;
    else if(CP210xIds.isDeviceSupported(vid, pid))
        return true;
    else if(PL2303Ids.isDeviceSupported(vid, pid))
        return true;
    else if(CH34xIds.isDeviceSupported(vid, pid))
        return true;
    else if(isCdcDevice(device))
        return true;
    else
        return false;
}
 

private void removeService(final UsbDevice device) {
	final int key = device.hashCode();
	synchronized (sServiceSync) {
		final CameraServer service = sCameraServers.get(key);
		if (service != null)
			service.release();
		sCameraServers.remove(key);
		sServiceSync.notifyAll();
	}
	if (checkReleaseService()) {
		if (mUSBMonitor != null) {
			mUSBMonitor.unregister();
			mUSBMonitor = null;
		}
	}
}
 

@Override
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
    String deviceName = usbDevice.getDeviceName();
    if (UsbStorageProvider.ACTION_USB_PERMISSION.equals(action)) {
        boolean permission = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false);
        if (permission) {
            discoverDevice(usbDevice);
            notifyRootsChanged();
            notifyDocumentsChanged(getContext(), getRootId(usbDevice)+ROOT_SEPERATOR);
        } else {
            // so we don't ask for permission again
        }
    } else if (UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(action)
            || UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
        updateRoots();
    }
}
 

/**
 * open specific USB device
 * @param device
 */
private final void processConnect(final UsbDevice device) {
	if (destroyed) return;

	updatePermission(device, true);
	mAsyncHandler.post(new Runnable() {
		@Override
		public void run() {
			if (DEBUG) Log.v(TAG, "processConnect:device=" + device);
			UsbControlBlock ctrlBlock;
			final boolean createNew;
			ctrlBlock = mCtrlBlocks.get(device);
			if (ctrlBlock == null) {
				ctrlBlock = new UsbControlBlock(USBMonitor.this, device);
				mCtrlBlocks.put(device, ctrlBlock);
				createNew = true;
			} else {
				createNew = false;
			}
			if (mOnDeviceConnectListener != null) {
				mOnDeviceConnectListener.onConnect(device, ctrlBlock, createNew);
			}
		}
	});
}
 

public UsbDevice findDexcom() {
    Log.i("CALIBRATION-CHECK-IN: ", "Searching for dexcom");
    mUsbManager = (UsbManager) getApplicationContext().getSystemService(Context.USB_SERVICE);
    Log.i("USB MANAGER = ", mUsbManager.toString());
    HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
    Log.i("USB DEVICES = ", deviceList.toString());
    Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
    Log.i("USB DEVICES = ", String.valueOf(deviceList.size()));

    while(deviceIterator.hasNext()){
        UsbDevice device = deviceIterator.next();
        if (device.getVendorId() == 8867 && device.getProductId() == 71
                && device.getDeviceClass() == 2 && device.getDeviceSubclass() ==0
                && device.getDeviceProtocol() == 0){
            dexcom = device;
            Log.i("CALIBRATION-CHECK-IN: ", "Dexcom Found!");
            return device;
        } else {
            Log.w("CALIBRATION-CHECK-IN: ", "that was not a dexcom (I dont think)");
        }
    }
    return null;
}
 

/**
 * request permission to access to USB device
 * @param device
 */
public synchronized void requestPermission(final UsbDevice device) {
	if (DEBUG) Log.v(TAG, "requestPermission:device=" + device);
	if (mPermissionIntent != null) {
		if (device != null) {
			if (mUsbManager.hasPermission(device)) {
				processConnect(device);
			} else {
				mUsbManager.requestPermission(device, mPermissionIntent);
			}
		} else {
			processCancel(device);
		}
	} else {
		processCancel(device);
	}
}
 

private UsbHidDevice(UsbDevice usbDevice, UsbInterface usbInterface, UsbManager usbManager) {
    mUsbDevice = usbDevice;
    mUsbInterface = usbInterface;
    mUsbManager= usbManager;

    for (int i = 0; i < mUsbInterface.getEndpointCount(); i++) {
        UsbEndpoint endpoint = mUsbInterface.getEndpoint(i);
        int dir = endpoint.getDirection();
        int type = endpoint.getType();
        if (mInUsbEndpoint == null && dir == UsbConstants.USB_DIR_IN && type == UsbConstants.USB_ENDPOINT_XFER_INT) {
            mInUsbEndpoint = endpoint;
        }
        if (mOutUsbEndpoint == null && dir == UsbConstants.USB_DIR_OUT && type == UsbConstants.USB_ENDPOINT_XFER_INT) {
            mOutUsbEndpoint = endpoint;
        }
    }
}
 

/**
 * close specified interface. USB device itself still keep open.
 */
public synchronized void close() {
	if (DEBUG) Log.i(TAG, "UsbControlBlock#close:");

	if (mConnection != null) {
		final int n = mInterfaces.size();
		int key;
		UsbInterface intf;
		for (int i = 0; i < n; i++) {
			key = mInterfaces.keyAt(i);
			intf = mInterfaces.get(key);
			mConnection.releaseInterface(intf);
		}
		mConnection.close();
		mConnection = null;
		final USBMonitor monitor = mWeakMonitor.get();
		if (monitor != null) {
			if (monitor.mOnDeviceConnectListener != null) {
				final UsbDevice device = mWeakDevice.get();
				monitor.mOnDeviceConnectListener.onDisconnect(device, this);
			}
			monitor.mCtrlBlocks.remove(getDevice());
		}
	}
}
 

@Override
public void onStart() {
  super.onStart();
  HashMap<String, UsbDevice> deviceList = usbManager.getDeviceList();
  ListView listView = getRootView().findViewById(R.id.connected_usb_devices_list);
  listView.setAdapter(usbArrayAdapter);
  for (UsbDevice device : deviceList.values()) {
    usbArrayAdapter.add(getDisplayableUsbDeviceName(device));
  }
  usbArrayAdapter.notifyDataSetChanged();
  if (usbArrayAdapter.getCount() == 0) {
    updateScreenBasedOnIfUsbDeviceIsConnected(false);
  }

  IntentFilter intent = new IntentFilter(UsbManager.ACTION_USB_DEVICE_ATTACHED);
  intent.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
  getActivity().registerReceiver(broadcastReceiver, intent);
}
 

/**
 * return device list, return empty list if no device matched
 * @param filters
 * @return
 * @throws IllegalStateException
 */
public List<UsbDevice> getDeviceList(final List<DeviceFilter> filters) throws IllegalStateException {
	if (destroyed) throw new IllegalStateException("already destroyed");
	final HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
	final List<UsbDevice> result = new ArrayList<UsbDevice>();
	if (deviceList != null) {
		if ((filters == null) || filters.isEmpty()) {
			result.addAll(deviceList.values());
		} else {
			for (final UsbDevice device: deviceList.values() ) {
				for (final DeviceFilter filter: filters) {
					if ((filter != null) && filter.matches(device)) {
						// when filter matches
						if (!filter.isExclude) {
							result.add(device);
						}
						break;
					}
				}
			}
		}
	}
	return result;
}
 

/**
 * Gets a summary of the current select product and vendor ids
 */
private String getSelectedDeviceSummary() {
    int productId = sharedPreferences.getInt(
            USBGpsProviderService.PREF_GPS_DEVICE_PRODUCT_ID, DEFAULT_GPS_PRODUCT_ID);
    int vendorId = sharedPreferences.getInt(
            USBGpsProviderService.PREF_GPS_DEVICE_VENDOR_ID, DEFAULT_GPS_VENDOR_ID);

    String deviceDisplayedName = "Device not connected - " + vendorId + ": " + productId;

    for (UsbDevice usbDevice: usbManager.getDeviceList().values()) {
        if (usbDevice.getVendorId() == vendorId && usbDevice.getProductId() == productId) {
            deviceDisplayedName =
                    "USB " + usbDevice.getDeviceProtocol() + " " + usbDevice.getDeviceName() +
                            " | " + vendorId + ": " + productId;

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                deviceDisplayedName = usbDevice.getManufacturerName() + usbDevice.getProductName() +
                        " | " + vendorId + ": " + productId;
            }

            break;
        }
    }

    return deviceDisplayedName;
}
 

public static UsbSpiDevice createUsbSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
    int vid = device.getVendorId();
    int pid = device.getProductId();

    if(CP2130Ids.isDeviceSupported(vid, pid))
        return new CP2130SpiDevice(device, connection, iface);
    else
        return null;
}
 

@Override
public UsbDeviceInfo getDeviceByBusId(String busId) {
	UsbDevice dev = getDevice(busId);
	if (dev == null) {
		return null;
	}
	
	AttachedDeviceContext context = connections.get(dev.getDeviceId());
	UsbDeviceConnection devConn = null;
	if (context != null) {
		devConn = context.devConn;
	}
	
	return getInfoForDevice(dev, devConn);
}
 

public DeviceFilter(final UsbDevice device) {
		mVendorId = device.getVendorId();
		mProductId = device.getProductId();
		mClass = device.getDeviceClass();
		mSubclass = device.getDeviceSubclass();
		mProtocol = device.getDeviceProtocol();
		mManufacturerName = null;	// device.getManufacturerName();
		mProductName = null;		// device.getProductName();
		mSerialNumber = null;		// device.getSerialNumber();
/*		Log.i(TAG, String.format("vendorId=0x%04x,productId=0x%04x,class=0x%02x,subclass=0x%02x,protocol=0x%02x",
			mVendorId, mProductId, mClass, mSubclass, mProtocol)); */
	}
 

TinfoilUSB(ResultReceiver resultReceiver,
           Context context,
           UsbDevice usbDevice,
           UsbManager usbManager,
           ArrayList<NSPElement> nspElements) throws Exception{
    super(resultReceiver, context, usbDevice, usbManager);
    this.nspElements = nspElements;
}
 

public void discoverDevices(){
    try{
        for (UsbDevice device : usbManager.getDeviceList().values()) {
            if(hasPermission(device)) {
                discoverDevice(device);
            } else {
                addRoot(device);
            }
        }
    } catch (Exception e){
        Crashlytics.logException(e);
    }
}
 

public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();

    if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
        UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
        if (device != null) {
            printStatus(getString(R.string.status_removed));
            printDeviceDescription(device);
        }
    }
}
 

/**
 * return device list, return empty list if no device matched
 * @param filter
 * @return
 * @throws IllegalStateException
 */
public List<UsbDevice> getDeviceList(final DeviceFilter filter) throws IllegalStateException {
	if (destroyed) throw new IllegalStateException("already destroyed");
	final HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
	final List<UsbDevice> result = new ArrayList<UsbDevice>();
	if (deviceList != null) {
		for (final UsbDevice device: deviceList.values() ) {
			if ((filter == null) || (filter.matches(device) && !filter.isExclude)) {
				result.add(device);
			}
		}
	}
	return result;
}
 

@Override
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    if (ACTION_USB_PERMISSION.equals(action)) {
        context.unregisterReceiver(this);
        final UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
        // device is not plugged in anymore, we're not interested in it's permissions
        if (device == null || !findDevices().contains(device)) {
            return;
        }

        listener.onRequestPermissionsResult(new UsbSession(usbManager, device), usbManager.hasPermission(device));
    }
}
 

/**
 * Finds and builds all possible {@link UsbSerialDriver UsbSerialDrivers}
 * from the currently-attached {@link UsbDevice} hierarchy. This method does
 * not require permission from the Android USB system, since it does not
 * open any of the devices.
 *
 * @param usbManager
 *
 * @return a list, possibly empty, of all compatible drivers
 */
@Keep
public List<UsbSerialDriver> findAllDrivers(final UsbManager usbManager) {
    final List<UsbSerialDriver> result = new ArrayList<UsbSerialDriver>();
    HashMap<String, UsbDevice> deviceList = usbManager.getDeviceList();
    Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
    while (deviceIterator.hasNext()) {
        UsbDevice usbDevice = deviceIterator.next();
        UsbSerialDriver driver = probeDevice(usbDevice);
        if (driver != null) {
            result.add(driver);
        }
    }
    return result;
}
 

private UsbDevice getDevice(int deviceId) {
	for (UsbDevice dev : usbManager.getDeviceList().values()) {
		if (dev.getDeviceId() == deviceId) {
			return dev;
		}
	}
	
	return null;
}
 

protected LineBasedUsbSerialCardDevice(Context context, UsbDevice usbDevice, String delimiter,
        String charsetName, String status) throws IOException {
    super(context, usbDevice, status);

    this.delimiter = delimiter;
    this.charsetName = charsetName;
}
 

public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    if (ACTION_USB_PERMISSION.equals(action)) {
        synchronized (this) {
            UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

            if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                if (device != null) {
                    if (usbManager.hasPermission(device)) {
                        debugLog("We have permission, good!");
                        if (enabled) {
                            openConnection(device);
                        }
                    }
                }
            } else {
                debugLog("permission denied for device " + device);
            }
        }
    } else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
        synchronized (this) {
            if (connectedGps != null && enabled) {
                connectedGps.close();
            }
        }
    }
}
 

private Ledger(UsbManager usbManager, UsbDevice usbDevice) throws IOException {
    final BTChipTransport transport = BTChipTransportAndroidHID.open(usbManager, usbDevice);
    Timber.d("transport opened = %s", transport.toString());
    transport.setDebug(BuildConfig.DEBUG);
    this.transport = transport;
    this.name = usbDevice.getManufacturerName() + " " + usbDevice.getProductName();
    initKey();
}
 

private final void processCancel(final UsbDevice device) {
	if (DEBUG) Log.v(TAG, "processCancel:");
	if (mOnDeviceConnectListener != null) {
		mHandler.post(new Runnable() {
			@Override
			public void run() {
				mOnDeviceConnectListener.onCancel();
			}
		});
	}
}
 

private static String nameForClass(UsbDevice usbDevice) {
    int classType = usbDevice.getDeviceClass();
    switch (classType) {
        case UsbConstants.USB_CLASS_AUDIO:
            return "Audio";
        case UsbConstants.USB_CLASS_CDC_DATA:
            return "CDC Control";
        case UsbConstants.USB_CLASS_COMM:
            return "Communications";
        case UsbConstants.USB_CLASS_CONTENT_SEC:
            return "Content Security";
        case UsbConstants.USB_CLASS_CSCID:
            return "Content Smart Card";
        case UsbConstants.USB_CLASS_HID:
            return "Human Interface Device";
        case UsbConstants.USB_CLASS_HUB:
            return "Hub";
        case UsbConstants.USB_CLASS_MASS_STORAGE:
            return "Mass Storage";
        case UsbConstants.USB_CLASS_MISC:
            return "Wireless Miscellaneous";
        case UsbConstants.USB_CLASS_PHYSICA:
            return "Physical";
        case UsbConstants.USB_CLASS_PRINTER:
            return "Printer";
        case UsbConstants.USB_CLASS_STILL_IMAGE:
            return "Still Image";
        case UsbConstants.USB_CLASS_VENDOR_SPEC:
            return String.format("Vendor Specific 0x%02x", classType);
        case UsbConstants.USB_CLASS_VIDEO:
            return "Video";
        case UsbConstants.USB_CLASS_WIRELESS_CONTROLLER:
            return "Wireless Controller";
        default:
            return "";
    }
}
 

public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    if (ACTION_USB_PERMISSION.equals(action)) {
        synchronized (this) {
            UsbDevice uDevice = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

            if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {

                if(uDevice != null) {
                    initView();

                    // Right now the activity doesn't have focus, so if we need to manually
                    // set immersive mode.
                    if (immersive) {
                        camView.setSystemUiVisibility(
                                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                                        | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                                        | View.SYSTEM_UI_FLAG_FULLSCREEN);

                        currentLayout.post(setAspectRatio);
                    }
                }
                else {
                    Log.d(TAG, "USB Device not valid");
                }
            }
            else {
                Log.d(TAG, "permission denied for device " + uDevice);
            }
        }
    }
}