andhikayuana · June 25, 2025 08:08 · Aug 28, 2014 · Aug 6, 2014 · Aug 6, 2014 · Jun 27, 2014
diff --git a/UsbDbAdapter.java b/UsbDbAdapter.java
@@ -236,6 +236,7 @@ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
 				db.execSQL("DROP TABLE IF EXISTS " + VERSION_TABLE);
 				db.execSQL("DROP TABLE IF EXISTS " + VENDOR_TABLE);
 				db.execSQL("DROP TABLE IF EXISTS " + PRODUCT_TABLE);
+                                db.execSQL("VACUUM");
 				onCreate(db);
 			}else
 			{

diff --git a/UsbDbAdapter.java b/UsbDbAdapter.java
@@ -242,5 +242,11 @@ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
 				db.setVersion(oldVersion);
 			}
 		}
+
+                @Override
+		public void onDowngrade (SQLiteDatabase db, int oldVersion, int newVersion)
+		{
+			onUpgrade(db, oldVersion, newVersion);
+		}
 	}
 }
diff --git a/UsbDataProvider.java b/UsbDataProvider.java
@@ -92,7 +92,8 @@ public void run()
 						if(data != null)
 						{
 							dbAdapter.close();
-							dbAdapter = new UsbDbAdapter(context, idLocalVersion++);
+                                                        idLocalVersion++;
+							dbAdapter = new UsbDbAdapter(context, idLocalVersion);
 							dbAdapter.open();
 							UsbDataHelper.parseStringToDb(data, dbAdapter);
 							if(mCallback != null)

diff --git a/UsbIdDb.java b/UsbIdDb.java
@@ -3,6 +3,8 @@
 * @author: felhr ([email protected])
 */
 
+// Permissions needed: <uses-permission android:name="android.permission.INTERNET" /> 
+
 // There are some callbacks related with created, opened and updated database events. It is not necessary to use them.
 private UsbDataProvider.UsbDbCallback mCallback = new UsbDataProvider.UsbDbCallback()
 {

diff --git a/UsbData.java b/UsbData.java
@@ -0,0 +1,64 @@
+public class UsbData
+{
+	private String vendorId;
+	private String vendorName;
+	private String productId;
+	private String productName;
+
+
+	public UsbData(String vendorId, String vendorName, String productId, String productName)
+	{
+		this.vendorId = vendorId;
+		this.vendorName = vendorName;
+		this.productId = productId;
+		this.productName = productName;
+	}
+
+
+	public String getVendorId() 
+	{
+		return vendorId;
+	}
+
+
+	public void setVendorId(String vendorId) 
+	{
+		this.vendorId = vendorId;
+	}
+
+
+	public String getVendorName() 
+	{
+		return vendorName;
+	}
+
+
+	public void setVendorName(String vendorName) 
+	{
+		this.vendorName = vendorName;
+	}
+
+
+	public String getProductId() 
+	{
+		return productId;
+	}
+
+
+	public void setProductId(String productId) 
+	{
+		this.productId = productId;
+	}
+
+
+	public String getProductName() 
+	{
+		return productName;
+	}
+
+
+	public void setProductName(String productName) 
+	{
+		this.productName = productName;
+	}
+}
diff --git a/UsbDataHelper.java b/UsbDataHelper.java
@@ -0,0 +1,209 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class UsbDataHelper 
+{
+	private final static String USB_URL = "http://www.linux-usb.org/usb.ids";
+
+	private UsbDataHelper()
+	{
+
+	}
+
+	// Parse a given number of lines from url. Returns null if an error occur.
+	public static List<String> parseDataFromUrl(int numberLines)
+	{
+		return UrlDownloaderHelper.fetchDataFromUrl(numberLines);
+	}
+
+	// Parse data from url to a local database.
+	public static void parseStringToDb(List<String> data, UsbDbAdapter dbAdapter)
+	{
+		UsbIdRepositoryHelper.populateDb(data, dbAdapter);
+	}
+
+	// Get current repository version from url. Returns null if an error occur
+	public static String getRepositoryVersion()
+	{
+		return UsbIdRepositoryHelper.getVersion();
+	}
+
+	private static class UrlDownloaderHelper
+	{
+		public static List<String> fetchDataFromUrl(int linesNumber)
+		{
+			int counter = 0;
+			List<String> lines = new ArrayList<String>(19000);
+			URL url = null;
+
+			try 
+			{
+				url = new URL(USB_URL);
+			}catch(MalformedURLException e)
+			{
+				e.printStackTrace();
+				url = null;
+			}
+
+			if(url != null)
+			{
+				try 
+				{
+					URLConnection newConnection = url.openConnection();
+					HttpURLConnection httpConexion = (HttpURLConnection) newConnection;
+					int responseCode = httpConexion.getResponseCode();
+					if(responseCode == HttpURLConnection.HTTP_OK)
+					{
+						InputStream is = httpConexion.getInputStream();
+						BufferedReader br = new BufferedReader(new InputStreamReader(is,"UTF-8"));
+
+						String line;
+						while((line = br.readLine()) != null)
+						{
+
+							lines.add(line);
+							if(linesNumber != 0)
+							{
+								counter++;
+								if(linesNumber == counter)
+									return lines;
+							}
+						}	
+					}else
+					{
+						return null;
+					}
+
+				} catch (IOException e) 
+				{
+					e.printStackTrace();
+					return null;
+				}
+			}else
+			{
+				return null;
+			}
+
+			return lines;
+		}
+	}
+
+	private static class UsbIdRepositoryHelper
+	{
+
+		// Flags
+		private static boolean VID_PID_PARSING; // Parser is already parsing Vids and Pids
+
+		// Next Section of file, there are no more vid an pids beyond this line
+		private static final String NEXT_SECTION = "# List of known device classes, subclasses and protocols";
+
+		//Tokens
+		private static final char NUMBER_SIGN = '#';
+		private static final String VERSION = "Version:";
+		private static final String DATE = "Date:";
+
+
+		private UsbIdRepositoryHelper()
+		{
+			VID_PID_PARSING = false;
+		}
+
+		public static void populateDb(List<String> data, UsbDbAdapter dbAdapter)
+		{
+			boolean keep = true;
+			String tempVidKey = null;
+			String tempVidName = null;
+			String tempVersion = null;
+			String tempDate = null;
+			List<UsbData> productList = new ArrayList<UsbData>();
+			Iterator<String> e = data.iterator();
+			dbAdapter.beginTransaction();
+			while(keep && e.hasNext())
+			{
+				String line = e.next();
+				if(line.length() > 0)
+				{
+					if(!VID_PID_PARSING && line.charAt(0) == NUMBER_SIGN  && line.contains(VERSION)) // Get Version
+					{
+						line = line.trim();
+						tempVersion = line.substring(11, line.length());
+					}else if(!VID_PID_PARSING && line.charAt(0) == NUMBER_SIGN && line.contains(DATE)) // Get Date
+					{
+						line = line.trim();
+						tempDate = line.substring(11,line.length());
+						dbAdapter.insertEntryVersion(tempVersion, tempDate);
+					}else if(line.charAt(0) >= 0x30) // Get VID and Vendor name
+					{
+						if(!productList.isEmpty()) // List of Pids associated to a Vid has been completely read. 
+						{
+							dbAdapter.insertEntryVendor(tempVidKey, tempVidName);
+							Iterator<UsbData> t = productList.iterator();
+							while(t.hasNext())
+							{
+								UsbData usbData = t.next();
+								dbAdapter.insertEntryProduct(usbData);
+							}
+							productList.clear();
+						}else if((VID_PID_PARSING && productList.isEmpty())) // There is a VID without PIDS
+						{
+							dbAdapter.insertEntryVendor(tempVidKey, tempVidName);
+						}
+						line = line.trim();
+						tempVidKey = line.substring(0, 4);
+						tempVidName = line.substring(5, line.length());
+						if(!VID_PID_PARSING)
+							VID_PID_PARSING = true;
+					}else if(VID_PID_PARSING && line.charAt(0) != NUMBER_SIGN && line.length() > 1) // Get PID and product name
+					{
+						line = line.trim();
+						String pid = line.substring(0, 4);
+						String namePid = line.substring(6,line.length());
+						UsbData productData = new UsbData(tempVidKey, tempVidName, pid, namePid);
+						productList.add(productData);
+					}else if(VID_PID_PARSING && line.equals(NEXT_SECTION)) // No more devices, add the last Vid and Pids associated
+					{
+						dbAdapter.insertEntryVendor(tempVidKey, tempVidName);
+						Iterator<UsbData> t = productList.iterator();
+						while(t.hasNext())
+						{
+							UsbData usbData = t.next();
+							dbAdapter.insertEntryProduct(usbData);
+						}
+						productList.clear();
+						keep = false;
+					}
+				}
+			}
+			dbAdapter.setTransactionSuccesful();
+			dbAdapter.endTransaction();
+		}
+
+
+		public static String getVersion()
+		{
+			List<String> data = UrlDownloaderHelper.fetchDataFromUrl(12);
+			if(data != null)
+			{
+				Iterator<String> e = data.iterator();
+				while(e.hasNext())
+				{
+					String line = e.next();
+					if(line.charAt(0) == NUMBER_SIGN  && line.contains(VERSION)) // Get Version
+					{
+						return line.substring(11, line.length());
+					}
+				}
+			}
+			return null;
+		}
+	}
+}
diff --git a/UsbDataProvider.java b/UsbDataProvider.java
@@ -0,0 +1,127 @@
+import java.io.File;
+import java.util.List;
+
+import android.content.Context;
+import android.util.Log;
+
+public class UsbDataProvider 
+{
+	private static final String CLASS_ID = UsbDataProvider.class.getSimpleName();
+	private Context context;
+	private HeavyTasksThread heavyTasksThread;
+	private UsbDbCallback mCallback;
+	private UsbDbAdapter dbAdapter;
+
+	public UsbDataProvider(Context context)
+	{
+		this.context = context;
+		heavyTasksThread = new HeavyTasksThread();
+		heavyTasksThread.start();
+	}
+
+	public UsbDataProvider(Context context, UsbDbCallback mCallback)
+	{
+		this.context = context;
+		heavyTasksThread = new HeavyTasksThread();
+		this.mCallback = mCallback;
+		heavyTasksThread.start();
+	}
+
+	public UsbData lookup(String vid, String pid)
+	{
+		if(dbAdapter != null)
+			return dbAdapter.query(vid, pid);
+		else
+			return null;
+	}
+
+
+	private class HeavyTasksThread extends Thread
+	{
+		private boolean isDbCreated;
+
+		public HeavyTasksThread()
+		{
+			isDbCreated = false;
+		}
+
+		@Override
+		public void run()
+		{
+			File dbPath = context.getDatabasePath(UsbDbAdapter.DB_NAME);
+			if(dbPath.exists())
+				isDbCreated = true;
+
+			if(!isDbCreated)
+			{	
+				// First time, populate DB
+				List<String> data = UsbDataHelper.parseDataFromUrl(0);
+				if(data != null) // 
+				{
+					// Open Database
+					dbAdapter = new UsbDbAdapter(context, UsbDbAdapter.DB_VERSION_1);
+					dbAdapter.open();
+
+					// Data correctly parsed from url
+					UsbDataHelper.parseStringToDb(data, dbAdapter);
+					if(mCallback != null)
+						mCallback.onDbOpenedFirstTime(true);
+				}else
+				{
+					// Some error occurred when parsing data from url
+					if(mCallback != null)
+						mCallback.onDbOpenedFirstTime(false);
+				}
+			}else
+			{
+				// Database has been created before. Check version and update if necessary
+				dbAdapter = new UsbDbAdapter(context, UsbDbAdapter.DB_VERSION_1);
+				dbAdapter.open();
+				String currentVersion = UsbDataHelper.getRepositoryVersion();
+				if(currentVersion != null)
+				{
+					// Current remote version could be read. Check version and if not equal, update
+					String localVersion = dbAdapter.queryLocalVersion();
+					int idLocalVersion = dbAdapter.queryLocalVersionId();
+					Log.i(CLASS_ID, "Local version: " + localVersion + " Local version Id: " +
+							String.valueOf(idLocalVersion)+  " Remote version: " + currentVersion);
+
+					if(!currentVersion.equals(localVersion)) // Remote version != local version. Try to update
+					{
+						List<String> data = UsbDataHelper.parseDataFromUrl(0);
+						if(data != null)
+						{
+							dbAdapter.close();
+							dbAdapter = new UsbDbAdapter(context, idLocalVersion++);
+							dbAdapter.open();
+							UsbDataHelper.parseStringToDb(data, dbAdapter);
+							if(mCallback != null)
+								mCallback.onDbUpdated(currentVersion);
+						}else
+						{
+							dbAdapter = new UsbDbAdapter(context, idLocalVersion);
+							dbAdapter.open();
+							Log.i(CLASS_ID, "Db could not be updated");
+						}
+					}else // Remote version == Local version Open Database normally
+					{	
+						if(mCallback != null)
+							mCallback.onDbOpened();
+					}
+				}else
+				{
+					Log.i(CLASS_ID, "Remote version could not be read from url, Last db version opened");
+					if(mCallback != null)
+						mCallback.onDbOpened();
+				}
+			}
+		}	
+	}
+
+	public interface UsbDbCallback
+	{
+		public void onDbOpenedFirstTime(boolean status);
+		public void onDbOpened();
+		public void onDbUpdated(String newVersion);
+	}
+}
diff --git a/UsbDbAdapter.java b/UsbDbAdapter.java
@@ -0,0 +1,246 @@
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteDatabase.CursorFactory;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteStatement;
+
+public class UsbDbAdapter 
+{
+	public static final String DB_NAME = "usbIds.db";
+	public static final int DB_VERSION_1 = 1;
+
+	private static final String VERSION_TABLE = "versionTable";
+	private static final String VENDOR_TABLE = "vendorTable";
+	private static final String PRODUCT_TABLE = "productTable";
+
+	//Version Table Columns
+	private static final String VERSION_COLUMN = "version";
+	private static final String DATE_COLUMN = "date";
+	private static final String ID_VERSION = "id_version";
+
+	// Vendor Table Columns
+	private static final String KEY_ID = "_id";
+	private static final String VID_COLUMN = "vid";
+	private static final String VID_NAME_COLUMN = "vid_name";
+
+	// Product Table Columns
+	private static final String KEY_ID_PRODUCT = "_id";
+	private static final String VID_PRODUCT_COLUMN = "vid";
+	private static final String PID_PRODUCT_COLUMN = "pid";
+	private static final String PID_NAME_PRODUCT_COLUMN = "pid_name";
+
+	// SQL Statements
+	private static final String CREATE_VERSION_TABLE = "create table " + VERSION_TABLE + "("
+			+ KEY_ID + " integer primary key autoincrement, " + VERSION_COLUMN + " text not null, "
+			+ DATE_COLUMN + " text not null, " + ID_VERSION + " integer);";
+
+	private static final String CREATE_VENDOR_TABLE = "create table " + VENDOR_TABLE + "(" 
+			 +KEY_ID + " integer primary key autoincrement, " + VID_COLUMN + " text not null, " + VID_NAME_COLUMN + " text not null);";
+
+	private static final String CREATE_PRODUCT_TABLE = "create table " + PRODUCT_TABLE + "("
+			+ KEY_ID_PRODUCT + " integer primary key autoincrement, " + VID_PRODUCT_COLUMN + " text not null, "
+			+ PID_PRODUCT_COLUMN + " text not null, " + PID_NAME_PRODUCT_COLUMN + " text not null);" ;
+
+	private static final String SELECT_VENDOR_PRODUCT = "select vid_name, pid_name from " 
+	+ VENDOR_TABLE + ", " + PRODUCT_TABLE + " where " + VENDOR_TABLE +".vid = ?" + " and " + PRODUCT_TABLE + ".vid = ? " + "and pid = ?"; 
+
+	private static final String SELECT_VENDOR = "select vid, vid_name from " + VENDOR_TABLE + " where vid = ?";
+
+	private static final String SELECT_VERSION = "select " + VERSION_COLUMN + " from " + VERSION_TABLE;
+
+	private static final String SELECT_VERSION_ID = "select " + ID_VERSION + " from " + VERSION_TABLE;
+
+	private static final String INSERT_VENDOR = "insert into " + VENDOR_TABLE + " (" + VID_COLUMN + ", " + VID_NAME_COLUMN
+			+ ") values(?,?)";
+
+	private static final String INSERT_PRODUCT = "insert into " + PRODUCT_TABLE + " (" + VID_PRODUCT_COLUMN 
+			+ ", " + PID_PRODUCT_COLUMN + ", " + PID_NAME_PRODUCT_COLUMN  + ") values(?,?,?)";
+
+	// Compiled SQL Statements
+	private static SQLiteStatement insertVendor;
+	private static SQLiteStatement insertProduct;
+
+
+	private SQLiteDatabase db;
+	private DbHelper dbHelper;
+	private int currentVersion;
+
+	public UsbDbAdapter(Context context, int version)
+	{
+		this.currentVersion = version;
+		dbHelper = new DbHelper(context, DB_NAME, null, version);
+	}
+
+	public UsbDbAdapter open() throws SQLException
+	{
+		db = dbHelper.getWritableDatabase();
+		return this;
+	}
+
+	public void close()
+	{
+		db.close();
+	}
+
+	public void beginTransaction()
+	{
+		db.beginTransaction();
+	}
+
+	public void endTransaction()
+	{
+		db.endTransaction();
+	}
+
+	public void setTransactionSuccesful()
+	{
+		db.setTransactionSuccessful();
+	}
+
+	public long insertEntryVersion(String version, String date)
+	{
+		ContentValues values = new ContentValues();
+		values.put(VERSION_COLUMN, version);
+		values.put(DATE_COLUMN, date);
+		values.put(ID_VERSION, currentVersion);
+		return db.insert(VERSION_TABLE, null, values);
+	}
+
+	public void insertEntryVendor(String vid, String vidName)
+	{
+		insertVendor.bindString(1, vid);
+		insertVendor.bindString(2, vidName);
+		insertVendor.execute();
+		insertVendor.clearBindings();
+	}
+
+	public void insertEntryProduct(UsbData data)
+	{
+		insertProduct.bindString(1, data.getVendorId());
+		insertProduct.bindString(2, data.getProductId());
+		insertProduct.bindString(3, data.getProductName());
+		insertProduct.execute();
+		insertProduct.clearBindings();
+	}
+
+	public String queryLocalVersion()
+	{
+		Cursor cursor = db.rawQuery(SELECT_VERSION, null);
+		cursor.moveToFirst();
+		return cursor.getString(0);
+	}
+
+	public int queryLocalVersionId()
+	{
+		Cursor cursor = db.rawQuery(SELECT_VERSION_ID, null);
+		cursor.moveToFirst();
+		return cursor.getInt(0);
+	}
+
+	public UsbData query(String vid, String pid)
+	{
+		if(validateInput(vid, pid))
+		{
+			Cursor cursor = db.rawQuery(SELECT_VENDOR_PRODUCT, new String[]{vid, vid, pid});
+			cursor.moveToFirst();
+			if(cursor.getCount() > 0)
+			{
+				String vidName = cursor.getString(0);
+				String pidName = cursor.getString(1);
+				return new UsbData(vid, vidName, pid, pidName);
+			}else
+			{
+				cursor = db.rawQuery(SELECT_VENDOR, new String[]{vid});
+				cursor.moveToFirst();
+				if(cursor.getCount() > 0)
+				{
+					String stringName = cursor.getString(1);
+					return new UsbData(vid, stringName, pid, "None");
+				}else
+				{
+					return new UsbData("None", "None", "None", "None");
+				}
+			}
+		}else
+		{
+			return null;
+		}
+	}
+
+
+	private boolean validateInput(String vid, String pid)
+	{
+		if((vid.length() > 4 || pid.length() > 4))
+			return false;
+		if(checkHexValue(vid) && checkHexValue(pid))
+			return true;
+		else
+			return false;
+	}
+
+	private boolean checkHexValue(String value)
+	{
+
+		for(int i=0;i<=value.length()-1;i++)
+		{
+			if(value.charAt(i) < 0x30 || value.charAt(i) > 0x66)
+			{
+				return false;
+			}else
+			{
+				if(value.charAt(i) > 0x39 && value.charAt(i) < 0x41)
+				{
+					return false;
+				}else
+				{
+					if(value.charAt(i) > 0x46 && value.charAt(i) < 0x61)
+					{
+						return false;
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+
+	private static class DbHelper extends SQLiteOpenHelper
+	{
+
+		public DbHelper(Context context, String name, CursorFactory factory,
+				int version) 
+		{
+			super(context, name, factory, version);
+		}
+
+		@Override
+		public void onCreate(SQLiteDatabase db) 
+		{
+			db.execSQL(CREATE_VERSION_TABLE);
+			db.execSQL(CREATE_VENDOR_TABLE);
+			db.execSQL(CREATE_PRODUCT_TABLE);
+
+			insertVendor = db.compileStatement(INSERT_VENDOR);
+			insertProduct = db.compileStatement(INSERT_PRODUCT);
+
+		}
+
+		@Override
+		public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
+		{
+			if(newVersion > oldVersion)
+			{
+				db.execSQL("DROP TABLE IF EXISTS " + VERSION_TABLE);
+				db.execSQL("DROP TABLE IF EXISTS " + VENDOR_TABLE);
+				db.execSQL("DROP TABLE IF EXISTS " + PRODUCT_TABLE);
+				onCreate(db);
+			}else
+			{
+				db.setVersion(oldVersion);
+			}
+		}
+	}
+}
diff --git a/UsbIdDb.java b/UsbIdDb.java
@@ -0,0 +1,47 @@
+/*
+* Example of use
+* @author: felhr ([email protected])
+*/
+
+// There are some callbacks related with created, opened and updated database events. It is not necessary to use them.
+private UsbDataProvider.UsbDbCallback mCallback = new UsbDataProvider.UsbDbCallback()
+{
+	@Override
+	public void onDbOpenedFirstTime(boolean status)
+	{
+		// status == false means database could not be created due to an error fetching data from source
+                // status == true means database was successfully created
+
+                // Code here
+
+	}
+
+	@Override
+	public void onDbOpened() 
+	{
+		// Database opened
+                // Code here
+	}
+
+	@Override
+	public void onDbUpdated(String newVersion) 
+	{
+		// Database updated with newVersion
+                // Code here
+	}		
+};
+
+
+UsbDataProvider dataProvider;
+dataProvider = new UsbDataProvider(context, mCallback); // Create and open, open or update and open database if necessary. Notifications on callback
+//dataProvider = new UsbDataProvider(context)
+
+String vid = "03f0"; // Must be an hex representation of 16 bit number (0000-FFFF). Don't worry about uppercase or lowercase
+String pid= "010C"; // Must be an hex representation of 16 bit number (0000-FFFF). Don't worry about uppercase or lowercase
+
+UsbData data = dataProvider.lookup(vid, pid); // Returns null if vid or pid are not valid inputs or database could not be created
+if(data != null)
+{
+    String vendorName = data.getVendorName(); // Vendor name
+    String productName = data.getProductName(); // Product name
+}
No results found