下面列出了android.hardware.usb.UsbManager#hasPermission ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public synchronized void connectRC(Context mContext) {
if (!this.isTryConnect) {
this.isTryConnect = true;
UsbManager usbManager = (UsbManager) mContext.getSystemService("usb");
this.mPermissionIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(ACTION_USB_PERMISSION), 0);
if (usbManager != null) {
UsbAccessory[] accessories = usbManager.getAccessoryList();
UsbAccessory accessory = accessories == null ? null : accessories[0];
if (accessory != null) {
if (usbManager.hasPermission(accessory)) {
CommunicationManager.getCommunicationManager().setAccessory(accessory);
CommunicationManager.getCommunicationManager().startConnectThread(mContext, ConnectType.Aoa);
} else if (!this.isRequestPermission) {
usbManager.requestPermission(accessory, this.mPermissionIntent);
this.isRequestPermission = true;
}
}
}
this.isTryConnect = false;
}
}
/**
* initialize ch340 parameters.
*
* @param context Application context.
*/
public static void initCH340(Context context) {
if (context == null) return;
Context appContext = context.getApplicationContext();
mUsbManager = (UsbManager) appContext.getSystemService(Context.USB_SERVICE);
if (mUsbManager != null) {
HashMap<String, UsbDevice> deviceHashMap = mUsbManager.getDeviceList();
LogUtils.e(TAG, "deviceHashMap.size()=" + deviceHashMap.size());
for (UsbDevice device : deviceHashMap.values()) {
LogUtils.i(TAG, "ProductId:" + device.getProductId() + ",VendorId:" + device.getVendorId());
if (device.getProductId() == 29987 && device.getVendorId() == 6790) {
mUsbDevice = device;
if (mUsbManager.hasPermission(device)) {
loadDriver(appContext, mUsbManager);
} else {
if (listener != null) {
listener.result(false);
}
}
break;
}
}
}
}
private boolean processUsbIntent(Intent intent) {
String action = intent.getAction();
if (UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(action)) {
synchronized (this) {
final UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
if (device != null) {
final UsbManager usbManager = getUsbManager();
if (usbManager.hasPermission(device)) {
Timber.d("Ledger attached by intent");
connectLedger(usbManager, device);
}
}
}
return true;
}
return false;
}
public void checkForDJIAccessory() {
mUsbManager = (UsbManager) BridgeApplication.getInstance().getSystemService(Context.USB_SERVICE);
UsbAccessory[] accessoryList = mUsbManager.getAccessoryList();
if (accessoryList != null
&& accessoryList.length > 0
&& !TextUtils.isEmpty(accessoryList[0].getManufacturer())
&& accessoryList[0].getManufacturer().equals("DJI")) {
BridgeApplication.getInstance().getBus().post(new RCConnectionEvent(true));
//Check permission
mAccessory = accessoryList[0];
if (mUsbManager.hasPermission(mAccessory)) {
Log.d(TAG, "RC CONNECTED");
} else {
Log.d(TAG, "NO Permission to USB Accessory");
DJILogger.e(TAG, "NO Permission to USB Accessory");
//mUsbManager.requestPermission(mAccessory, null);
}
} else {
BridgeApplication.getInstance().getBus().post(new RCConnectionEvent(false));
Log.d(TAG, "RC DISCONNECTED");
}
}
/**
* USB機器情報(ベンダー名・製品名・バージョン・シリアル等)を取得する
* @param manager
* @param device
* @param out
* @return
*/
@SuppressLint("NewApi")
public static UsbDeviceInfo getDeviceInfo(
@NonNull final UsbManager manager,
@Nullable final UsbDevice device, @Nullable final UsbDeviceInfo out) {
final UsbDeviceConnection connection
= (device != null && manager.hasPermission(device))
? manager.openDevice(device) : null;
try {
return getDeviceInfo(connection, device, out);
} finally {
if (connection != null) {
connection.close();
}
}
}
@ReactMethod
public void openDeviceAsync(ReadableMap deviceObject, Promise p) {
try {
int prodId = deviceObject.getInt("productId");
UsbManager manager = getUsbManager();
UsbSerialDriver driver = getUsbSerialDriver(prodId, manager);
if (manager.hasPermission(driver.getDevice())) {
WritableMap usd = createUsbSerialDevice(manager, driver);
p.resolve(usd);
} else {
requestUsbPermission(manager, driver.getDevice(), p);
}
} catch (Exception e) {
p.reject(e);
}
}
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction() == null)
return;
switch (intent.getAction()) {
case UsbManager.ACTION_USB_DEVICE_ATTACHED:
usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
if (usbManager == null)
break; // ???
if (usbManager.hasPermission(usbDevice))
isUsbDeviceAccessible = true;
else {
isUsbDeviceAccessible = false;
usbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(context, 0, new Intent(NsConstants.REQUEST_NS_ACCESS_INTENT), 0));
}
break;
case NsConstants.REQUEST_NS_ACCESS_INTENT:
isUsbDeviceAccessible = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false);
break;
case UsbManager.ACTION_USB_DEVICE_DETACHED:
usbDevice = null;
isUsbDeviceAccessible = false;
stopService(new Intent(context, CommunicationsService.class));
break;
case NsConstants.SERVICE_TRANSFER_TASK_FINISHED_INTENT:
ArrayList<NSPElement> nspElements = intent.getParcelableArrayListExtra(NsConstants.SERVICE_CONTENT_NSP_LIST);
if (nspElements == null)
break;
for (int i=0; i < mDataset.size(); i++){
for (NSPElement receivedNSPe : nspElements)
if (receivedNSPe.getFilename().equals(mDataset.get(i).getFilename()))
mDataset.get(i).setStatus(receivedNSPe.getStatus());
}
mAdapter.notifyDataSetChanged();
blockUI(false);
break;
}
}
private void checkUSBPermissionsAndConnectIfAllowed() {
UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
UsbDevice device = getAvailableUsbDevice();
if (device == null) return;
if (manager.hasPermission(device)) {
connectToUsbDevice();
return;
}
IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
registerReceiver(mUsbReceiver, filter);
manager.requestPermission(device, mPermissionIntent);
}
private void enumerate() {
l("enumerating");
UsbManager usbman = (UsbManager) activity
.getSystemService(Context.USB_SERVICE);
HashMap<String, UsbDevice> devlist = usbman.getDeviceList();
Iterator<UsbDevice> deviter = devlist.values().iterator();
PendingIntent pi = PendingIntent.getBroadcast(activity, 0, new Intent(
ACTION_USB_PERMISSION), 0);
while (deviter.hasNext()) {
UsbDevice d = deviter.next();
l("Found device: "
+ String.format("%04X:%04X", d.getVendorId(), d.getProductId()));
if (String.format("%04X:%04X", d.getVendorId(), d.getProductId()).equals(
VID_PID)) {
// we need to upload the hex file, first request permission
l("Device under: " + d.getDeviceName());
activity.registerReceiver(mPermissionReceiver, new IntentFilter(
ACTION_USB_PERMISSION));
if (!usbman.hasPermission(d))
usbman.requestPermission(d, pi);
else
init_USB(d);
// init_USB(d);
break;
}
}
l("no more devices found");
}
/**
* Attempts to connect to the specified accessory.
*
* If the permission is already granted, opens the accessory. Otherwise,
* requests permission to use it.
*
* @param accessory Accessory to connect to
*/
private void connectToAccessory(UsbAccessory accessory) {
if (accessory == null) {
handleTransportError("Can't connect to null accessory", null);
}
final State state = getState();
switch (state) {
case LISTENING:
UsbManager usbManager = getUsbManager();
if (usbManager.hasPermission(accessory)) {
logI("Already have permission to use " + accessory);
openAccessory(accessory);
} else {
logI("Requesting permission to use " + accessory);
PendingIntent permissionIntent = PendingIntent
.getBroadcast(getContext(), 0,
new Intent(ACTION_USB_PERMISSION), 0);
usbManager.requestPermission(accessory, permissionIntent);
}
break;
default:
logW("connectToAccessory() called from state " + state +
"; doing nothing");
}
}
private void connect(Boolean permissionGranted) {
UsbDevice device = null;
UsbManager usbManager = (UsbManager) getActivity().getSystemService(Context.USB_SERVICE);
for(UsbDevice v : usbManager.getDeviceList().values())
if(v.getDeviceId() == deviceId)
device = v;
if(device == null) {
status("connection failed: device not found");
return;
}
UsbSerialDriver driver = UsbSerialProber.getDefaultProber().probeDevice(device);
if(driver == null) {
driver = CustomProber.getCustomProber().probeDevice(device);
}
if(driver == null) {
status("connection failed: no driver for device");
return;
}
if(driver.getPorts().size() < portNum) {
status("connection failed: not enough ports at device");
return;
}
usbSerialPort = driver.getPorts().get(portNum);
UsbDeviceConnection usbConnection = usbManager.openDevice(driver.getDevice());
if(usbConnection == null && permissionGranted == null && !usbManager.hasPermission(driver.getDevice())) {
PendingIntent usbPermissionIntent = PendingIntent.getBroadcast(getActivity(), 0, new Intent(Constants.INTENT_ACTION_GRANT_USB), 0);
usbManager.requestPermission(driver.getDevice(), usbPermissionIntent);
return;
}
if(usbConnection == null) {
if (!usbManager.hasPermission(driver.getDevice()))
status("connection failed: permission denied");
else
status("connection failed: open failed");
return;
}
connected = Connected.Pending;
try {
usbSerialPort.open(usbConnection);
usbSerialPort.setParameters(baudRate, UsbSerialPort.DATABITS_8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE);
SerialSocket socket = new SerialSocket(getActivity().getApplicationContext(), usbConnection, usbSerialPort);
service.connect(socket);
// usb connect is not asynchronous. connect-success and connect-error are returned immediately from socket.connect
// for consistency to bluetooth/bluetooth-LE app use same SerialListener and SerialService classes
onSerialConnect();
} catch (Exception e) {
onSerialConnectError(e);
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Initialize ToolBar
Toolbar toolbar = findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
DrawerLayout drawer = findViewById(R.id.drawer_layout);
drawerNavView = findViewById(R.id.nav_view);
ActionBarDrawerToggle toggle = new ActionBarDrawerToggle(
this, drawer, toolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close);
drawer.addDrawerListener(toggle);
toggle.syncState();
drawerNavView.setNavigationItemSelectedListener(this);
// Initialize Progress Bar
progressBarMain = findViewById(R.id.mainProgressBar);
// Configure data set in case it's restored from screen rotation or something
if (savedInstanceState != null){
mDataset = savedInstanceState.getParcelableArrayList("DATASET_LIST");
// Restore USB device information
usbDevice = savedInstanceState.getParcelable("USB_DEVICE");
isUsbDeviceAccessible = savedInstanceState.getBoolean("IS_USB_DEV_ACCESSIBLE", false);
drawerNavView.setCheckedItem(savedInstanceState.getInt("PROTOCOL", R.id.nav_tf_usb));
nsResultReciever = savedInstanceState.getParcelable("RECEIVER");
}
else {
mDataset = new ArrayList<>();
usbDevice = getIntent().getParcelableExtra(UsbManager.EXTRA_DEVICE); // If it's started initially, then check if it's started from notification.
if (usbDevice != null){
UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
// If somehow we can't get system service
if (usbManager == null) {
NsNotificationPopUp.getAlertWindow(this, getResources().getString(R.string.popup_error), "Internal issue: getSystemService(Context.USB_SERVICE) returned null");
return; // ??? HOW ???
}
isUsbDeviceAccessible = usbManager.hasPermission(usbDevice);
}
else
isUsbDeviceAccessible = false;
switch (getSharedPreferences("NSUSBloader", MODE_PRIVATE).getInt("PROTOCOL", NsConstants.PROTO_TF_USB)){
case NsConstants.PROTO_TF_USB:
drawerNavView.setCheckedItem(R.id.nav_tf_usb);
break;
case NsConstants.PROTO_TF_NET:
drawerNavView.setCheckedItem(R.id.nav_tf_net);
break;
case NsConstants.PROTO_GL_USB:
drawerNavView.setCheckedItem(R.id.nav_gl);
break;
default:
}
nsResultReciever = new NsResultReciever(new Handler()); // We will set callback in onResume and unset onPause
}
recyclerView = findViewById(R.id.recyclerView);
RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
mAdapter = new NspItemsAdapter(mDataset);
recyclerView.setAdapter(mAdapter);
this.setSwipeFunctionsToView();
// Select files button
selectBtn = findViewById(R.id.buttonSelect);
selectBtn.setOnClickListener(e->{
Intent fileChooser = new Intent(Intent.ACTION_GET_CONTENT);
fileChooser.setType("application/octet-stream"); //fileChooser.setType("*/*"); ???
if (fileChooser.resolveActivity(getPackageManager()) != null)
startActivityForResult(Intent.createChooser(fileChooser, getString(R.string.select_file_btn)), ADD_NSP_INTENT_CODE);
else
NsNotificationPopUp.getAlertWindow(this, getResources().getString(R.string.popup_error), getResources().getString(R.string.install_file_explorer));
});
// Upload to NS button
uploadToNsBtn = findViewById(R.id.buttonUpload);
}
private void uploadFiles(){
ArrayList<NSPElement> NSPElementsToSend = new ArrayList<>();
for (NSPElement element: mDataset){
if (element.isSelected())
NSPElementsToSend.add(element);
}
// Do we have files to send?
if (NSPElementsToSend.isEmpty()){
Snackbar.make(findViewById(android.R.id.content), getString(R.string.nothing_selected_message), Snackbar.LENGTH_LONG).show();
return;
}
// Do we have selected protocol?
if (drawerNavView.getCheckedItem() == null) {
Snackbar.make(findViewById(android.R.id.content), getString(R.string.no_protocol_selected_message), Snackbar.LENGTH_LONG).show();
return;
}
Intent serviceStartIntent = new Intent(this, CommunicationsService.class);
serviceStartIntent.putExtra(NsConstants.NS_RESULT_RECEIVER, nsResultReciever);
serviceStartIntent.putParcelableArrayListExtra(NsConstants.SERVICE_CONTENT_NSP_LIST, NSPElementsToSend);
// Is it TF Net transfer?
if (drawerNavView.getCheckedItem().getItemId() == R.id.nav_tf_net){
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_PROTOCOL, NsConstants.PROTO_TF_NET);
SharedPreferences sp = getSharedPreferences("NSUSBloader", MODE_PRIVATE);
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_NS_DEVICE_IP, sp.getString("SNsIP", "192.168.1.42"));
if (sp.getBoolean("SAutoIP", true))
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_PHONE_IP, "");
else
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_PHONE_IP, sp.getString("SServerIP", "192.168.1.142"));
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_PHONE_PORT, sp.getInt("SServerPort", 6042));
startService(serviceStartIntent);
blockUI(true);
return;
}
// Ok, so it's something USB related
UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
// Do we have manager?
if (usbManager == null) {
NsNotificationPopUp.getAlertWindow(this, getResources().getString(R.string.popup_error), "Internal issue: getSystemService(Context.USB_SERVICE) returned null");
return;
}
// If device not connected
if (usbDevice == null){
HashMap<String, UsbDevice> deviceHashMap;
deviceHashMap = usbManager.getDeviceList();
for (UsbDevice device : deviceHashMap.values()) {
if (device.getVendorId() == 1406 && device.getProductId() == 12288) {
usbDevice = device;
}
}
// If it's still not connected then it's really not connected.
if (usbDevice == null) {
NsNotificationPopUp.getAlertWindow(this, getResources().getString(R.string.popup_error), getResources().getString(R.string.ns_not_found_in_connected));
return;
}
// If we have NS connected check for permissions
if (! usbManager.hasPermission(usbDevice)){
usbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(this, 0, new Intent(NsConstants.REQUEST_NS_ACCESS_INTENT), 0));
return;
}
}
if (! isUsbDeviceAccessible){
usbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(this, 0, new Intent(NsConstants.REQUEST_NS_ACCESS_INTENT), 0));
return;
}
switch (drawerNavView.getCheckedItem().getItemId()){
case R.id.nav_tf_usb:
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_PROTOCOL, NsConstants.PROTO_TF_USB);
break;
case R.id.nav_gl:
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_PROTOCOL, NsConstants.PROTO_GL_USB);
break;
default:
Snackbar.make(findViewById(android.R.id.content), getString(R.string.unknown_protocol_error), Snackbar.LENGTH_LONG).show(); // ?_?
return;
}
serviceStartIntent.putExtra(NsConstants.SERVICE_CONTENT_NS_DEVICE, usbDevice);
startService(serviceStartIntent);
blockUI(true);
}
private void connect() {
UsbDevice device = null;
UsbManager usbManager = (UsbManager) getActivity().getSystemService(Context.USB_SERVICE);
for(UsbDevice v : usbManager.getDeviceList().values())
if(v.getDeviceId() == deviceId)
device = v;
if(device == null) {
status("connection failed: device not found");
return;
}
UsbSerialDriver driver = UsbSerialProber.getDefaultProber().probeDevice(device);
if(driver == null) {
driver = CustomProber.getCustomProber().probeDevice(device);
}
if(driver == null) {
status("connection failed: no driver for device");
return;
}
if(driver.getPorts().size() < portNum) {
status("connection failed: not enough ports at device");
return;
}
usbSerialPort = driver.getPorts().get(portNum);
UsbDeviceConnection usbConnection = usbManager.openDevice(driver.getDevice());
if(usbConnection == null && usbPermission == UsbPermission.Unknown && !usbManager.hasPermission(driver.getDevice())) {
usbPermission = UsbPermission.Requested;
PendingIntent usbPermissionIntent = PendingIntent.getBroadcast(getActivity(), 0, new Intent(INTENT_ACTION_GRANT_USB), 0);
usbManager.requestPermission(driver.getDevice(), usbPermissionIntent);
return;
}
if(usbConnection == null) {
if (!usbManager.hasPermission(driver.getDevice()))
status("connection failed: permission denied");
else
status("connection failed: open failed");
return;
}
try {
usbSerialPort.open(usbConnection);
usbSerialPort.setParameters(baudRate, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE);
if(withIoManager) {
usbIoManager = new SerialInputOutputManager(usbSerialPort, this);
Executors.newSingleThreadExecutor().submit(usbIoManager);
}
status("connected");
connected = true;
controlLines.start();
} catch (Exception e) {
status("connection failed: " + e.getMessage());
disconnect();
}
}
/**
* ベンダー名・製品名・バージョン・シリアルを取得する
* @param manager
* @param device
* @param _info
* @return
*/
@TargetApi(Build.VERSION_CODES.M)
public static UsbDeviceInfo updateDeviceInfo(final UsbManager manager, final UsbDevice device, final UsbDeviceInfo _info) {
final UsbDeviceInfo info = _info != null ? _info : new UsbDeviceInfo();
info.clear();
if (device != null) {
if (BuildCheck.isLollipop()) {
info.manufacturer = device.getManufacturerName();
info.product = device.getProductName();
info.serial = device.getSerialNumber();
}
if (BuildCheck.isMarshmallow()) {
info.usb_version = device.getVersion();
}
if ((manager != null) && manager.hasPermission(device)) {
final UsbDeviceConnection connection = manager.openDevice(device);
if(connection == null) {
return null;
}
final byte[] desc = connection.getRawDescriptors();
if (TextUtils.isEmpty(info.usb_version)) {
info.usb_version = String.format("%x.%02x", ((int)desc[3] & 0xff), ((int)desc[2] & 0xff));
}
if (TextUtils.isEmpty(info.version)) {
info.version = String.format("%x.%02x", ((int)desc[13] & 0xff), ((int)desc[12] & 0xff));
}
if (TextUtils.isEmpty(info.serial)) {
info.serial = connection.getSerial();
}
final byte[] languages = new byte[256];
int languageCount = 0;
// controlTransfer(int requestType, int request, int value, int index, byte[] buffer, int length, int timeout)
try {
int result = connection.controlTransfer(
USB_REQ_STANDARD_DEVICE_GET, // USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE
USB_REQ_GET_DESCRIPTOR,
(USB_DT_STRING << 8) | 0, 0, languages, 256, 0);
if (result > 0) {
languageCount = (result - 2) / 2;
}
if (languageCount > 0) {
if (TextUtils.isEmpty(info.manufacturer)) {
info.manufacturer = getString(connection, desc[14], languageCount, languages);
}
if (TextUtils.isEmpty(info.product)) {
info.product = getString(connection, desc[15], languageCount, languages);
}
if (TextUtils.isEmpty(info.serial)) {
info.serial = getString(connection, desc[16], languageCount, languages);
}
}
} finally {
connection.close();
}
}
if (TextUtils.isEmpty(info.manufacturer)) {
info.manufacturer = USBVendorId.vendorName(device.getVendorId());
}
if (TextUtils.isEmpty(info.manufacturer)) {
info.manufacturer = String.format("%04x", device.getVendorId());
}
if (TextUtils.isEmpty(info.product)) {
info.product = String.format("%04x", device.getProductId());
}
}
return info;
}
private boolean hasUsbPermission() {
UsbManager usbManager = (UsbManager) this.getSystemService(Context.USB_SERVICE);
if (usbManager == null) return false;
UsbDevice cnlDevice = UsbHidDriver.getUsbDevice(usbManager, MedtronicCnlService.USB_VID, MedtronicCnlService.USB_PID);
return !(cnlDevice != null && !usbManager.hasPermission(cnlDevice));
}
/**
* ベンダー名・製品名・バージョン・シリアルを取得する
* @param manager
* @param device
* @param _info
* @return
*/
public static UsbDeviceInfo updateDeviceInfo(final UsbManager manager, final UsbDevice device, final UsbDeviceInfo _info) {
final UsbDeviceInfo info = _info != null ? _info : new UsbDeviceInfo();
info.clear();
if (device != null) {
if (BuildCheck.isLollipop()) {
info.manufacturer = device.getManufacturerName();
info.product = device.getProductName();
info.serial = device.getSerialNumber();
}
if (BuildCheck.isMarshmallow()) {
info.usb_version = device.getVersion();
}
if ((manager != null) && manager.hasPermission(device)) {
final UsbDeviceConnection connection = manager.openDevice(device);
final byte[] desc = connection.getRawDescriptors();
if (TextUtils.isEmpty(info.usb_version)) {
info.usb_version = String.format("%x.%02x", ((int)desc[3] & 0xff), ((int)desc[2] & 0xff));
}
if (TextUtils.isEmpty(info.version)) {
info.version = String.format("%x.%02x", ((int)desc[13] & 0xff), ((int)desc[12] & 0xff));
}
if (TextUtils.isEmpty(info.serial)) {
info.serial = connection.getSerial();
}
final byte[] languages = new byte[256];
int languageCount = 0;
// controlTransfer(int requestType, int request, int value, int index, byte[] buffer, int length, int timeout)
try {
int result = connection.controlTransfer(
USB_REQ_STANDARD_DEVICE_GET, // USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE
USB_REQ_GET_DESCRIPTOR,
(USB_DT_STRING << 8) | 0, 0, languages, 256, 0);
if (result > 0) {
languageCount = (result - 2) / 2;
}
if (languageCount > 0) {
if (TextUtils.isEmpty(info.manufacturer)) {
info.manufacturer = getString(connection, desc[14], languageCount, languages);
}
if (TextUtils.isEmpty(info.product)) {
info.product = getString(connection, desc[15], languageCount, languages);
}
if (TextUtils.isEmpty(info.serial)) {
info.serial = getString(connection, desc[16], languageCount, languages);
}
}
} finally {
connection.close();
}
}
if (TextUtils.isEmpty(info.manufacturer)) {
info.manufacturer = USBVendorId.vendorName(device.getVendorId());
}
if (TextUtils.isEmpty(info.manufacturer)) {
info.manufacturer = String.format("%04x", device.getVendorId());
}
if (TextUtils.isEmpty(info.product)) {
info.product = String.format("%04x", device.getProductId());
}
}
return info;
}
public void run() {
Log.d(TAG, "run readAndUpload");
try {
UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
boolean hasPermission = faking;
for (final UsbDevice usbDevice : usbManager.getDeviceList()
.values()) {
if (usbManager.hasPermission(usbDevice)) {
hasPermission = true;
}
}
if (!hasPermission) {
synchronized (checkSerialLock) {
Log.d(TAG, "I have lost usb permission changing listener attached to false...");
listenerAttached = false;
mSerial.clearReadListener();
mHandlerRead.removeCallbacks(readByListener);
sendMessageDisconnectedToUI();
if (!mHandlerActive || isDestroying){
Log.d(TAG,"destroy readAnd Upload "+ mHandlerActive + " isDes "+ isDestroying);
return;
}
mHandlerCheckSerial.removeCallbacks(readAndUpload);
mHandlerCheckSerial.postDelayed(readAndUpload, MedtronicConstants.FIVE_SECONDS__MS);
return;
}
} else
sendMessageConnectedToUI();
boolean connected;
synchronized (mSerialLock) {
connected = isConnected();
}
if (connected) {
if (!isOnline())
sendErrorMessageToUI("NET connection error");
if (!listenerAttached) {
Log.d(TAG, "!listener attached readByListener triggered");
mSerial.clearReadListener();
mHandlerRead.removeCallbacks(readByListener);
mSerial.addReadListener(readListener);
mHandlerRead.post(readByListener);
listenerAttached = true;
}
} else {
openUsbSerial(false);
connected = isConnected();
if (!connected)
sendErrorMessageToUI("Receptor connection error");
else if (!isOnline())
sendErrorMessageToUI("Not online/connection error");
else {
sendMessageConnectedToUI();
sendMessageToUI("connected");
}
}
} catch (Exception e) {
sendExceptionToUI("Unable to read from receptor or upload", e);
}
synchronized (checkSerialLock) {
if (!mHandlerActive || isDestroying){
Log.d(TAG,"destroy readAnd Upload2 "+ mHandlerActive + " isDes "+ isDestroying);
return;
}
mHandlerCheckSerial.removeCallbacks(readAndUpload);
mHandlerCheckSerial.postDelayed(readAndUpload, MedtronicConstants.FIVE_SECONDS__MS);
}
}
@Override
public void start()
{
if (sPort != null)
{
final UsbManager usbManager = (UsbManager) mContext.getSystemService(Context.USB_SERVICE);
if (usbManager == null)
{
connectionFailed();
return;
}
UsbDevice device = sPort.getDriver().getDevice();
if (!usbManager.hasPermission(device))
{
PendingIntent usbPermissionIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(INTENT_ACTION_GRANT_USB), 0);
usbManager.requestPermission(device, usbPermissionIntent);
connectionFailed();
return;
}
UsbDeviceConnection connection = usbManager.openDevice(sPort.getDriver().getDevice());
if (connection == null)
{
connectionFailed();
return;
}
try
{
sPort.open(connection);
sPort.setDTR(true);
sPort.setParameters(38400, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE);
log.info("Starting io manager ..");
Thread runner = new Thread(mSerialIoManager);
runner.setPriority(Thread.MAX_PRIORITY);
runner.start();
// we are connected -> signal connectionEstablished
connectionEstablished(sPort.toString());
}
catch (IOException e)
{
log.log(Level.SEVERE, "Error setting up device: " + e.getMessage(), e);
try
{
sPort.close();
}
catch (IOException e2)
{
// Ignore.
}
connectionFailed();
sPort = null;
}
}
}
/**
* Initialize the USB device. Determines endpoints and prepares communication.
*
* @param vid
* @param pid
* @throws IOException if the device cannot be opened
* @throws SecurityException
*/
public void initDevice(int vid, int pid) throws IOException, SecurityException {
mUsbManager = (UsbManager) mContext.getSystemService(Context.USB_SERVICE);
if (mUsbManager == null) {
throw new IllegalArgumentException("UsbManager == null!");
}
List<UsbDevice> usbDevices = findUsbDevices(mUsbManager, (short) vid, (short) pid);
if (usbDevices.isEmpty() || usbDevices.get(0) == null) {
throw new IOException("USB device not found. (VID: " + vid + ", PID: " + pid + ")");
}
// TODO: Only gets the first USB device that is found
this.mUsbDevice = usbDevices.get(0);
//request permissions
if (mUsbDevice != null && !mUsbManager.hasPermission(mUsbDevice)) {
Log.d(LOG_TAG, "Request permission");
mPermissionIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(mContext.getPackageName()+".USB_PERMISSION"), 0);
mUsbManager.requestPermission(mUsbDevice, mPermissionIntent);
} else if (mUsbDevice != null && mUsbManager.hasPermission(mUsbDevice)) {
Log.d(LOG_TAG, "Has permission");
} else {
Log.d(LOG_TAG, "device == null");
return;
}
Log.d(LOG_TAG, "setDevice " + this.mUsbDevice);
// find interface
if (this.mUsbDevice.getInterfaceCount() != 1) {
Log.e(LOG_TAG, "Could not find interface");
return;
}
mIntf = this.mUsbDevice.getInterface(0);
// device should have two endpoints
if (mIntf.getEndpointCount() != 2) {
Log.e(LOG_TAG, "Could not find endpoints");
return;
}
// endpoints should be of type bulk
UsbEndpoint ep = mIntf.getEndpoint(0);
if (ep.getType() != UsbConstants.USB_ENDPOINT_XFER_BULK) {
Log.e(LOG_TAG, "Endpoint is not of type bulk");
return;
}
// check endpoint direction
if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
mEpIn = mIntf.getEndpoint(0);
mEpOut = mIntf.getEndpoint(1);
} else {
mEpIn = mIntf.getEndpoint(1);
mEpOut = mIntf.getEndpoint(0);
}
UsbDeviceConnection connection = mUsbManager.openDevice(mUsbDevice);
if (connection != null && connection.claimInterface(mIntf, true)) {
Log.d(LOG_TAG, "open SUCCESS");
mConnection = connection;
} else {
Log.d(LOG_TAG, "open FAIL");
throw new IOException("could not open usb connection");
}
}