API tools faq
paste
Pavle_nis

usb_devices_list

Pavle_nis
Feb 4th, 2017
195
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 27.45 KB | None | 0 0
raw download clone embed print report
  1. USBInfoAPI.class
  2.  
  3.     public class USBInfoAPI extends AppCompatActivity
  4.     {
  5.         TextView textInfo;
  6.         TextView textInfoInterface;
  7.         TextView textEndPoint;
  8.    
  9.         Spinner spInterface;
  10.         ArrayList<String> listInterface;
  11.         ArrayList<UsbInterface> listUsbInterface;
  12.         ArrayAdapter<String> adapterInterface;
  13.    
  14.         Spinner spEndPoint;
  15.         ArrayList<String> listEndPoint;
  16.         ArrayList<UsbEndpoint> listUsbEndpoint;
  17.         ArrayAdapter<String> adapterEndpoint;
  18.    
  19.         UsbDevice deviceFound = null;
  20.    
  21.         private static final String ACTION_USB_PERMISSION =
  22.                 "com.android.example.USB_PERMISSION";
  23.         PendingIntent mPermissionIntent;
  24.    
  25.         UsbInterface usbInterface;
  26.         UsbDeviceConnection usbDeviceConnection;
  27.    
  28.         private int SETTINGS_ACTION = 1;
  29.    
  30.         @Override
  31.         protected void onCreate(Bundle savedInstanceState)
  32.         {
  33.             SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
  34.             boolean keep_screen = sharedPrefs.getBoolean("Keep screen on",false);
  35.             String theme = sharedPrefs.getString("Choose Theme","Light");
  36.             if(keep_screen)
  37.             {
  38.                 getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  39.             }
  40.             if(theme != null && theme.equals("Light"))
  41.             {
  42.                 setTheme(R.style.AppTheme);
  43.                 //setTheme(R.style.Theme_light);
  44.                 //Toast.makeText(AutoOTG.this,"Light theme",Toast.LENGTH_SHORT).show();
  45.             }
  46.             else
  47.             {
  48.                 setTheme(R.style.AppTheme_AppBarOverlay);
  49.                 //Toast.makeText(AutoOTG.this,"Dark theme",Toast.LENGTH_SHORT).show();
  50.             }
  51.    
  52.             super.onCreate(savedInstanceState);
  53.             setContentView(R.layout.usbinfoapi);
  54.    
  55.             Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
  56.             setSupportActionBar(toolbar);
  57.             getSupportActionBar().setTitle("USB Info");
  58.             if(getSupportActionBar() != null)
  59.             {
  60.                 getSupportActionBar().setDisplayHomeAsUpEnabled(true);
  61.                 getSupportActionBar().setDisplayShowHomeEnabled(true);
  62.             }
  63.    
  64.             spInterface = (Spinner)findViewById(R.id.spinnerinterface);
  65.             spEndPoint = (Spinner)findViewById(R.id.spinnerendpoint);
  66.             textInfo = (TextView) findViewById(R.id.info);
  67.             textInfoInterface = (TextView)findViewById(R.id.infointerface);
  68.             textEndPoint = (TextView)findViewById(R.id.infoendpoint);
  69.    
  70.             //register the broadcast receiver
  71.             mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
  72.             IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
  73.             registerReceiver(mUsbReceiver, filter);
  74.    
  75.             registerReceiver(mUsbDeviceReceiver, new IntentFilter(UsbManager.ACTION_USB_DEVICE_ATTACHED));
  76.             registerReceiver(mUsbDeviceReceiver, new IntentFilter(UsbManager.ACTION_USB_DEVICE_DETACHED));
  77.    
  78.             connectUsb();
  79.         }
  80.    
  81.         @Override
  82.         public boolean onOptionsItemSelected(MenuItem menuItem)
  83.         {
  84.             if(menuItem.getItemId() == android.R.id.home)
  85.                 finish();
  86.             return super.onOptionsItemSelected(menuItem);
  87.         }
  88.    
  89.         @Override
  90.         protected void onDestroy() {
  91.             releaseUsb();
  92.             unregisterReceiver(mUsbReceiver);
  93.             unregisterReceiver(mUsbDeviceReceiver);
  94.             super.onDestroy();
  95.         }
  96.    
  97.         private void connectUsb(){
  98.    
  99.             Toast.makeText(USBInfoAPI.this,
  100.                     "connectUsb()",
  101.                     Toast.LENGTH_LONG).show();
  102.             //textStatus.setText("connectUsb()");
  103.    
  104.             checkDeviceInfo();
  105.             if(deviceFound != null){
  106.                 doRawDescriptors();
  107.             }
  108.         }
  109.    
  110.         private void releaseUsb(){
  111.    
  112.             Toast.makeText(USBInfoAPI.this,
  113.                     "releaseUsb()",
  114.                     Toast.LENGTH_LONG).show();
  115.             //textStatus.setText("releaseUsb()");
  116.    
  117.             if(usbDeviceConnection != null){
  118.                 if(usbInterface != null){
  119.                     usbDeviceConnection.releaseInterface(usbInterface);
  120.                     usbInterface = null;
  121.                 }
  122.                 usbDeviceConnection.close();
  123.                 usbDeviceConnection = null;
  124.             }
  125.             deviceFound = null;
  126.         }
  127.    
  128.         private void doRawDescriptors(){
  129.             UsbDevice deviceToRead = deviceFound;
  130.             UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
  131.    
  132.             Boolean permitToRead = manager.hasPermission(deviceToRead);
  133.    
  134.             if(permitToRead){
  135.    
  136.             }else{
  137.                 manager.requestPermission(deviceToRead, mPermissionIntent);
  138.                 Toast.makeText(USBInfoAPI.this,
  139.                         "Permission: " + permitToRead,
  140.                         Toast.LENGTH_LONG).show();
  141.                 //textStatus.setText("Permission: " + permitToRead);
  142.             }
  143.         }
  144.    
  145.         private final BroadcastReceiver mUsbReceiver =
  146.                 new BroadcastReceiver() {
  147.    
  148.                     @Override
  149.                     public void onReceive(Context context, Intent intent) {
  150.                         String action = intent.getAction();
  151.                         if (ACTION_USB_PERMISSION.equals(action)) {
  152.    
  153.                             Toast.makeText(USBInfoAPI.this,
  154.                                     "ACTION_USB_PERMISSION",
  155.                                     Toast.LENGTH_LONG).show();
  156.                             //textStatus.setText("ACTION_USB_PERMISSION");
  157.    
  158.                             synchronized (this) {
  159.                                 UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
  160.    
  161.                                 if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
  162.                                     if(device != null){
  163.                                         // doReadRawDescriptors(device);
  164.                                     }
  165.                                 }
  166.                                 else {
  167.                                     Toast.makeText(USBInfoAPI.this,
  168.                                             "permission denied for device " + device,
  169.                                             Toast.LENGTH_LONG).show();
  170.                                     //textStatus.setText("permission denied for device " + device);
  171.                                 }
  172.                             }
  173.                         }
  174.                     }
  175.                 };
  176.    
  177.         private final BroadcastReceiver mUsbDeviceReceiver =
  178.                 new BroadcastReceiver() {
  179.    
  180.                     @Override
  181.                     public void onReceive(Context context, Intent intent) {
  182.                         String action = intent.getAction();
  183.                         if (UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(action)) {
  184.    
  185.                             deviceFound = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
  186.                             Toast.makeText(USBInfoAPI.this,
  187.                                     "ACTION_USB_DEVICE_ATTACHED: \n" +
  188.                                             deviceFound.toString(),
  189.                                     Toast.LENGTH_LONG).show();
  190.                             /*textStatus.setText("ACTION_USB_DEVICE_ATTACHED: \n" +
  191.                                     deviceFound.toString());*/
  192.    
  193.                             checkDeviceInfoSkipDeviceSearching();
  194.                             doRawDescriptors();
  195.                         }else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
  196.    
  197.                             UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
  198.    
  199.                             Toast.makeText(USBInfoAPI.this,
  200.                                     "ACTION_USB_DEVICE_DETACHED: \n" +
  201.                                             device.toString(),
  202.                                     Toast.LENGTH_LONG).show();
  203.                             /*textStatus.setText("ACTION_USB_DEVICE_DETACHED: \n" +
  204.                                     device.toString());*/
  205.    
  206.                             if(device!=null){
  207.                                 if(device == deviceFound){
  208.                                     releaseUsb();
  209.                                 }
  210.                             }
  211.    
  212.                             textInfo.setText("");
  213.                             textInfoInterface.setText("");
  214.                             textEndPoint.setText("");
  215.    
  216.                             listInterface.clear();
  217.                             listUsbInterface.clear();
  218.                             adapterInterface.notifyDataSetChanged();
  219.    
  220.                             listEndPoint.clear();
  221.                             listUsbEndpoint.clear();
  222.                             adapterEndpoint.notifyDataSetChanged();
  223.                         }
  224.                     }
  225.    
  226.                 };
  227.    
  228.         private void checkDeviceInfo() {
  229.    
  230.             deviceFound = null;
  231.    
  232.             UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
  233.             HashMap<String, UsbDevice> deviceList = manager.getDeviceList();
  234.             Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
  235.    
  236.             while (deviceIterator.hasNext()) {
  237.                 UsbDevice device = deviceIterator.next();
  238.    
  239.                 //if(device.getVendorId()==targetVendorID){
  240.                 //  if(device.getProductId()==targetProductID){
  241.                 deviceFound = device;
  242.                 // }
  243.                 // }
  244.             }
  245.    
  246.             textInfo.setText("");
  247.             textInfoInterface.setText("");
  248.             textEndPoint.setText("");
  249.    
  250.             if(deviceFound==null){
  251.                 Toast.makeText(USBInfoAPI.this,
  252.                         "device not found",
  253.                         Toast.LENGTH_LONG).show();
  254.                 //textStatus.setText("device not found");
  255.             }else{
  256.                 String i = deviceFound.toString() + "\n" +
  257.                         "DevicePath: " + deviceFound.getDeviceName() + "\n" +
  258.                         "DeviceClass: " + deviceFound.getDeviceClass() + " - "
  259.                         + translateDeviceClass(deviceFound.getDeviceClass()) + "\n" +
  260.                         "DeviceSubClass: " + deviceFound.getDeviceSubclass() + "\n" +
  261.                         "DeviceID: " + deviceFound.getDeviceId() + "\n" +
  262.                         "VendorID: " + deviceFound.getVendorId() + "\n" +
  263.                         "Vendor Name" + deviceFound.getDeviceName() + "\n" +
  264.                         "ProductID: " + deviceFound.getProductId() + "\n" +
  265.                         "Product Name" + deviceFound.getManufacturerName() + "\n" +
  266.                         "InterfaceCount: " + deviceFound.getInterfaceCount();
  267.                 textInfo.setText(i);
  268.    
  269.                 checkUsbDevicve(deviceFound);
  270.             }
  271.    
  272.         }
  273.    
  274.         private void checkDeviceInfoSkipDeviceSearching() {
  275.             //called when ACTION_USB_DEVICE_ATTACHED,
  276.             //device already found, skip device searching
  277.    
  278.             textInfo.setText("");
  279.             textInfoInterface.setText("");
  280.             textEndPoint.setText("");
  281.    
  282.             String i = deviceFound.toString() + "\n" +
  283.                     "DevicePath: " + deviceFound.getDeviceName() + "\n" +
  284.                     "DeviceClass: " + deviceFound.getDeviceClass() + " - "
  285.                     + translateDeviceClass(deviceFound.getDeviceClass()) + "\n" +
  286.                     "DeviceSubClass: " + deviceFound.getDeviceSubclass() + "\n" +
  287.                     "DeviceID: " + deviceFound.getDeviceId() + "\n" +
  288.                     "VendorID: " + deviceFound.getVendorId() + "\n" +
  289.                     "Vendor Name" + deviceFound.getDeviceName() + "\n" +
  290.                     "ProductID: " + deviceFound.getProductId() + "\n" +
  291.                     "Product Name" + deviceFound.getManufacturerName() + "\n" +
  292.                     "InterfaceCount: " + deviceFound.getInterfaceCount();
  293.             textInfo.setText(i);
  294.    
  295.             checkUsbDevicve(deviceFound);
  296.    
  297.         }
  298.    
  299.         OnItemSelectedListener deviceOnItemSelectedListener =
  300.                 new OnItemSelectedListener(){
  301.    
  302.                     @Override
  303.                     public void onItemSelected(AdapterView<?> parent,
  304.                                                View view, int position, long id) {
  305.                         UsbDevice device = deviceFound;
  306.    
  307.                         String i = device.toString() + "\n" +
  308.                                 "DevicePath: " + deviceFound.getDeviceName() + "\n" +
  309.                                 "DeviceClass: " + deviceFound.getDeviceClass() + " - "
  310.                                 + translateDeviceClass(deviceFound.getDeviceClass()) + "\n" +
  311.                                 "DeviceSubClass: " + deviceFound.getDeviceSubclass() + "\n" +
  312.                                 "DeviceID: " + deviceFound.getDeviceId() + "\n" +
  313.                                 "VendorID: " + deviceFound.getVendorId() + "\n" +
  314.                                 "Vendor Name" + deviceFound.getDeviceName() + "\n" +
  315.                                 "ProductID: " + deviceFound.getProductId() + "\n" +
  316.                                 "Product Name" + deviceFound.getManufacturerName() + "\n" +
  317.                                 "InterfaceCount: " + deviceFound.getInterfaceCount();
  318.                         textInfo.setText(i);
  319.    
  320.                         checkUsbDevicve(device);
  321.                     }
  322.    
  323.                     @Override
  324.                     public void onNothingSelected(AdapterView<?> parent) {}
  325.    
  326.                 };
  327.    
  328.         private void checkUsbDevicve(UsbDevice d) {
  329.             listInterface = new ArrayList<String>();
  330.             listUsbInterface = new ArrayList<UsbInterface>();
  331.    
  332.             for(int i=0; i<d.getInterfaceCount(); i++){
  333.                 UsbInterface usbif = d.getInterface(i);
  334.                 listInterface.add(usbif.toString());
  335.                 listUsbInterface.add(usbif);
  336.             }
  337.    
  338.             adapterInterface = new ArrayAdapter<String>(this,
  339.                     android.R.layout.simple_spinner_item, listInterface);
  340.             adapterInterface.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  341.             spInterface.setAdapter(adapterInterface);
  342.             spInterface.setOnItemSelectedListener(interfaceOnItemSelectedListener);
  343.         }
  344.    
  345.         OnItemSelectedListener interfaceOnItemSelectedListener =
  346.                 new OnItemSelectedListener(){
  347.    
  348.                     @Override
  349.                     public void onItemSelected(AdapterView<?> parent,
  350.                                                View view, int position, long id) {
  351.    
  352.                         UsbInterface selectedUsbIf = listUsbInterface.get(position);
  353.    
  354.                         String sUsbIf = "\n" + selectedUsbIf.toString() + "\n"
  355.                                 + "Id: " + selectedUsbIf.getId() + "\n"
  356.                                 + "InterfaceClass: " + selectedUsbIf.getInterfaceClass() + "\n"
  357.                                 + "InterfaceProtocol: " + selectedUsbIf.getInterfaceProtocol() + "\n"
  358.                                 + "InterfaceSubclass: " + selectedUsbIf.getInterfaceSubclass() + "\n"
  359.                                 + "EndpointCount: " + selectedUsbIf.getEndpointCount();
  360.    
  361.                         textInfoInterface.setText(sUsbIf);
  362.                         checkUsbInterface(selectedUsbIf);
  363.                     }
  364.    
  365.                     @Override
  366.                     public void onNothingSelected(AdapterView<?> parent) {}
  367.    
  368.                 };
  369.    
  370.         private void checkUsbInterface(UsbInterface uif) {
  371.             listEndPoint = new ArrayList<String>();
  372.             listUsbEndpoint = new ArrayList<UsbEndpoint>();
  373.    
  374.             for(int i=0; i<uif.getEndpointCount(); i++){
  375.                 UsbEndpoint usbEndpoint = uif.getEndpoint(i);
  376.                 listEndPoint.add(usbEndpoint.toString());
  377.                 listUsbEndpoint.add(usbEndpoint);
  378.             }
  379.    
  380.             adapterEndpoint = new ArrayAdapter<String>(this,
  381.                     android.R.layout.simple_spinner_item, listEndPoint);
  382.             adapterEndpoint.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  383.             spEndPoint.setAdapter(adapterEndpoint);
  384.             spEndPoint.setOnItemSelectedListener(endpointOnItemSelectedListener);
  385.         }
  386.    
  387.         OnItemSelectedListener endpointOnItemSelectedListener =
  388.                 new OnItemSelectedListener(){
  389.    
  390.                     @Override
  391.                     public void onItemSelected(AdapterView<?> parent,
  392.                                                View view, int position, long id) {
  393.    
  394.                         UsbEndpoint selectedEndpoint = listUsbEndpoint.get(position);
  395.    
  396.                         String sEndpoint = "\n" + selectedEndpoint.toString() + "\n"
  397.                                 + translateEndpointType(selectedEndpoint.getType());
  398.    
  399.                         textEndPoint.setText(sEndpoint);
  400.                     }
  401.    
  402.                     @Override
  403.                     public void onNothingSelected(AdapterView<?> parent) {}
  404.    
  405.                 };
  406.    
  407.         private String translateEndpointType(int type){
  408.             switch(type){
  409.                 case UsbConstants.USB_ENDPOINT_XFER_CONTROL:
  410.                     return "USB_ENDPOINT_XFER_CONTROL (endpoint zero)";
  411.                 case UsbConstants.USB_ENDPOINT_XFER_ISOC:
  412.                     return "USB_ENDPOINT_XFER_ISOC (isochronous endpoint)";
  413.                 case UsbConstants.USB_ENDPOINT_XFER_BULK :
  414.                     return "USB_ENDPOINT_XFER_BULK (bulk endpoint)";
  415.                 case UsbConstants.USB_ENDPOINT_XFER_INT:
  416.                     return "USB_ENDPOINT_XFER_INT (interrupt endpoint)";
  417.                 default:
  418.                     return "unknown";
  419.             }
  420.         }
  421.    
  422.         private String translateDeviceClass(int deviceClass){
  423.             switch(deviceClass){
  424.                 case UsbConstants.USB_CLASS_APP_SPEC:
  425.                     return "Application specific USB class";
  426.                 case UsbConstants.USB_CLASS_AUDIO:
  427.                     return "USB class for audio devices";
  428.                 case UsbConstants.USB_CLASS_CDC_DATA:
  429.                     return "USB class for CDC devices (communications device class)";
  430.                 case UsbConstants.USB_CLASS_COMM:
  431.                     return "USB class for communication devices";
  432.                 case UsbConstants.USB_CLASS_CONTENT_SEC:
  433.                     return "USB class for content security devices";
  434.                 case UsbConstants.USB_CLASS_CSCID:
  435.                     return "USB class for content smart card devices";
  436.                 case UsbConstants.USB_CLASS_HID:
  437.                     return "USB class for human interface devices (for example, mice and keyboards)";
  438.                 case UsbConstants.USB_CLASS_HUB:
  439.                     return "USB class for USB hubs";
  440.                 case UsbConstants.USB_CLASS_MASS_STORAGE:
  441.                     return "USB class for mass storage devices";
  442.                 case UsbConstants.USB_CLASS_MISC:
  443.                     return "USB class for wireless miscellaneous devices";
  444.                 case UsbConstants.USB_CLASS_PER_INTERFACE:
  445.                     return "USB class indicating that the class is determined on a per-interface basis";
  446.                 case UsbConstants.USB_CLASS_PHYSICA:
  447.                     return "USB class for physical devices";
  448.                 case UsbConstants.USB_CLASS_PRINTER:
  449.                     return "USB class for printers";
  450.                 case UsbConstants.USB_CLASS_STILL_IMAGE:
  451.                     return "USB class for still image devices (digital cameras)";
  452.                 case UsbConstants.USB_CLASS_VENDOR_SPEC:
  453.                     return "Vendor specific USB class";
  454.                 case UsbConstants.USB_CLASS_VIDEO:
  455.                     return "USB class for video devices";
  456.                 case UsbConstants.USB_CLASS_WIRELESS_CONTROLLER:
  457.                     return "USB class for wireless controller devices";
  458.                 default: return "Unknown USB class!";
  459.    
  460.             }
  461.         }
  462.     }
  463.  
  464. USBInfoLinux.class
  465.  
  466. public class USBInfoLinux extends AppCompatActivity
  467. {
  468.     public static final String DEVICE_PATH_KEY = "devicePath";
  469.  
  470.     private static final String[] fieldList = new String[]{ "bDeviceClass", "bDeviceSubClass", "idVendor", "manufacturer",
  471.             "idProduct", "product", "version", "speed", "bDeviceProtocol", "bMaxPower", "serial" };
  472.  
  473.     private TextView textView1,textView2;
  474.  
  475.     private static class InfoField
  476.     {
  477.         String field;
  478.         String value;
  479.  
  480.         InfoField(String field, String value)
  481.         {
  482.             this.field = field;
  483.             this.value = value;
  484.         }
  485.  
  486.         @Override
  487.         public String toString()
  488.         {
  489.             return field+": "+value;
  490.         }
  491.  
  492.     }
  493.  
  494.     private static String getValue(String path)
  495.     {
  496.         File file = new File(path);
  497.  
  498.         if (!file.isDirectory())
  499.         {
  500.             try
  501.             {
  502.                 FileReader fileReader = new FileReader(file);
  503.  
  504.                 BufferedReader bufferedReader = new BufferedReader(fileReader);
  505.                 String line = bufferedReader.readLine();
  506.                 bufferedReader.close();
  507.                 return line;
  508.             }
  509.             catch (IOException e)
  510.             {
  511.                 e.printStackTrace();
  512.                 return null;
  513.             }
  514.         }
  515.  
  516.         return null;
  517.     }
  518.  
  519.     @Override
  520.     protected void onCreate(Bundle savedInstanceState)
  521.     {
  522.         SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
  523.         boolean keep_screen = sharedPrefs.getBoolean("Keep screen on",false);
  524.         String theme = sharedPrefs.getString("Choose Theme","Light");
  525.         if(keep_screen)
  526.         {
  527.             getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  528.         }
  529.         if(theme != null && theme.equals("Light"))
  530.         {
  531.             setTheme(R.style.AppTheme);
  532.             //setTheme(R.style.Theme_light);
  533.             //Toast.makeText(AutoOTG.this,"Light theme",Toast.LENGTH_SHORT).show();
  534.         }
  535.         else
  536.         {
  537.             setTheme(R.style.AppTheme_AppBarOverlay);
  538.             //Toast.makeText(AutoOTG.this,"Dark theme",Toast.LENGTH_SHORT).show();
  539.         }
  540.  
  541.         super.onCreate(savedInstanceState);
  542.         setContentView(R.layout.usbinfolinux);
  543.  
  544.         textView1 = (TextView) findViewById(R.id.textView3);
  545.         textView2 = (TextView) findViewById(R.id.textView4);
  546.  
  547.         Intent intent = getIntent();
  548.         if (intent.getExtras() == null)
  549.             finish();
  550.         String devicePath = intent.getExtras().getString(DEVICE_PATH_KEY);
  551.  
  552.         try
  553.         {
  554.             String path = devicePath + "/" + "idVendor";
  555.             FileReader fileReader = new FileReader(path);
  556.             BufferedReader bufferedReader = new BufferedReader(fileReader);
  557.             String line = bufferedReader.readLine();
  558.             bufferedReader.close();
  559.  
  560.             String path1 = devicePath + "/" + "bDeviceClass";
  561.             FileReader fileReader1 = new FileReader(path1);
  562.             BufferedReader bufferedReader1 = new BufferedReader(fileReader1);
  563.             String deviceclass = bufferedReader1.readLine();
  564.             bufferedReader1.close();
  565.  
  566.             String path2 = devicePath + "/" + "bDeviceSubClass";
  567.             FileReader fileReader2 = new FileReader(path2);
  568.             BufferedReader bufferedReader2 = new BufferedReader(fileReader2);
  569.             String devicesubclass = bufferedReader2.readLine();
  570.             bufferedReader2.close();
  571.  
  572.             String path3 = devicePath + "/" + "idVendor";
  573.             FileReader fileReader3 = new FileReader(path3);
  574.             BufferedReader bufferedReader3 = new BufferedReader(fileReader3);
  575.             String idVendor = bufferedReader3.readLine();
  576.             bufferedReader3.close();
  577.  
  578.             String path4 = devicePath + "/" + "manufacturer";
  579.             FileReader fileReader4 = new FileReader(path4);
  580.             BufferedReader bufferedReader4 = new BufferedReader(fileReader4);
  581.             String manufacturer = bufferedReader4.readLine();
  582.             bufferedReader4.close();
  583.  
  584.             String path5 = devicePath + "/" + "idProduct";
  585.             FileReader fileReader5 = new FileReader(path5);
  586.             BufferedReader bufferedReader5 = new BufferedReader(fileReader5);
  587.             String idProduct = bufferedReader5.readLine();
  588.             bufferedReader5.close();
  589.  
  590.             String path6 = devicePath + "/" + "product";
  591.             FileReader fileReader6 = new FileReader(path6);
  592.             BufferedReader bufferedReader6 = new BufferedReader(fileReader6);
  593.             String product = bufferedReader6.readLine();
  594.             bufferedReader6.close();
  595.  
  596.             textView1.setText("Path : " + devicePath + "\n" + "Device Class :" + deviceclass + "\n" +
  597.                     "Device SubClass :" + devicesubclass + "\n" + "Vendor ID :" + idVendor + "\n" +
  598.                     "Vendor Name :" + manufacturer + "\n" + "Product ID :" + idProduct + "\n" +
  599.                     "Product Name :" + product);
  600.  
  601.             String path7 = devicePath + "/" + "version";
  602.             FileReader fileReader7 = new FileReader(path7);
  603.             BufferedReader bufferedReader7 = new BufferedReader(fileReader7);
  604.             String version = bufferedReader7.readLine();
  605.             bufferedReader7.close();
  606.  
  607.             String path8 = devicePath + "/" + "speed";
  608.             FileReader fileReader8 = new FileReader(path8);
  609.             BufferedReader bufferedReader8 = new BufferedReader(fileReader8);
  610.             String speed = bufferedReader8.readLine();
  611.             bufferedReader8.close();
  612.  
  613.             String path9 = devicePath + "/" + "bDeviceProtocol";
  614.             FileReader fileReader9 = new FileReader(path9);
  615.             BufferedReader bufferedReader9 = new BufferedReader(fileReader9);
  616.             String deviceprotocol = bufferedReader9.readLine();
  617.             bufferedReader9.close();
  618.  
  619.             String path10 = devicePath + "/" + "bMaxPower";
  620.             FileReader fileReader10 = new FileReader(path10);
  621.             BufferedReader bufferedReader10 = new BufferedReader(fileReader10);
  622.             String maximumpower = bufferedReader10.readLine();
  623.             bufferedReader10.close();
  624.  
  625.             String path11 = devicePath + "/" + "serial";
  626.             FileReader fileReader11 = new FileReader(path11);
  627.             BufferedReader bufferedReader11 = new BufferedReader(fileReader11);
  628.             String serial = bufferedReader11.readLine();
  629.             bufferedReader11.close();
  630.  
  631.             textView2.setText("USB Version : " + version + "\n" + "Speed :" + speed + "\n" +
  632.                     "Protocol :" + deviceprotocol + "\n" + "Maximum Power :" + maximumpower + "\n" +
  633.                     "Serial Number :" + serial);
  634.         }
  635.         catch(IOException ie)
  636.         {
  637.             ie.printStackTrace();
  638.         }
  639.     }
  640. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!