Android应用能否读写外接USB闪存中的SQLite数据库？

Absolutely doable! I’ve worked on projects where we needed exactly this—storing app data on a removable USB drive instead of the device’s internal storage. Let’s walk through how to make it happen step by step.

First off: this is totally feasible. Android has supported USB OTG (On-The-Go) for years, and as long as your target devices support OTG, you can directly read/write SQLite databases on an external USB flash drive. The data doesn’t need to live alongside your app’s installation directory—you just need to handle permissions and storage access correctly.

1. Request Required Permissions #

Permissions are the first hurdle, especially with Android’s evolving storage policies:

• Add these entries to your AndroidManifest.xml:

  <!-- Declare OTG hardware support (optional, allows app to install on non-OTG devices) -->
  <uses-feature android:name="android.hardware.usb.host" android:required="false" />
  <!-- Legacy storage access for Android 10+ (avoids scoped storage restrictions temporarily) -->
  <application
      ...
      android:requestLegacyExternalStorage="true">
  </application>
  

• For Android 6.0 (API 23) and above, dynamically request runtime permissions:

  String[] permissions = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE};
  if (ContextCompat.checkSelfPermission(this, permissions[0]) != PackageManager.PERMISSION_GRANTED) {
      ActivityCompat.requestPermissions(this, permissions, 1001);
  }
  

• For Android 11 (API 30)+, if you want to avoid the broad MANAGE_EXTERNAL_STORAGE permission, use the Storage Access Framework (SAF) to let users select the USB drive directory explicitly (more on this later).

2. Detect and Access the USB Storage Drive #

You need to locate the mounted USB drive’s file path:

• Use the StorageManager to get all available storage volumes, then filter for removable, mounted ones:

  StorageManager storageManager = (StorageManager) getSystemService(Context.STORAGE_SERVICE);
  List<StorageVolume> storageVolumes = storageManager.getStorageVolumes();
  
  String usbStoragePath = null;
  for (StorageVolume volume : storageVolumes) {
      if (volume.isRemovable() && volume.isMounted()) {
          // Get the directory path (works for Android 11+)
          File usbDir = volume.getDirectory();
          if (usbDir != null) {
              usbStoragePath = usbDir.getAbsolutePath();
              break;
          }
      }
  }
  

• If usbStoragePath is not null, you’ve got the root path of your USB drive.

3. Read/Write the SQLite Database on USB #

Once you have the USB path, interacting with the SQLite database is almost identical to using internal storage:

// Define the full path to your database on the USB drive
String dbFilePath = usbStoragePath + "/my_app_database.db";

// Open or create the database
SQLiteDatabase db = null;
try {
    db = SQLiteDatabase.openOrCreateDatabase(dbFilePath, null);
    
    // Example: Create a table if it doesn't exist
    db.execSQL("CREATE TABLE IF NOT EXISTS user_data (id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT, score INTEGER)");
    
    // Example: Insert data
    ContentValues values = new ContentValues();
    values.put("username", "Mark");
    values.put("score", 95);
    db.insert("user_data", null, values);
    
    // Example: Query data
    Cursor cursor = db.rawQuery("SELECT * FROM user_data WHERE username = ?", new String[]{"Mark"});
    if (cursor.moveToFirst()) {
        int score = cursor.getInt(cursor.getColumnIndex("score"));
        // Do something with the data
    }
    cursor.close();
} catch (SQLiteException | IOException e) {
    // Handle errors (e.g., USB drive was removed mid-operation)
    e.printStackTrace();
    Toast.makeText(this, "Failed to access database on USB", Toast.LENGTH_SHORT).show();
} finally {
    if (db != null && db.isOpen()) {
        db.close();
    }
}

4. Handle Edge Cases #

• USB Drive Removal: Always wrap database operations in try-catch blocks to handle IOException or SQLiteException if the user pulls out the drive while the app is accessing it.
• Android 11+ SAF Alternative: If you don’t want to use MANAGE_EXTERNAL_STORAGE, use SAF to let users pick the database file:

  // Trigger the SAF picker
  Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
  intent.addCategory(Intent.CATEGORY_OPENABLE);
  intent.setType("*/*");
  startActivityForResult(intent, 1002);
  

  Then in onActivityResult (or registerForActivityResult for newer Android versions), get the Uri and open the database via a file descriptor:

  ParcelFileDescriptor pfd = getContentResolver().openFileDescriptor(uri, "rw");
  if (pfd != null) {
      SQLiteDatabase db = SQLiteDatabase.openDatabase(pfd.getFileDescriptor(), null, SQLiteDatabase.OPEN_READWRITE);
      // Perform database operations
      db.close();
      pfd.close();
  }
  

• OTG Support: Verify that the user’s device supports USB OTG (most modern Android devices do, but it’s good to add a check in your app).
• Thread Safety: Don’t run database operations on the main UI thread—use Kotlin Coroutines, AsyncTask, or a background thread to avoid ANRs.
• Data Backup: Consider adding a feature to backup the USB database to internal storage (or cloud) to prevent data loss if the drive is lost/damaged.

内容的提问来源于stack exchange，提问作者Mark Anderson