精华内容
下载资源
问答
  • 文件为利用反射机制进行androidU盘安全卸载的代码,使用此方法方法时,需注意需要打系统包名
  • 主要介绍了Android编程实现识别与挂载U盘的方法,对比分析了Android针对U盘的识别与挂载技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 本文实例为大家分享了android通过usb读取U盘的具体代码,供大家参考,具体内容如下 1.关联 compile ‘com.github.mjdev:libaums:+’ 2.权限设置 <uses android:name=android.permission.WRITE_EXTERNAL_STORAGE> ...
  • Android 基于libaums实现读写U盘文件,相关博客:https://blog.csdn.net/a512337862/article/details/80505128
  • Android U盘插拔监听以及U盘写入权限解决办法 https://blog.csdn.net/qq_31939617/article/details/80447276
  • Android读取U盘

    2018-07-10 12:51:11
    Android TV读取外部U盘方法 读写操作,。。
  • 今天小编就为大家分享一篇android 识别U盘以及读写文件的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Android U盘插拔监听详细版以及U盘写入权限解决办法 https://blog.csdn.net/qq_31939617/article/details/80447276
  • 今天小编就为大家分享一篇Android 6.0上sdcard和U盘路径获取和区分方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Android M 读取OTG U盘路径和sdcard路径demo , 第三方apk可以参考使用。摘要为什么要50个字,为什么呢?
  • Android 文件选择器(支持选择u盘),支持sd卡,支持内置,支持U盘选择,支持多选,支持文件,文件夹的选择。
  • android通过otg去读取U盘的内容并进行读写操作.
  • Android通过U盘更新程序 https://blog.csdn.net/qq_31939617/article/details/80749448
  • Android vold 多U盘多分区挂载实现

    热门讨论 2015-05-19 09:45:27
    Android vold 多U盘多分区挂载实现 可以对比原生的vold代码查看修改
  • 现在越来越多手机支持OTG功能,通过OTG可以实现与外接入的U盘等USB设备实现数据传输。  USB OTG(On The Go)作为USB2.0的补充协议,于2001年由USB-IF提出。它提出的背景是移动消费类电子产品的迅猛增加,而之前USB...
  • Android U盘读写 反射获取U盘路径
  • Android 读取U盘或SD卡中的所有.txt文件 https://blog.csdn.net/qq_31939617/article/details/80765285
  • 项目需要,每次插入U盘需要格式化。 刚看到这个需求的时候感觉很简单,调一行api就搞定的,事实证明还是太年轻了 android没有提供相应的api,于是百度 参考Android格式化外部设备如USB等_AZZ的博客-CSDN博客 ...

    项目需要,每次插入U盘需要格式化。

    刚看到这个需求的时候感觉很简单,调一行api就搞定的,事实证明还是太年轻了

    android没有提供相应的api,于是百度

    参考 Android格式化外部设备如USB等_AZZ的博客-CSDN博客

    按照一贯的风格,直接CV大法,兴高采烈的发现行不通,有些类在android高版本都没了,这篇博客是基于android5.0,这会儿在我这用不成。

    后来翻了很久,发现了StorageManager这个关键的类。

    这个类在/frameworks/base/core/java/android/os/storage/StorageManager.java下,

    StorageManager是Android SDK中管理存储设备的一个类。其中的存储设备分内部存储和外部存储,外部存储可以有SDCard、U盘等其他挂载的外设。

    还有StorageVolume类
    StorageVolume代表的是一个设备信息的数据结构,里面包含了名称、路径、挂载状态等等信息。

    StorageManager中我找到了两个方法

    移除U盘:

     格式化U盘:

     这两个方法没有任何说明,并且是hide标签,意味着得用反射。还有参数volid我一度不知道是啥玩意儿。

    尝试以后,通过传入StorageVolume.getid(usb的id),成功

    下面附上代码:

       // 获取 StorageVolume 对象
        public void getStoragePath(Context mContext) {
            mStorageManager = (StorageManager) 
            mContext.getSystemService(Context.STORAGE_SERVICE);
            Class<?> storageVolumeClazz = null;
            try {
                storageVolumeClazz = Class.forName("android.os.storage.StorageVolume");
                //暂且称之为获取usb列表
                Method getVolumeList = mStorageManager.getClass().getMethod("getVolumeList");
                //拿到format方法
                Method format = mStorageManager.getClass().getMethod("format", String.class);
                //拿到StorageVolume 的getpath方法
                Method getPath = storageVolumeClazz.getMethod("getPath");
                 //拿到StorageVolume 的getId方法
                Method getId = storageVolumeClazz.getMethod("getId");
                Method isRemovable = storageVolumeClazz.getMethod("isRemovable");
                Object result = getVolumeList.invoke(mStorageManager);
                final int length = Array.getLength(result);
                //遍历列表
                for (int i = 0; i < length; i++) {
                    Object storageVolumeElement = Array.get(result, i);
                    String path = (String) getPath.invoke(storageVolumeElement);
                    boolean removable = (Boolean) isRemovable.invoke(storageVolumeElement);
                    //如果当前的usb地址和我们定义的地址一样的话,就操作它
                    if (removable && path.equals(mPreferUsbPath)) {
                        String id = (String) getId.invoke(storageVolumeElement);
                        //格式化它!!
                        format.invoke(mStorageManager, id);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    以上,格式化USB算是完成了。

    顺便还解决了移除USB功能,刚好是下周要做的功能,开心!!!

    展开全文
  • 主要为大家详细介绍了Android将数据写入Excel格式导出U盘、发送邮件,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Android 读取U盘文件

    2021-02-19 16:02:59
    下图就是我通过adb命令查看到我插入Android设备U盘的相关信息 上面我们可以很清楚看到U盘挂载的路径是/mnt/media_rw,而我的U盘名称是B4FE-5315,通过adb命令查看到自己想要的路径了,那么就是如何获取路径的...

    一、通过adb 方式连接Android设备,然后通过adb 命令也就是Linux 命令查看Android设备相关的目录,

          下图就是我通过adb命令查看到我插入Android设备U盘的相关信息

     

    上面我们可以很清楚看到U盘挂载的路径是 /mnt/media_rw,而我的U盘名称是B4FE-5315,通过adb命令查看到自己想要的路径了,那么就是如何获取路径的问题了

    二、获取U盘路径

    本代码主要参考了:https://www.jianshu.com/p/b2425efca483

    import android.util.Log;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.List;
    
    public class ReadUDiskUtil {
    
        public final static String searchPath() {
            String filePath = "/proc/mounts";
            File file = new File(filePath);
            List<String> lineList = new ArrayList<>();
            InputStream inputStream =null;
            try {
                inputStream = new FileInputStream(file);
                if (inputStream != null) {
                    InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "GBK");
                    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
                    String line = "";
                    while ((line = bufferedReader.readLine()) != null) {
    //                    Log.e("TAG",line);
                        if (line.contains("vfat")) {
                            lineList.add(line);
                        }
                    }
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            String editPath = lineList.get(lineList.size() - 1);
            int start = editPath.indexOf("/mnt");
            int end = editPath.indexOf(" vfat");
            String path = editPath.substring(start, end);
            Log.d("TAG_SelectBusLineDialog", "path: " + path);
            return path;
        }
    }
    

     

    三、使用

    比如使用VideoView播放视频

    uri = Uri.parse(ReadUDiskUtil.searchPath()+"/video.mp4");
    videoView.setVideoURI(uri);
    videoView.start();

     

     

    展开全文
  • 利用libaums在android上实现Android端读写U盘的功能,并将其进行了封装,写了个工具类,可以实现u盘与本地数据互传功能
  • UMS Interface This program allows you to chose a block device or disk image as a 'disk', and communicate with PC through usb mass storage (just as usb disk do). Root permission is needed. ...
  • android检测U盘插拔事件

    千次下载 热门讨论 2013-04-26 17:05:52
    工程里面有俩包,分别用了两种方法检测U盘热插拔,但只有利用广播方式监听U盘热插拔这种方式有效。
  • Android关于读写U盘文件-操作外置sd卡一、背景二、可行性分析关于问题1关于问题2关于问题2,我们可以采取四种方式操作:实现效果依赖build.gradle布局文件activity_u.xml权限AndroidManifest.xml一个类UsbActivity三...

    一、背景

    很久以前做过这个功能,一直没有总结。碰巧最近有网友问到,就总结一下。
    项目要求实现两个功能:
    1、读取U盘里的apk文件并安装
    2、导出数据,生成Excel表格到U盘

    二、可行性分析

    关于问题1

    第一个问题很简单,读取U盘里的内容并安装是不需要系统权限的。动态获取到读权限就可以了

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

    关于问题2

    我们需要获取到

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

    但是即使我们获取了写入权限,写入的时候,依旧会失败,会提示permission denied。
    原因是:
    Android5.0以上系统已经不支持开发者随便写手机的外部存储(包含tf卡、otg外接u盘等),必须用特定的方法去读写。即5.0以下我们还是可以直接读写的(直接拿到U盘文件路径也可以操作)。

    关于问题2,我们可以采取四种方式操作:

    1、使用google提供的特定方式,SAF框架操作外置sd卡,关键字DocumentFile.
    2、只操作固定的目录:Android/data/包名/…,这里面你可以随便做操作,不过app删了,这些数据也会自动删掉。
    3、使用第三方的框架libaums
    4、系统签名,成为系统应用

    //目前最新版本为0.7.0,但是该版本的兼容库已迁移至androidx
    implementation 'com.github.mjdev:libaums:0.6.0'
    

    我最后采取的是第四种方式。
    但是这个文章主要是为第三种方式提供demo。
    注意:当时调研的时候发现libaums这个框架对于nfts格式的U盘读取是有问题的,貌似只支持FAT32。
    我没有去研究libaums的源码,并不知道它是如何在没有权限的情况下写入成功的。观测情况是,一旦授予权限,文件管理器是看不到这个U盘的。所以我估计,它可能是把U盘挂载到了其他地方。
    以上都是废话,下面是经测可用的demo。

    实现效果

    把挂载到Android设备的U盘,遍历文件并输出。进行简单的读写操作。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    依赖build.gradle

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

    布局文件activity_u.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout
        xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent"
        android:layout_height="match_parent">
        <ScrollView
            android:layout_width="match_parent"
            android:layout_height="match_parent">
            <TextView
                android:textStyle="bold"
                android:textColor="#000000"
                android:textSize="16sp"
                android:id="@+id/log_tv"
                android:text="content \ndisplay"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content" />
        </ScrollView>
    </LinearLayout>
    

    权限AndroidManifest.xml

     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
        <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
        <!--手机必须支持USB主机特性(OTG)-->
        <uses-feature android:name="android.hardware.usb.host" />
    

    一个类UsbActivity

    package com.example.pc.testeverything.Activity;
    
    import android.Manifest;
    import android.app.PendingIntent;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.hardware.usb.UsbDevice;
    import android.hardware.usb.UsbManager;
    import android.os.Build;
    import android.os.Bundle;
    import android.support.annotation.Nullable;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.widget.TextView;
    
    import com.example.pc.testeverything.R;
    import com.github.mjdev.libaums.UsbMassStorageDevice;
    import com.github.mjdev.libaums.fs.FileSystem;
    import com.github.mjdev.libaums.fs.UsbFile;
    import com.github.mjdev.libaums.fs.UsbFileStreamFactory;
    import com.github.mjdev.libaums.partition.Partition;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.util.Locale;
    
    import static android.hardware.usb.UsbManager.ACTION_USB_DEVICE_ATTACHED;
    import static android.hardware.usb.UsbManager.ACTION_USB_DEVICE_DETACHED;
    
    
    /**
     * 写了一个简单测试
     *
     * @author Rachel
     */
    public class UsbActivity extends AppCompatActivity {
        private static final String TAG = "Rachel_test";
        private static final String ACTION_USB_PERMISSION = "com.demo.otgusb.USB_PERMISSION";
        private UsbMassStorageDevice[] storageDevices;
        private TextView logTv;
        /**
         * 监听USB设备的广播
         */
        BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
    
            @Override
            public void onReceive(Context context, Intent intent) {
                String intentAction = intent.getAction();
                UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                switch (intentAction) {
                    case ACTION_USB_PERMISSION:
                        //自定义Action
                        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                            logShow("用户同意USB设备访问权限");
                            readDevice(getUsbMass(device));
                        } else {
                            logShow("用户拒绝USB设备访问权限");
                        }
                        break;
                    case ACTION_USB_DEVICE_ATTACHED:
                        logShow("U盘设备插入");
                        if (device != null) {
                            redUDiskDeviceList();
                        }
                        break;
                    case ACTION_USB_DEVICE_DETACHED:
                        logShow("U盘设备移除");
                        break;
                    default:
                        Log.i(TAG, "----------------------------------");
                }
            }
        };
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_u);
            logTv = (TextView) findViewById(R.id.log_tv);
            init();
        }
    
        /**
         * 动态申请读写权限
         */
        private void init() {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,
                        Manifest.permission.READ_EXTERNAL_STORAGE}, 111);
            }
            registerUsbReceiver();
            redUDiskDeviceList();
        }
    
        /**
         * 权限申请回调
         *
         * @param requestCode 标识码
         */
        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if (requestCode == 111) {
                registerUsbReceiver();
                redUDiskDeviceList();
            }
        }
    
        /**
         * 动态注册监听USB设备的广播。
         * 由于耗电等原因,8.0不能对大部分的广播进行静态注册
         */
        private void registerUsbReceiver() {
            IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
            filter.addAction("android.hardware.usb.action.USB_STATE");
            filter.addAction("android.hardware.usb.action.USB_DEVICE_ATTACHED");
            filter.addAction("android.hardware.usb.action.USB_DEVICE_DETACHED");
            registerReceiver(mUsbReceiver, filter);
        }
    
        /**
         * 获取存储设备
         *
         * @param usbDevice 与android设备连接在一起的USB设备
         * @return Usb设备的一个包装类
         */
        private UsbMassStorageDevice getUsbMass(UsbDevice usbDevice) {
            for (UsbMassStorageDevice device : storageDevices) {
                if (usbDevice.equals(device.getUsbDevice())) {
                    return device;
                }
            }
            return null;
        }
    
        /**
         * 初始化USB设备
         *
         * @param device USB设备
         */
        private void readDevice(UsbMassStorageDevice device) {
            try {
                device.init();//初始化
                //设备分区
                Partition partition = device.getPartitions().get(0);
                //文件系统
                FileSystem currentFs = partition.getFileSystem();
                //可以获取到设备的标识
                currentFs.getVolumeLabel();
                //通过FileSystem可以获取当前U盘的一些存储信息,包括剩余空间大小,容量等等
                Log.e("Volume Label: ", currentFs.getVolumeLabel());
                Log.e("Capacity: ", fSize(currentFs.getCapacity()));
                Log.e("Occupied Space: ", fSize(currentFs.getOccupiedSpace()));
                Log.e("Free Space: ", fSize(currentFs.getFreeSpace()));
                Log.e("Chunk size: ", fSize(currentFs.getChunkSize()));
                readAndWriteTest(currentFs);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * USB设备读取
         */
        private void redUDiskDeviceList() {
            Context context = this;
            //设备管理器
            UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
            //获取U盘存储设备
            storageDevices = UsbMassStorageDevice.getMassStorageDevices(context);
            PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0);
            //一般手机只有1个OTG插口
            if (storageDevices.length <= 0) {
                return;
            }
            UsbMassStorageDevice device = storageDevices[0];
            //读取设备是否有权限
            if (usbManager.hasPermission(device.getUsbDevice())) {
                readDevice(device);
            } else {
                //没有权限,进行申请
                usbManager.requestPermission(device.getUsbDevice(), pendingIntent);
            }
        }
    
        private void logShow(final String s) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    logTv.setText(logTv.getText() + "\n" + s);
                }
            });
        }
    
    
        /**
         * 读写文件尝试
         *
         * @param currentFs
         */
        private void readAndWriteTest(FileSystem currentFs) {
            try {
                //设置当前文件对象为根目录
                UsbFile usbFile = currentFs.getRootDirectory();
                UsbFile[] files = usbFile.listFiles();
                for (UsbFile file : files) {
                    logShow("文件: " + file.getName());
                }
                // 新建文件
                UsbFile newFile = usbFile.createFile("hello_" + System.currentTimeMillis() + ".txt");
                logShow("新建文件: " + newFile.getName());
    
                // 写文件
                OutputStream os = UsbFileStreamFactory.createBufferedOutputStream(newFile, currentFs);
                os.write(("hi_" + System.currentTimeMillis()).getBytes());
                os.close();
                logShow("写文件: " + newFile.getName());
                // 读文件
                // InputStream is = new UsbFileInputStream(newFile);
                InputStream is = UsbFileStreamFactory.createBufferedInputStream(newFile, currentFs);
                byte[] buffer = new byte[currentFs.getChunkSize()];
                int len;
                File sdFile = new File("/sdcard/111");
                sdFile.mkdirs();
                FileOutputStream sdOut = new FileOutputStream(sdFile.getAbsolutePath() + "/" + newFile.getName());
                while ((len = is.read(buffer)) != -1) {
                    sdOut.write(buffer, 0, len);
                }
                is.close();
                sdOut.close();
                logShow("读文件: " + newFile.getName() + " ->复制到/sdcard/111/");
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    
        public static String fSize(long sizeInByte) {
            if (sizeInByte < 1024) {
                return String.format("%s", sizeInByte);
            } else if (sizeInByte < 1024 * 1024) {
                return String.format(Locale.CANADA, "%.2fKB", sizeInByte / 1024.);
            } else if (sizeInByte < 1024 * 1024 * 1024) {
                return String.format(Locale.CANADA, "%.2fMB", sizeInByte / 1024. / 1024);
            } else {
                return String.format(Locale.CANADA, "%.2fGB", sizeInByte / 1024. / 1024 / 1024);
            }
        }
    }
    
    

    三、参考文章

    libaums
    android OTG (USB读写,U盘读写)最全使用相关总结
    Android-USB-OTG-读写U盘文件

    SAF
    android 使用SAF框架操作外置sd卡
    android官网

    四、DEMO

    TestEverything
    注:一个测试demo,里面都是乱七八糟的东西,不建议下载。第15个,是本文的测试。
    在这里插入图片描述

    Java基础不好的小水怪,正在学习。有错请指出,一起加油。

    展开全文
  • Android N上并没有提供直接的方法获取外置SD卡或挂载U盘路径,可以通过下面方法获取内置sd卡路径 Environment.getExternalStorageDirectory().getAbsolutePath(); 通过查看getExternalStorageDirectory源码发现,...
  • cat /proc/partitions 查看有u盘设备 df 查看挂载情况 iTOP4416开发板插入u盘,自动挂载到 /mnt/udisk1 转载于:https://www.cnblogs.com/god-of-death/p/8724196.html

    cat /proc/partitions 查看有u盘设备

     

    df 查看挂载情况

     

    iTOP4416开发板插入u盘,自动挂载到 /mnt/udisk1

    转载于:https://www.cnblogs.com/god-of-death/p/8724196.html

    展开全文
  • Android7获取U盘路径

    千次阅读 2020-05-23 02:11:11
    Android 设备禁用U盘获取U盘的真实路径直接上代码(实测Android7.1.2有效) 获取U盘的真实路径 直接上代码(实测Android7.1.2有效) public static String getUPath(Context context){ StorageManager mStorageManager ...
  • Toast.makeText(SplashActivity.this, "未检测到U盘", Toast.LENGTH_SHORT).show(); e.printStackTrace(); } catch (IOException e) { Toast.makeText(SplashActivity.this, "未检测到U盘", Toast.LENGTH_SHORT)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,777
精华内容 3,110
关键字:

u盘android