使用libaums v0.7.0读取SD卡时热插拔致损坏的问题求助

Hey there, let's dig into your SD card corruption issue with libaums 0.7.0. The problem you're seeing—corruption even after just calling device.init() and device.close() when yanking the card without manual unmounting—is actually rooted in how USB mass storage and file system metadata work, and potentially a gap in how you're tearing down the device connection.

Why This Happens #

Even if you don't write any user data, mounting a file system (which device.init() triggers) can still modify low-level metadata on the SD card: things like file system journal entries, access timestamps, or cache sync markers. When you yank the card without properly unmounting, these incomplete metadata writes leave the file system in an inconsistent state—Windows picks up on this and throws an error.

Your assumption that device.close() should handle this makes sense, but libaums' close() method might not be doing all the necessary cleanup steps by default. It might close the USB connection but skip explicitly unmounting the partition or syncing cached metadata to the card.

Fixes to Try #

1. Explicitly Sync and Unmount Partitions Before Closing #

Modify your code to sync the file system cache and unmount the partition before calling device.close(). This ensures all pending metadata writes are flushed and the file system is properly marked as safe to remove:

private class FindDevicesTask extends AsyncTask<Integer, Integer, String> { 
    private WeakReference<Context> mContext; 
    FindDevicesTask (Context context){ 
        mContext = new WeakReference<>(context); 
    } 
    @Override 
    protected String doInBackground(Integer... dummy) { 
        Context ctx = mContext.get(); 
        if (ctx == null) return null; // Context expired 
        UsbMassStorageDevice[] devices = UsbMassStorageDevice.getMassStorageDevices(ctx); 
        for (final UsbMassStorageDevice device : devices) { 
            if (!mUsbManager.hasPermission(device.getUsbDevice())) { 
                mUsbManager.requestPermission(device.getUsbDevice(), mPermissionIntent); 
                return null; 
            } 
            try { 
                device.init();
                // Get the first partition (adjust if you need multi-partition support)
                Partition partition = device.getPartitions().get(0);
                FileSystem fs = partition.getFileSystem();
                
                // Your existing work here
                
                // Step 1: Sync all cached data/metadata to the SD card
                fs.sync();
                // Step 2: Unmount the partition properly
                partition.unmount();
            } catch (IOException e) { 
                return e.getMessage(); 
            } finally { 
                device.close();
                // Extra: Release USB interfaces to ensure full system cleanup
                UsbDevice usbDevice = device.getUsbDevice();
                for (UsbInterface intf : usbDevice.getInterfaces()) {
                    if (mUsbManager.hasPermission(usbDevice)) {
                        mUsbManager.releaseInterface(intf);
                    }
                }
            } 
        } 
        return null; 
    } 
    @Override 
    protected void onPostExecute(String result) { 
        if (result == null || result.isEmpty()) return; 
        Context ctx = mContext.get(); 
        if (ctx != null) displayString(result, "USB connection error", ctx); 
    } 
};

2. Auto-Handle Device Removal with Broadcast Receiver #

To catch when the user is about to pull the card, register a broadcast receiver for ACTION_USB_DEVICE_DETACHED. This lets you run cleanup code before the device is fully disconnected:

private BroadcastReceiver mUsbDetachReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
            UsbDevice detachedDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
            // Match the detached device to your active UsbMassStorageDevice
            // If it's a match, run your sync/unmount/close logic here
        }
    }
};

// Register the receiver in your Activity/Fragment's onCreate
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    IntentFilter filter = new IntentFilter(UsbManager.ACTION_USB_DEVICE_DETACHED);
    registerReceiver(mUsbDetachReceiver, filter);
}

// Don't forget to unregister in onDestroy
@Override
protected void onDestroy() {
    super.onDestroy();
    unregisterReceiver(mUsbDetachReceiver);
}

Key Notes #

• Even with these fixes, it's still good practice to prompt users to "safe remove" the device—some Android system-level USB handling might override app-level cleanup.
• libaums 0.7.0 is a relatively old version; checking if there's a newer release might help, as later versions could have improved cleanup logic.

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