Android U盘 读写

最新推荐文章于 2024-08-12 03:40:05 发布
最新推荐文章于 2024-08-12 03:40:05 发布
阅读量2.4k 收藏 4
点赞数
文章标签： Android otg U盘读写

首先给予足够的读写权限：

<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<uses-permission
    android:name="android.hardware.usb.host"
    android:required="false" />

<uses-feature
    android:name="android.hardware.usb.host"
    android:required="true" />

其次添加一个U盘读写操作的依赖包，我用的也是大家都推荐的：

compile 'com.github.mjdev:libaums:0.5.5'

继续上代码：首先是写操作（注意：需要你的手机root了才可以）

第一步：注册广播

/**
 * @description OTG广播注册
 * @author ldm
 * @time 2017/9/1 17:19
 */
private void registerUDiskReceiver() {
    //监听otg插入 拔出
    IntentFilter usbDeviceStateFilter = new IntentFilter();
    usbDeviceStateFilter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
    usbDeviceStateFilter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
    registerReceiver(mOtgReceiver, usbDeviceStateFilter);
    //注册监听自定义广播
    IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
    registerReceiver(mOtgReceiver, filter);
}
/**
 * @description OTG广播，监听U盘的插入及拔出
 * @author ldm
 * @time 2017/9/1 17:20
 * @param
 */
private BroadcastReceiver mOtgReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        switch (action) {
            case ACTION_USB_PERMISSION://接受到自定义广播
                usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                //允许权限申请
                if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                    if (usbDevice != null) {
                        //用户已授权，可以进行读取操作
                        readDevice(getUsbMass(usbDevice));
                    } else {
                        showToastMsg("没有插入U盘");
                    }
                } else {
                    showToastMsg("未获取到U盘权限");
                }
                break;
            case UsbManager.ACTION_USB_DEVICE_ATTACHED://接收到U盘设备插入广播
                UsbDevice device_add = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                if (device_add != null) {
                    //接收到U盘插入广播，尝试读取U盘设备数据
                    redUDiskDevsList();
                }
                break;
            case UsbManager.ACTION_USB_DEVICE_DETACHED://接收到U盘设设备拔出广播
                showToastMsg("U盘已拔出");
                break;
        }
    }
};

设备读取

/**
 * @description U盘设备读取
 * @author ldm
 * @time 2017/9/1 17:20
 */
private void redUDiskDevsList() {
    //设备管理器
    UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
    //获取U盘存储设备
    storageDevices = UsbMassStorageDevice.getMassStorageDevices(this);
    PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
    //一般手机只有1个OTG插口
    for (UsbMassStorageDevice device : storageDevices) {
        //读取设备是否有权限
        if (usbManager.hasPermission(device.getUsbDevice())) {
            readDevice(device);
        } else {
            //没有权限，进行申请
            usbManager.requestPermission(device.getUsbDevice(), pendingIntent);
        }
    }
    if (storageDevices.length == 0) {
        showToastMsg("请插入可用的U盘");
    }
}

设备写入：

/**
 * @description 保存数据到U盘，目前是保存到根目录的
 * @author ldm
 * @time 2017/9/1 17:17
 */
private void saveText2UDisk(String content) {
    //项目中也把文件保存在了SD卡，其实可以直接把文本读取到U盘指定文件
    File file = FileUtil.getSaveFile(getPackageName()
                    + File.separator + FileUtil.DEFAULT_BIN_DIR,
            U_DISK_FILE_NAME);
    try {
        FileWriter fw = new FileWriter(file);
        fw.write(content);
        fw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    if (null != cFolder) {
        FileUtil.saveSDFile2OTG(MainActivity.this,file, cFolder);
        mHandler.sendEmptyMessage(100);
    }
}

文件操作类：

public class FileUtil {
    public static final String DEFAULT_BIN_DIR = "usb";

    /**
     * 检测SD卡是否存在
     */
    public static boolean checkSDcard() {
        return Environment.MEDIA_MOUNTED.equals(Environment
                .getExternalStorageState());
    }

    /**
     * 从指定文件夹获取文件
     *
     * @return 如果文件不存在则创建, 如果如果无法创建文件或文件名为空则返回null
     */
    public static File getSaveFile(String folderPath, String fileNmae) {
        File file = new File(getSavePath(folderPath) + File.separator
                + fileNmae);
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return file;
    }

    /**
     * 获取SD卡下指定文件夹的绝对路径
     *
     * @return 返回SD卡下的指定文件夹的绝对路径
     */
    public static String getSavePath(String folderName) {
        return getSaveFolder(folderName).getAbsolutePath();
    }

    /**
     * 获取文件夹对象
     *
     * @return 返回SD卡下的指定文件夹对象，若文件夹不存在则创建
     */
    public static File getSaveFolder(String folderName) {
        File file = new File(getExternalStorageDirectory()
                .getAbsoluteFile()
                + File.separator
                + folderName
                + File.separator);
        file.mkdirs();
        return file;
    }

    /**
     * 关闭流
     */
    public static void closeIO(Closeable... closeables) {
        if (null == closeables || closeables.length <= 0) {
            return;
        }
        for (Closeable cb : closeables) {
            try {
                if (null == cb) {
                    continue;
                }
                cb.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void redFileStream(OutputStream os, InputStream is) throws IOException {
        int bytesRead = 0;
        byte[] buffer = new byte[1024 * 8];
        while ((bytesRead = is.read(buffer)) != -1) {
            os.write(buffer, 0, bytesRead);
        }
        os.flush();
        os.close();
        is.close();
    }

    public static List<String> getAllExterSdcardPath()
    {
        List<String> SdList = new ArrayList<String>();

        String firstPath = Environment.getExternalStorageDirectory().getPath();

        try
        {
            Runtime runtime = Runtime.getRuntime();
            // 运行mount命令，获取命令的输出，得到系统中挂载的所有目录
            Process proc = runtime.exec("mount");
            InputStream is = proc.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            String line;
            BufferedReader br = new BufferedReader(isr);
            while ((line = br.readLine()) != null)
            {
                Log.d("", line);
                // 将常见的linux分区过滤掉

                if (line.contains("proc") || line.contains("tmpfs") || line.contains("media") || line.contains("asec") || line.contains("secure") || line.contains("system") || line.contains("cache")
                        || line.contains("sys") || line.contains("data") || line.contains("shell") || line.contains("root") || line.contains("acct") || line.contains("misc") || line.contains("obb"))
                {
                    continue;
                }

                // 下面这些分区是我们需要的
                if (line.contains("fat") || line.contains("fuse") || (line.contains("ntfs")))
                {
                    // 将mount命令获取的列表分割，items[0]为设备名，items[1]为挂载路径
                    String items[] = line.split(" ");
                    if (items != null && items.length > 1)
                    {
                        String path = items[1].toLowerCase(Locale.getDefault());
                        // 添加一些判断，确保是sd卡，如果是otg等挂载方式，可以具体分析并添加判断条件
                        if (path != null && !SdList.contains(path) && path.contains("sd"))
                            SdList.add(items[1]);
                    }
                }
            }
        } catch (Exception e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        if (!SdList.contains(firstPath))
        {
            SdList.add(firstPath);
        }

        return SdList;
    }


    /**
     * @description 把本地文件写入到U盘中
     * @author ldm
     * @time 2017/8/22 10:22
     */
    public static void saveSDFile2OTG(Context context,final File f, final UsbFile usbFile) {
        UsbFile uFile = null;
        FileInputStream fis = null;
        try {//开始写入
            fis = new FileInputStream(f);//读取选择的文件的
            if (usbFile.isDirectory()) {//如果选择是个文件夹
                UsbFile[] usbFiles = usbFile.listFiles();
                if (usbFiles != null && usbFiles.length > 0) {
                    for (UsbFile file : usbFiles) {
                        if (file.getName().equals(f.getName())) {
                            file.delete();
                        }
                    }
                }
                uFile = usbFile.createFile(f.getName());
                UsbFileOutputStream uos = new UsbFileOutputStream(uFile);
                try {
                    redFileStream(uos, fis);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (final Exception e) {
            e.printStackTrace();
            Toast.makeText(context,e.toString(),Toast.LENGTH_LONG).show();
        }
    }
}
private final static String U_DISK_FILE_NAME = "****.txt";//星号写自己要写入文件的文件名

读取操作：Ps：一开始以为挺简单，后面发现没那么简单

获取UsbDevice

private UsbMassStorageDevice getUsbMass(UsbDevice usbDevice) {
    if(usbDevice!=null){
        for (UsbMassStorageDevice device : storageDevices) {
            if (usbDevice.equals(device.getUsbDevice())) {
                return device;
            }
        }
    }
    return null;
}

初始化调用：

private void readDevice(UsbMassStorageDevice device) {
        try {
            device.init();//初始化
            //设备分区
            Partition partition = device.getPartitions().get(0);
            //文件系统
            currentFs = partition.getFileSystem();
            currentFs.getVolumeLabel();//可以获取到设备的标识
            //通过FileSystem可以获取当前U盘的一些存储信息，包括剩余空间大小，容量等等
            Log.e("Capacity: ", currentFs.getCapacity() + "");
            Log.e("Occupied Space: ", currentFs.getOccupiedSpace() + "");
            Log.e("Free Space: ", currentFs.getFreeSpace() + "");
            Log.e("Chunk size: ", currentFs.getChunkSize() + "");
            cFolder = currentFs.getRootDirectory();//设置当前文件对象为根目录
            UsbFile[] usbFiles=cFolder.listFiles();
            if (null != usbFiles && usbFiles.length > 0) {
                for (UsbFile usbFile : usbFiles) {
                    if (usbFile.getName().equals(U_DISK_FILE_NAME)) {
                        readFile(usbFile);
//                        readTxtFromUDisk(usbFile);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            android.widget.Toast.makeText(AddPwsAddressActivity.this,e.toString(), android.widget.Toast.LENGTH_LONG).show();
        }
    }
private void readFile(final UsbFile uFile) {
    String sdPath = SDUtils.getSDPath();//获取sd根目录 创建一个同名文件
    String filePath = sdPath + "/" + uFile.getName();
    final File f = new File(filePath);
    if (!f.exists()) {
        try {
            f.createNewFile();
            //设置视图
            //执行线程
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        FileOutputStream os = new FileOutputStream(f);
                        InputStream is = new UsbFileInputStream(uFile);
                        final String bt = redFileStream(os, is);
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                android.widget.Toast.makeText(AddPwsAddressActivity.this,bt, android.widget.Toast.LENGTH_LONG).show();
                                Message msg = mHandler.obtainMessage();
                                msg.what = 101;
                                android.widget.Toast.makeText(AddPwsAddressActivity.this,bt, android.widget.Toast.LENGTH_LONG).show();
                                msg.obj = bt;
                                mHandler.sendMessage(msg);
                            }
                        });
                    } catch (final Exception e) {
                        e.printStackTrace();

                    }
                }
            });
        } catch (final Exception e) {
            e.printStackTrace();


        }
    }else {
        try {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        FileOutputStream os = new FileOutputStream(f);
                        InputStream is = new UsbFileInputStream(uFile);
                        final String bt = redFileStream(os, is);
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                android.widget.Toast.makeText(AddPwsAddressActivity.this,bt, android.widget.Toast.LENGTH_LONG).show();
                                Message msg = mHandler.obtainMessage();
                                msg.what = 101;
                                android.widget.Toast.makeText(AddPwsAddressActivity.this,bt, android.widget.Toast.LENGTH_LONG).show();
                                msg.obj = bt;
                                mHandler.sendMessage(msg);
                            }
                        });
                    } catch (final Exception e) {
                        e.printStackTrace();

                    }
                }
            });
        } catch (final Exception e) {
            e.printStackTrace();


        }
    }
}

private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 100:
                showToastMsg("保存成功");
                break;
            case 101:
                if(msg.obj==null){
                    Toast.makeText(MainActivity.this,"空的",Toast.LENGTH_LONG).show();
                }else{
                    String txt = msg.obj.toString();
                    if (!TextUtils.isEmpty(txt))
                        u_disk_show.setText("读取到的数据是：" + txt);
                }
                break;
        }
    }
};

Ps:别忘记反注册广播

特别感谢（对代码有疑问的可以提给我或者去看这两篇博客）：

https://blog.csdn.net/csdn635406113/article/details/70146041

https://blog.csdn.net/true100/article/details/77775700

还要感谢我朋友猴子的无私分享~

sd卡工具类：

public class SDUtils {
    private static final String TAG = "文件工具类";

    public static String getSDPath() {
        File sdDir = null;
        boolean sdCardExist = Environment.getExternalStorageState()
                .equals(Environment.MEDIA_MOUNTED); //判断sd卡是否存在
        if (sdCardExist) {
            sdDir = Environment.getExternalStorageDirectory();//获取跟目录
//            sdDir1 = Environment.getDataDirectory();
//            sdDir2 = Environment.getRootDirectory();
        } else {
            Log.d(TAG, "getSDPath: sd卡不存在");
        }
        Log.d(TAG, "getSDPath: " + sdDir.getAbsolutePath());
        return sdDir.getAbsolutePath();
    }
心只一念
关注
android usb host 读写USB设备
Central-Perk的专栏
07-12 5万+
自android3.1以后android增加了操作USB设备的API。 官网地址：http://developer.android.com/guide/topics/connectivity/usb/host.html 网上也有很多这方面的文章，不过多数是介绍如何得到设备和获取权限的，很少有介绍如何读写数据的。 最近也研究了在android下如何读写USB设备，和大家分享一下。 关于如何监听
Android 实现读写U盘文件
06-05
Android 基于libaums实现读写U盘文件，相关博客：https://blog.csdn.net/a512337862/article/details/80505128
android对外置U盘进行读取
12-20
android通过otg去读取U盘的内容并进行读写操作.
android 获取U盘文件
最新发布
weixin_40544096的博客
08-12 80
Android 获取 U 盘文件的完整指南 在 Android 应用开发中，有时需要从 U 盘中获取文件。对于初学者来说，这可能会显得有些复杂。在本教程中，我们将详细介绍如何在 Android 应用中实现获取 U 盘文件的功能，并为你提供清晰的步骤和代码示例。 整体流程 为了帮助你更好地理解整个过程，下面是我们将要进行的步...
Android-关于读写U盘文件(USB)-操作外置sd卡
Hogwarts
06-02 7045
Android关于读写U盘文件-操作外置sd卡一、背景二、可行性分析关于问题1关于问题2关于问题2，我们可以采取四种方式操作：实现效果依赖build.gradle布局文件activity_u.xml权限AndroidManifest.xml一个类UsbActivity三、参考文章 一、背景 很久以前做过这个功能，一直没有总结。碰巧最近有网友问到，就总结一下。 项目要求实现两个功能： 1、读取U盘里的apk文件并安装 2、导出数据，生成Excel表格到U盘 二、可行性分析 关于问题1 第一个问题很简单，读取U
Android 读取外接储存设备的数据（如挂载的U盘，SD卡等）
热门推荐
da_caoyuan的博客
08-04 1万+
本篇文章，将围绕以下几点来讲解： 1：OTG是什么？ 2：Android手机和一些Android系统的TV盒子对OTG的支持情况? 3：如何得知外接储存设备的插入和拔出的广播事件？ 4：得到插入广播后，而又如何去读取外部设备的数据？ 一： OTG是什么？ OTG是On-The-Go的缩写，是近年发展起来的技术，2001年12月18日由USB Implementers F...
Android U盘读写 反射获取U盘路径
04-09
在Android系统中，U盘（USB On-The-Go，OTG）的读写操作涉及到对外部存储设备的访问，这通常需要系统级别的权限。由于Android的安全机制，开发者不能直接通过常规方式获取到U盘的路径，而是需要通过反射技术来实现。...
android u盘 读写
06-21
Android U盘读写是指在Android系统设备上使用U盘进行数据传输和存储的过程。在Android系统中，U盘通常使用USB接口与设备连接，通过USB On-The-Go（简称USB OTG）技术可以使设备拥有读写U盘的能力。 要在Android设备...
Android USB检测，文件读写demo
07-18
在Android平台上，USB设备的检测和文件读写是开发者经常遇到的任务，特别是在移动设备与外部存储设备交互的场景中。本教程将详细讲解如何实现"Android USB检测，文件读写demo"，帮助你掌握相关技能。 首先，让我们...
android 识别U盘以及读写文件的方法
08-27
总之，Android识别U盘并读写文件的过程涉及到系统ContentProvider的查询、文件I/O操作以及对存储设备状态的监控。通过`ContentResolver` 和`AsyncQueryHandler`，应用可以监听到U盘的插入和移除，并进行相应的读写...
Android读取U盘
07-10
Android TV读取外部U盘方法 读写操作，。。
Android 基于libaums实现读写U盘文件
03-13
利用libaums在android上实现Android端读写U盘的功能，并将其进行了封装，写了个工具类,可以实现u盘与本地数据互传功能
Android U盘插拔监听以及U盘写入权限解决办法
05-28
Android U盘插拔监听以及U盘写入权限解决办法 https://blog.csdn.net/qq_31939617/article/details/80447276
android的U盘能写入的方法
07-25
现在U盘不能基本写入,有代码写adb shell命名,使得U盘具有写入功能
android通过usb读取U盘的方法
01-04
本文实例为大家分享了android通过usb读取U盘的具体代码，供大家参考，具体内容如下 1.关联 compile ‘com.github.mjdev:libaums:+’ 2.权限设置 <uses-permission android:name=android.hardware.us
Android系统之APP添加插入U盘读写权限（已测试Android7.1和Android12）
Llearn1202的博客
12-21 711
我们加入这个权限后，多媒体应用就可以在U盘或者sd卡目录下面创建和删除文件了，由上面可以看出这个就是media和dscard的管理权限。但是还是不行，不过我们在源码权限文件platform.xml发现了这个权限。
Android U盘读写
qidixiaoxian的博客
11-29 498
修改项目（app）的build.gradle /* * exel导入导出 * */ implementation group: 'net.sourceforge.jexcelapi', name: 'jxl', version: '2.6.12' /* * libaums * https://github.com/magnusja/libaums#usin...
micro usb接口正负极_ORICO这个U盘有三种接口，堪称安卓设备用户必备利器
weixin_39700215的博客
10-22 543
虽然现如今移动硬盘已经成为了商务人士以及学生用户们在选购移动存储设备时的首选，但拥有出色便携性优势的U盘依旧是生活与工作中必备的配件。如果你是安卓手机、安卓平板用户，并且正打算入手一款U盘的话，相信ORICO推出的这款三接口U盘(ORICO FL-TC)就是非常不错的选择。这款ORICO三接口U盘共有安卓接口以及苹果接口两个版本，分别对应着安卓设备用户以及苹果设备用户，不过由于iOS的原因，安卓设...
android tf卡及u盘_在Android中读写U盘
weixin_39728213的博客
12-29 1300
原文链接：https://www.zybuluo.com/Tyhj/note/1144629最近工作中遇到数据从U盘导出的功能，网上找了一下，有个开源的框架可以拿来使用，U盘和内存卡什么的不一样，是用OTG口来连接手机的，有些手机不支持，有些手机支持，U盘格式也有几种，常见的exFAT、FAT32、NTFS，有些手机可能不支持所有格式的U盘，//导入依赖：compile 'com.github.m...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值