API tools faq
paste
Guest User

Untitled

a guest
Dec 21st, 2016
147
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 23.42 KB | None | 0 0
raw download clone embed print report
  1. package com.myproject.mylibrary.j2xx;
  2.  
  3. import android.app.PendingIntent;
  4. import android.content.BroadcastReceiver;
  5. import android.content.Context;
  6. import android.content.Intent;
  7. import android.content.IntentFilter;
  8. import android.hardware.usb.UsbDevice;
  9. import android.hardware.usb.UsbManager;
  10. import android.util.Log;
  11.  
  12. import java.io.IOException;
  13. import java.lang.reflect.Array;
  14. import java.util.ArrayList;
  15. import java.util.Arrays;
  16. import java.util.List;
  17.  
  18. import static android.R.transition.move;
  19.  
  20. public class D2xxManager {
  21.     protected static final String ACTION_USB_PERMISSION = "com.myproject.mylibrary.j2xx";
  22.     public static final int FTDI_BREAK_OFF = 0;
  23.     public static final int FTDI_BREAK_ON = 16384;
  24.     public static final byte FT_BI = (byte) 16;
  25.     public static final byte FT_BITMODE_ASYNC_BITBANG = (byte) 1;
  26.     public static final byte FT_BITMODE_CBUS_BITBANG = (byte) 32;
  27.     public static final byte FT_BITMODE_FAST_SERIAL = (byte) 16;
  28.     public static final byte FT_BITMODE_MCU_HOST = (byte) 8;
  29.     public static final byte FT_BITMODE_MPSSE = (byte) 2;
  30.     public static final byte FT_BITMODE_RESET = (byte) 0;
  31.     public static final byte FT_BITMODE_SYNC_BITBANG = (byte) 4;
  32.     public static final byte FT_BITMODE_SYNC_FIFO = (byte) 64;
  33.     public static final byte FT_CTS = (byte) 16;
  34.     public static final byte FT_DATA_BITS_7 = (byte) 7;
  35.     public static final byte FT_DATA_BITS_8 = (byte) 8;
  36.     public static final byte FT_DCD = Byte.MIN_VALUE;
  37.     public static final int FT_DEVICE_2232 = 4;
  38.     public static final int FT_DEVICE_2232H = 6;
  39.     public static final int FT_DEVICE_232B = 0;
  40.     public static final int FT_DEVICE_232H = 8;
  41.     public static final int FT_DEVICE_232R = 5;
  42.     public static final int FT_DEVICE_245R = 5;
  43.     public static final int FT_DEVICE_4222_0 = 10;
  44.     public static final int FT_DEVICE_4222_1_2 = 11;
  45.     public static final int FT_DEVICE_4222_3 = 12;
  46.     public static final int FT_DEVICE_4232H = 7;
  47.     public static final int FT_DEVICE_8U232AM = 1;
  48.     public static final int FT_DEVICE_UNKNOWN = 3;
  49.     public static final int FT_DEVICE_X_SERIES = 9;
  50.     public static final byte FT_DSR = (byte) 32;
  51.     public static final byte FT_EVENT_LINE_STATUS = (byte) 4;
  52.     public static final byte FT_EVENT_MODEM_STATUS = (byte) 2;
  53.     public static final byte FT_EVENT_REMOVED = (byte) 8;
  54.     public static final byte FT_EVENT_RXCHAR = (byte) 1;
  55.     public static final byte FT_FE = (byte) 8;
  56.     public static final byte FT_FLAGS_HI_SPEED = (byte) 2;
  57.     public static final byte FT_FLAGS_OPENED = (byte) 1;
  58.     public static final short FT_FLOW_DTR_DSR = (short) 512;
  59.     public static final short FT_FLOW_NONE = (short) 0;
  60.     public static final short FT_FLOW_RTS_CTS = (short) 256;
  61.     public static final short FT_FLOW_XON_XOFF = (short) 1024;
  62.     public static final byte FT_OE = (byte) 2;
  63.     public static final byte FT_PARITY_EVEN = (byte) 2;
  64.     public static final byte FT_PARITY_MARK = (byte) 3;
  65.     public static final byte FT_PARITY_NONE = (byte) 0;
  66.     public static final byte FT_PARITY_ODD = (byte) 1;
  67.     public static final byte FT_PARITY_SPACE = (byte) 4;
  68.     public static final byte FT_PE = (byte) 4;
  69.     public static final byte FT_PURGE_RX = (byte) 1;
  70.     public static final byte FT_PURGE_TX = (byte) 2;
  71.     public static final byte FT_RI = (byte) 64;
  72.     public static final byte FT_STOP_BITS_1 = (byte) 0;
  73.     public static final byte FT_STOP_BITS_2 = (byte) 2;
  74.     private static final String TAG = "D2xx::";
  75.     private static Context mContext;
  76.     private static D2xxManager mInstance;
  77.     private static PendingIntent mPendingIntent;
  78.     private static IntentFilter mPermissionFilter;
  79.     private static List<FtVidPid> mSupportedDevices;
  80.     private static BroadcastReceiver mUsbDevicePermissions;
  81.     private static UsbManager mUsbManager;
  82.     private ArrayList<FT_Device> mFtdiDevices;
  83.     private BroadcastReceiver mUsbPlugEvents;
  84.  
  85.     /* renamed from: com.myproject.mylibrary.j2xx.D2xxManager.1 */
  86.     class C00001 extends BroadcastReceiver {
  87.         C00001() {
  88.         }
  89.  
  90.         public void onReceive(Context context, Intent intent) {
  91.             String action = intent.getAction();
  92.             if ("android.hardware.usb.action.USB_DEVICE_DETACHED".equals(action)) {
  93.                 UsbDevice dev = (UsbDevice) intent.getParcelableExtra("device");
  94.                 FT_Device ftDev = D2xxManager.this.findDevice(dev);
  95.                 while (ftDev != null) {
  96.                     ftDev.close();
  97.                     synchronized (D2xxManager.this.mFtdiDevices) {
  98.                         D2xxManager.this.mFtdiDevices.remove(ftDev);
  99.                     }
  100.                     ftDev = D2xxManager.this.findDevice(dev);
  101.                 }
  102.             } else if ("android.hardware.usb.action.USB_DEVICE_ATTACHED".equals(action)) {
  103.                 D2xxManager.this.addUsbDevice((UsbDevice) intent.getParcelableExtra("device"));
  104.             }
  105.         }
  106.     }
  107.  
  108.     /* renamed from: com.myproject.mylibrary.j2xx.D2xxManager.2 */
  109.     static class C00012 extends BroadcastReceiver {
  110.         C00012() {
  111.         }
  112.  
  113.         public void onReceive(Context context, Intent intent) {
  114.             if (D2xxManager.ACTION_USB_PERMISSION.equals(intent.getAction())) {
  115.                 synchronized (this) {
  116.                     UsbDevice device = (UsbDevice) intent.getParcelableExtra("device");
  117.                     if (!intent.getBooleanExtra("permission", false)) {
  118.                         Log.d(D2xxManager.TAG, "permission denied for device " + device);
  119.                     }
  120.                 }
  121.             }
  122.         }
  123.     }
  124.  
  125.     public static class D2xxException extends IOException {
  126.         private static final long serialVersionUID = 1;
  127.  
  128.         public D2xxException(String ftStatusMsg) {
  129.             super(ftStatusMsg);
  130.         }
  131.     }
  132.  
  133.     public static class DriverParameters {
  134.         private int mBufferSize;
  135.         private int mMaxTransferSize;
  136.         private int mNrBuffers;
  137.         private int mRxTimeout;
  138.  
  139.         public DriverParameters() {
  140.             this.mBufferSize = D2xxManager.FTDI_BREAK_ON;
  141.             this.mMaxTransferSize = D2xxManager.FTDI_BREAK_ON;
  142.             this.mNrBuffers = 16;
  143.             this.mRxTimeout = 5000;
  144.         }
  145.  
  146.         public boolean setMaxBufferSize(int size) {
  147.             if (size < 64 || size > 262144) {
  148.                 Log.e(D2xxManager.TAG, "***bufferSize Out of correct range***");
  149.                 return false;
  150.             }
  151.             this.mBufferSize = size;
  152.             return true;
  153.         }
  154.  
  155.         public int getMaxBufferSize() {
  156.             return this.mBufferSize;
  157.         }
  158.  
  159.         public boolean setMaxTransferSize(int size) {
  160.             if (size < 64 || size > 262144) {
  161.                 Log.e(D2xxManager.TAG, "***maxTransferSize Out of correct range***");
  162.                 return false;
  163.             }
  164.             this.mMaxTransferSize = size;
  165.             return true;
  166.         }
  167.  
  168.         public int getMaxTransferSize() {
  169.             return this.mMaxTransferSize;
  170.         }
  171.  
  172.         public boolean setBufferNumber(int number) {
  173.             if (number < 2 || number > 16) {
  174.                 Log.e(D2xxManager.TAG, "***nrBuffers Out of correct range***");
  175.                 return false;
  176.             }
  177.             this.mNrBuffers = number;
  178.             return true;
  179.         }
  180.  
  181.         public int getBufferNumber() {
  182.             return this.mNrBuffers;
  183.         }
  184.  
  185.         public boolean setReadTimeout(int timeout) {
  186.             this.mRxTimeout = timeout;
  187.             return true;
  188.         }
  189.  
  190.         public int getReadTimeout() {
  191.             return this.mRxTimeout;
  192.         }
  193.     }
  194.  
  195.     public static class FtDeviceInfoListNode {
  196.         public short bcdDevice;
  197.         public int breakOnParam;
  198.         public String description;
  199.         public int flags;
  200.         public int handle;
  201.         public byte iSerialNumber;
  202.         public int id;
  203.         public short lineStatus;
  204.         public int location;
  205.         public short modemStatus;
  206.         public String serialNumber;
  207.         public int type;
  208.     }
  209.  
  210.     static {
  211.         mInstance = null;
  212.         mContext = null;
  213.         mPendingIntent = null;
  214.         mPermissionFilter = null;
  215.         mSupportedDevices = new ArrayList(Arrays.asList(new FtVidPid[]{new FtVidPid(1027, 24597), new FtVidPid(1027, 24596), new FtVidPid(1027, 24593), new FtVidPid(1027, 24592), new FtVidPid(1027, 24577), new FtVidPid(1027, 24582), new FtVidPid(1027, 24604), new FtVidPid(1027, 64193), new FtVidPid(1027, 64194), new FtVidPid(1027, 64195), new FtVidPid(1027, 64196), new FtVidPid(1027, 64197), new FtVidPid(1027, 64198), new FtVidPid(1027, 24594), new FtVidPid(2220, 4133), new FtVidPid(5590, FT_DEVICE_8U232AM), new FtVidPid(1027, 24599)}));
  216.         mUsbDevicePermissions = new C00012();
  217.     }
  218.  
  219.     private FT_Device findDevice(UsbDevice usbDev) {
  220.         FT_Device rtDev = null;
  221.         synchronized (this.mFtdiDevices) {
  222.             int nr_dev = this.mFtdiDevices.size();
  223.             for (int i = FT_DEVICE_232B; i < nr_dev; i += FT_DEVICE_8U232AM) {
  224.                 FT_Device ftDevice = (FT_Device) this.mFtdiDevices.get(i);
  225.                 if (ftDevice.getUsbDevice().equals(usbDev)) {
  226.                     rtDev = ftDevice;
  227.                     break;
  228.                 }
  229.             }
  230.         }
  231.         return rtDev;
  232.     }
  233.  
  234.     public boolean isFtDevice(UsbDevice dev) {
  235.         boolean rc = false;
  236.         if (mContext == null) {
  237.             return Boolean.parseBoolean(String.valueOf(FT_DEVICE_232B));
  238.         }
  239.         FtVidPid vidPid = new FtVidPid(dev.getVendorId(), dev.getProductId());
  240.         if (mSupportedDevices.contains(vidPid)) {
  241.             rc = true;
  242.         }
  243.         Log.v(TAG, vidPid.toString());
  244.         return rc;
  245.     }
  246.  
  247.     private static synchronized boolean updateContext(Context context) {
  248.         boolean rc = false;
  249.         synchronized (D2xxManager.class) {
  250.             if (context == null) {
  251.                 rc = false;
  252.             } else {
  253.                 if (mContext != context) {
  254.                     mContext = context;
  255.                     mPendingIntent = PendingIntent.getBroadcast(mContext.getApplicationContext(), FT_DEVICE_232B, new Intent(ACTION_USB_PERMISSION), PendingIntent.FLAG_ONE_SHOT); //Wpisane, aby było. To było oryginalnie -> 134217728
  256.                     mPermissionFilter = new IntentFilter(ACTION_USB_PERMISSION);
  257.                     mContext.getApplicationContext().registerReceiver(mUsbDevicePermissions, mPermissionFilter);
  258.                 }
  259.                 rc = true;
  260.             }
  261.         }
  262.         return rc;
  263.     }
  264.  
  265.     private boolean isPermitted(UsbDevice dev) {
  266.         if (!mUsbManager.hasPermission(dev)) {
  267.             mUsbManager.requestPermission(dev, mPendingIntent);
  268.         }
  269.         if (mUsbManager.hasPermission(dev)) {
  270.             return true;
  271.         }
  272.         return false;
  273.     }
  274.  
  275.     private D2xxManager(Context parentContext) throws D2xxException {
  276.         this.mUsbPlugEvents = new C00001();
  277.         Log.v(TAG, "Start constructor");
  278.         if (parentContext == null) {
  279.             throw new D2xxException("D2xx init failed: Can not find parentContext!");
  280.         }
  281.         updateContext(parentContext);
  282.         if (findUsbManger()) {
  283.             this.mFtdiDevices = new ArrayList();
  284.             IntentFilter filter = new IntentFilter();
  285.             filter.addAction("android.hardware.usb.action.USB_DEVICE_ATTACHED");
  286.             filter.addAction("android.hardware.usb.action.USB_DEVICE_DETACHED");
  287.             parentContext.getApplicationContext().registerReceiver(this.mUsbPlugEvents, filter);
  288.             Log.v(TAG, "End constructor");
  289.             return;
  290.         }
  291.         throw new D2xxException("D2xx init failed: Can not find UsbManager!");
  292.     }
  293.  
  294.     public static synchronized D2xxManager getInstance(Context parentContext) throws D2xxException {
  295.         D2xxManager d2xxManager;
  296.         synchronized (D2xxManager.class) {
  297.             if (mInstance == null) {
  298.                 mInstance = new D2xxManager(parentContext);
  299.             }
  300.             if (parentContext != null) {
  301.                 updateContext(parentContext);
  302.             }
  303.             d2xxManager = mInstance;
  304.         }
  305.         return d2xxManager;
  306.     }
  307.  
  308.     private static boolean findUsbManger() {
  309.         if (mUsbManager == null && mContext != null) {
  310.             mUsbManager = (UsbManager) mContext.getApplicationContext().getSystemService(Context.USB_SERVICE);
  311.         }
  312.         return mUsbManager != null;
  313.     }
  314.  
  315.     public boolean setVIDPID(int vendorId, int productId) {
  316.         boolean rc = false;
  317.         if (vendorId == 0 || productId == 0) {
  318.             Log.d(TAG, "Invalid parameter to setVIDPID");
  319.         } else {
  320.             FtVidPid vidpid = new FtVidPid(vendorId, productId);
  321.             if (mSupportedDevices.contains(vidpid)) {
  322.                 Log.i(TAG, "Existing vid:" + vendorId + "  pid:" + productId);
  323.                 return true;
  324.             } else if (mSupportedDevices.add(vidpid)) {
  325.                 rc = true;
  326.             } else {
  327.                 Log.d(TAG, "Failed to add VID/PID combination to list.");
  328.             }
  329.         }
  330.         return rc;
  331.     }
  332.  
  333.     public int[][] getVIDPID() {
  334.         int listSize = mSupportedDevices.size();
  335.         int[][] arrayVIDPID = (int[][]) Array.newInstance(Integer.TYPE, new int[]{2, listSize});
  336.         for (int i = FT_DEVICE_232B; i < listSize; i += FT_DEVICE_8U232AM) {
  337.             FtVidPid vidpid = (FtVidPid) mSupportedDevices.get(i);
  338.             arrayVIDPID[FT_DEVICE_232B][i] = vidpid.getVid();
  339.             arrayVIDPID[FT_DEVICE_8U232AM][i] = vidpid.getPid();
  340.         }
  341.         return arrayVIDPID;
  342.     }
  343.  
  344.     private void clearDevices() {
  345.         synchronized (this.mFtdiDevices) {
  346.             int nr_dev = this.mFtdiDevices.size();
  347.             for (int i = FT_DEVICE_232B; i < nr_dev; i += FT_DEVICE_8U232AM) {
  348.                 this.mFtdiDevices.remove(FT_DEVICE_232B);
  349.             }
  350.         }
  351.     }
  352.  
  353.     public int createDeviceInfoList(Context parentContext) {
  354.         ArrayList<FT_Device> devices = new ArrayList();
  355.         if (parentContext == null) {
  356.             return FT_DEVICE_232B;
  357.         }
  358.         int rc;
  359.         updateContext(parentContext);
  360.         for (UsbDevice usbDevice : mUsbManager.getDeviceList().values()) {
  361.             if (isFtDevice(usbDevice)) {
  362.                 int numInterfaces = usbDevice.getInterfaceCount();
  363.                 for (int i = FT_DEVICE_232B; i < numInterfaces; i += FT_DEVICE_8U232AM) {
  364.                     if (isPermitted(usbDevice)) {
  365.                         synchronized (this.mFtdiDevices) {
  366.                             FT_Device ftDev = findDevice(usbDevice);
  367.                             if (ftDev == null) {
  368.                                 ftDev = new FT_Device(parentContext, mUsbManager, usbDevice, usbDevice.getInterface(i));
  369.                             } else {
  370.                                 this.mFtdiDevices.remove(ftDev);
  371.                                 ftDev.setContext(parentContext);
  372.                             }
  373.                             devices.add(ftDev);
  374.                         }
  375.                     }
  376.                 }
  377.                 continue;
  378.             }
  379.         }
  380.         synchronized (this.mFtdiDevices) {
  381.             clearDevices();
  382.             this.mFtdiDevices = devices;
  383.             rc = this.mFtdiDevices.size();
  384.         }
  385.         return rc;
  386.     }
  387.  
  388.       // JADX WARNING: inconsistent code.
  389.       // Code decompiled incorrectly, please refer to instructions dump.
  390.     public synchronized int getDeviceInfoList(int r3, com.myproject.mylibrary.j2xx.D2xxManager.FtDeviceInfoListNode[] r4) {
  391.  
  392.         r2 = this;
  393.         monitor-enter(r2);
  394.         r0 = 0;
  395.     L_0x0002:
  396.         if (r0 < r3) goto L_0x000c;
  397.     L_0x0004:
  398.         r1 = r2.mFtdiDevices;    Catch:{ all -> 0x001b }
  399.         r1 = r1.size();  Catch:{ all -> 0x001b }
  400.         monitor-exit(r2);
  401.         return r1;
  402.     L_0x000c:
  403.         r1 = r2.mFtdiDevices;    Catch:{ all -> 0x001b }
  404.         r1 = r1.get(r0);     Catch:{ all -> 0x001b }
  405.         r1 = (com.ftdi.j2xx.FT_Device) r1;   Catch:{ all -> 0x001b }
  406.         r1 = r1.mDeviceInfoNode;     Catch:{ all -> 0x001b }
  407.         r4[r0] = r1;     Catch:{ all -> 0x001b }
  408.         r0 = r0 + 1;
  409.         goto L_0x0002;
  410.     L_0x001b:
  411.         r1 = move-exception;
  412.         monitor-exit(r2);
  413.         throw r1;
  414.  
  415.         throw new UnsupportedOperationException("Method not decompiled: com.ftdi.j2xx.D2xxManager.getDeviceInfoList(int, com.ftdi.j2xx.D2xxManager$FtDeviceInfoListNode[]):int");
  416.     }
  417.  
  418.  
  419.     public synchronized FtDeviceInfoListNode getDeviceInfoListDetail(int index) {
  420.         FtDeviceInfoListNode ftDeviceInfoListNode;
  421.         if (index > this.mFtdiDevices.size() || index < 0) {
  422.             ftDeviceInfoListNode = null;
  423.         } else {
  424.             ftDeviceInfoListNode = ((FT_Device) this.mFtdiDevices.get(index)).mDeviceInfoNode;
  425.         }
  426.         return ftDeviceInfoListNode;
  427.     }
  428.  
  429.     public static int getLibraryVersion() {
  430.         return 543162368;
  431.     }
  432.  
  433.     private boolean tryOpen(Context parentContext, FT_Device ftDev, DriverParameters params) {
  434.         boolean rc = false;
  435.         if (ftDev == null) {
  436.             return Boolean.getBoolean(String.valueOf(FT_DEVICE_232B));
  437.         }
  438.         if (parentContext == null) {
  439.             return Boolean.getBoolean(String.valueOf(FT_DEVICE_232B));
  440.         }
  441.         ftDev.setContext(parentContext);
  442.         if (params != null) {
  443.             ftDev.setDriverParameters(params);
  444.         }
  445.         if (ftDev.openDevice(mUsbManager) && ftDev.isOpen()) {
  446.             rc = true;
  447.         }
  448.         return rc;
  449.     }
  450.  
  451.     public synchronized FT_Device openByUsbDevice(Context parentContext, UsbDevice dev, DriverParameters params) {
  452.         FT_Device ftDev;
  453.         ftDev = null;
  454.         if (isFtDevice(dev)) {
  455.             ftDev = findDevice(dev);
  456.             if (!tryOpen(parentContext, ftDev, params)) {
  457.                 ftDev = null;
  458.             }
  459.         }
  460.         return ftDev;
  461.     }
  462.  
  463.     public synchronized FT_Device openByUsbDevice(Context parentContext, UsbDevice dev) {
  464.         return openByUsbDevice(parentContext, dev, null);
  465.     }
  466.  
  467.     public synchronized FT_Device openByIndex(Context parentContext, int index, DriverParameters params) {
  468.         FT_Device ftDev;
  469.         if (index < 0) {
  470.             ftDev = null;
  471.         } else if (parentContext == null) {
  472.             ftDev = null;
  473.         } else {
  474.             updateContext(parentContext);
  475.             FT_Device ftDev2 = (FT_Device) this.mFtdiDevices.get(index);
  476.             if (!tryOpen(parentContext, ftDev2, params)) {
  477.                 ftDev2 = null;
  478.             }
  479.             ftDev = ftDev2;
  480.         }
  481.         return ftDev;
  482.     }
  483.  
  484.     public synchronized FT_Device openByIndex(Context parentContext, int index) {
  485.         return openByIndex(parentContext, index, null);
  486.     }
  487.  
  488.     public synchronized FT_Device openBySerialNumber(Context parentContext, String serialNumber, DriverParameters params) {
  489.         FT_Device ftDev;
  490.         FT_Device ftDev2 = null;
  491.         if (parentContext == null) {
  492.             ftDev = null;
  493.         } else {
  494.             updateContext(parentContext);
  495.             for (int i = FT_DEVICE_232B; i < this.mFtdiDevices.size(); i += FT_DEVICE_8U232AM) {
  496.                 FT_Device tmpDev = (FT_Device) this.mFtdiDevices.get(i);
  497.                 if (tmpDev != null) {
  498.                     FtDeviceInfoListNode devInfo = tmpDev.mDeviceInfoNode;
  499.                     if (devInfo == null) {
  500.                         Log.d(TAG, "***devInfo cannot be null***");
  501.                     } else if (devInfo.serialNumber.equals(serialNumber)) {
  502.                         ftDev2 = tmpDev;
  503.                         break;
  504.                     }
  505.                 }
  506.             }
  507.             if (!tryOpen(parentContext, ftDev2, params)) {
  508.                 ftDev2 = null;
  509.             }
  510.             ftDev = ftDev2;
  511.         }
  512.         return ftDev;
  513.     }
  514.  
  515.     public synchronized FT_Device openBySerialNumber(Context parentContext, String serialNumber) {
  516.         return openBySerialNumber(parentContext, serialNumber, null);
  517.     }
  518.  
  519.     public synchronized FT_Device openByDescription(Context parentContext, String description, DriverParameters params) {
  520.         FT_Device ftDev;
  521.         FT_Device ftDev2 = null;
  522.         if (parentContext == null) {
  523.             ftDev = null;
  524.         } else {
  525.             updateContext(parentContext);
  526.             for (int i = FT_DEVICE_232B; i < this.mFtdiDevices.size(); i += FT_DEVICE_8U232AM) {
  527.                 FT_Device tmpDev = (FT_Device) this.mFtdiDevices.get(i);
  528.                 if (tmpDev != null) {
  529.                     FtDeviceInfoListNode devInfo = tmpDev.mDeviceInfoNode;
  530.                     if (devInfo == null) {
  531.                         Log.d(TAG, "***devInfo cannot be null***");
  532.                     } else if (devInfo.description.equals(description)) {
  533.                         ftDev2 = tmpDev;
  534.                         break;
  535.                     }
  536.                 }
  537.             }
  538.             if (!tryOpen(parentContext, ftDev2, params)) {
  539.                 ftDev2 = null;
  540.             }
  541.             ftDev = ftDev2;
  542.         }
  543.         return ftDev;
  544.     }
  545.  
  546.     public synchronized FT_Device openByDescription(Context parentContext, String description) {
  547.         return openByDescription(parentContext, description, null);
  548.     }
  549.  
  550.     public synchronized FT_Device openByLocation(Context parentContext, int location, DriverParameters params) {
  551.         FT_Device ftDev;
  552.         FT_Device ftDev2 = null;
  553.         if (parentContext == null) {
  554.             ftDev = null;
  555.         } else {
  556.             updateContext(parentContext);
  557.             for (int i = FT_DEVICE_232B; i < this.mFtdiDevices.size(); i += FT_DEVICE_8U232AM) {
  558.                 FT_Device tmpDev = (FT_Device) this.mFtdiDevices.get(i);
  559.                 if (tmpDev != null) {
  560.                     FtDeviceInfoListNode devInfo = tmpDev.mDeviceInfoNode;
  561.                     if (devInfo == null) {
  562.                         Log.d(TAG, "***devInfo cannot be null***");
  563.                     } else if (devInfo.location == location) {
  564.                         ftDev2 = tmpDev;
  565.                         break;
  566.                     }
  567.                 }
  568.             }
  569.             if (!tryOpen(parentContext, ftDev2, params)) {
  570.                 ftDev2 = null;
  571.             }
  572.             ftDev = ftDev2;
  573.         }
  574.         return ftDev;
  575.     }
  576.  
  577.     public synchronized FT_Device openByLocation(Context parentContext, int location) {
  578.         return openByLocation(parentContext, location, null);
  579.     }
  580.  
  581.     public int addUsbDevice(UsbDevice dev) {
  582.         int rc = FT_DEVICE_232B;
  583.         if (isFtDevice(dev)) {
  584.             int numInterfaces = dev.getInterfaceCount();
  585.             for (int i = FT_DEVICE_232B; i < numInterfaces; i += FT_DEVICE_8U232AM) {
  586.                 if (isPermitted(dev)) {
  587.                     synchronized (this.mFtdiDevices) {
  588.                         FT_Device ftDev = findDevice(dev);
  589.                         if (ftDev == null) {
  590.                             ftDev = new FT_Device(mContext, mUsbManager, dev, dev.getInterface(i));
  591.                         } else {
  592.                             ftDev.setContext(mContext);
  593.                             this.mFtdiDevices.remove(ftDev);
  594.                         }
  595.                         this.mFtdiDevices.add(ftDev);
  596.                         rc += FT_DEVICE_8U232AM;
  597.                     }
  598.                 }
  599.             }
  600.         }
  601.         return rc;
  602.     }
  603. }
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!