获取U盘路径和读取U盘文件

最新推荐文章于 2024-08-12 03:40:05 发布
最新推荐文章于 2024-08-12 03:40:05 发布
阅读量2.8k 收藏
点赞数
分类专栏： android笔记 文章标签： sqlite android U盘 路径 文件读写
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunxiaolin2016/article/details/106259900
版权

1.只有系统应用才有权限读写U盘文件
2.使用StorageVolume，通过反射的方式获取U盘的绝对路径，系统应用不需要反射

//AudioDatabase.java
//数据库操作
/**

  • A helper class that manages all operations relating to the database. This class should not

  • be accessed directly. Instead, {@link AudioStorage} interfaces directly with it.
    */
    public final class AudioDatabase extends SQLiteOpenHelper {
    private static final String TAG = “Audio.AudioDatabase”;
    private static final String DATABASE_NAME = “AudioDatabase”;
    private static final int DATABASE_VERSION = 1;

    private Context mContext;

    private static String mDatabasePath;

    SQLiteDatabase mDatabase;
    //private final String DATABASE_PATH = android.os.Environment.getExternalStorageDirectory().getAbsolutePath() + “/audio”;

    private final String DATABASE_PATH;

    private String DATABASE_FILENAME = “chime_param.db”;

    public AudioDatabase(Context context){
    super(context, DATABASE_NAME, null /* factory */, DATABASE_VERSION);
    mContext = context;

     DATABASE_PATH = "/data/data/" + mContext.getPackageName()+"/"+"databases";

    }

    public SQLiteDatabase openDatabase(String path) {
    try {
    mDatabasePath = path;
    String databaseFilename = DATABASE_PATH + “/” + DATABASE_FILENAME;
    Log.i(TAG,“openDatabase,path =” + path);
    //File dir = new File(databaseFilename);
    //Log.i(TAG,"openDatabase,dir.exists() = " + dir.exists());
    //if (!dir.exists())
    // dir.mkdir();

         if(!checkDataBase()){
         return null;
     }

     Log.i(TAG,"openDatabase,dir.exists() = " + (new File(databaseFilename)).exists());
     File dbFile = new File(databaseFilename);
     if (!dbFile.exists()) {
         //InputStream is = mContext.getResources().openRawResource(R.raw.chime_param_external);
         dbFile.getParentFile().mkdir();
         dbFile.createNewFile();
         File file = new File(path);
         InputStream is = new FileInputStream(file);

         FileOutputStream fos = new FileOutputStream(databaseFilename);
         byte[] buffer = new byte[81920];
         int count = 0;
         while ((count = is.read(buffer)) > 0) {
             fos.write(buffer, 0, count);
         }
         fos.close();
         is.close();
     }
     Log.i(TAG,"openDatabase,databaseFilename= " +databaseFilename);
     mDatabase = SQLiteDatabase.openOrCreateDatabase(databaseFilename, null);
     return mDatabase;
 } catch (Exception e) {
     e.printStackTrace();
 }

 return null;

    }

    private boolean checkDataBase() {
    File dbFile = mContext.getDatabasePath(mDatabasePath);
    Log.i(TAG,“dbFile.exists()=” + dbFile.exists());
    if (dbFile.exists()) return true;
    if (!dbFile.getParentFile().exists()) {
    dbFile.getParentFile().mkdirs();
    }
    return false;
    }

    /**

    • The table that holds all the user’s currently stored presets.
      */
      public static final class ChimeTable {
      public static final String CHIME_INTER_TABLE_NAME = “Chime_inter”;
      public static final String CHIME_EXTER_TABLE_NAME = “Chime_exter”;
      public static final String PDC_INTER_TABLE_NAME = “PDC_inter”;
      public static final String PDC_EXTER_TABLE_NAME = “PDC_exter”;

      public static final class Columns {
      public static final String CID = “cid”;
      public static final String NAME = “name”;
      public static final String MASTER_VOLUME = “master_volume”;
      public static final String CROSSFADER = “crossfader”;
      public static final String ATTACK = “attack”;
      public static final String REL_TYPE = “rel_type”;
      public static final String RELEASE = “release”;
      public static final String TA = “TA”;
      public static final String TB = “TB”;
      public static final String FS = “fs”;
      public static final String ADDITIONAL_BOOST = “additional_boost”;
      public static final String REPEAT_TIME = “repeat_time”;
      public static final String CHANGE_TH = “change_th”;
      public static final String DECAY_TH = “decay_th”;
      public static final String EFFECT = “effect”;
      public static final String C02 = “c02”;
      public static final String C1 = “c1”;
      public static final String C3 = “c3”;
      public static final String NUMBER = “number”;
      public static final String SIGNAL_TYPE1 = “signal_type1”;
      public static final String FREQUENCY1 = “frequency1”;
      public static final String CLIP1 = “clip1”;
      public static final String OUT_AMPLIT1 = “out_amplit1”;
      public static final String T1 = “T1”;
      public static final String SIGNAL_TYPE2 = “signal_type2”;
      public static final String FREQUENCY2 = “frequency2”;
      public static final String CLIP2 = “clip2”;
      public static final String OUT_AMPLIT2 = “out_amplit2”;
      public static final String T2 = “T2”;
      public static final String SIGNAL_TYPE3 = “signal_type3”;
      public static final String FREQUENCY3 = “frequency3”;
      public static final String CLIP3 = “clip3”;
      public static final String OUT_AMPLIT3 = “out_amplit3”;
      public static final String T3 = “T3”;
      public static final String SIGNAL_TYPE4 = “signal_type4”;
      public static final String FREQUENCY4 = “frequency4”;
      public static final String CLIP4 = “clip4”;
      public static final String OUT_AMPLIT4 = “out_amplit4”;
      public static final String T4 = “T4”;
      public static final String SUPERPOSITION = “superposition”;
      }
      }

    /**

    • 查询全部数据
      */
      public List queryAllData(String table_name){

      //查询全部数据
      Cursor cursor = mDatabase.query(table_name,null,null,null,null,null,null,null);
      List list = new ArrayList<>();

      if(cursor.getCount() > 0)
      {
      //移动到首位
      cursor.moveToFirst();
      for (int i = 0; i < cursor.getCount(); i++) {
      int cid = cursor.getInt(cursor.getColumnIndex(CID));
      String name = cursor.getString(cursor.getColumnIndex(NAME));
      int master_volume = cursor.getInt(cursor.getColumnIndex(MASTER_VOLUME));
      int crossfader = cursor.getInt(cursor.getColumnIndex(CROSSFADER));
      int attack = cursor.getInt(cursor.getColumnIndex(ATTACK));
      int rel_type = cursor.getInt(cursor.getColumnIndex(REL_TYPE));
      int release = cursor.getInt(cursor.getColumnIndex(RELEASE));
      int ta = cursor.getInt(cursor.getColumnIndex(TA));
      int tb = cursor.getInt(cursor.getColumnIndex(TB));
      int fs = cursor.getInt(cursor.getColumnIndex(FS));
      int additional_boost = cursor.getInt(cursor.getColumnIndex(ADDITIONAL_BOOST));
      int repeat_time = cursor.getInt(cursor.getColumnIndex(REPEAT_TIME));
      int change_th = cursor.getInt(cursor.getColumnIndex(CHANGE_TH));
      int decay_th = cursor.getInt(cursor.getColumnIndex(DECAY_TH));
      int effect = cursor.getInt(cursor.getColumnIndex(EFFECT));
      int c02 = cursor.getInt(cursor.getColumnIndex(C02));
      int c1 = cursor.getInt(cursor.getColumnIndex(C1));
      int c3 = cursor.getInt(cursor.getColumnIndex(C3));
      int number = cursor.getInt(cursor.getColumnIndex(NUMBER));
      String superposition = cursor.getString(cursor.getColumnIndex(SUPERPOSITION));
      int signal_type1 = cursor.getInt(cursor.getColumnIndex(SIGNAL_TYPE1));
      int frequency1 = cursor.getInt(cursor.getColumnIndex(FREQUENCY1));
      int clip1 = cursor.getInt(cursor.getColumnIndex(CLIP1));
      int out_amplit1 = cursor.getInt(cursor.getColumnIndex(OUT_AMPLIT1));
      int t1 = cursor.getInt(cursor.getColumnIndex(T1));
      int signal_type2 = cursor.getInt(cursor.getColumnIndex(SIGNAL_TYPE2));
      int frequency2 = cursor.getInt(cursor.getColumnIndex(FREQUENCY2));
      int clip2 = cursor.getInt(cursor.getColumnIndex(CLIP2));
      int out_amplit2 = cursor.getInt(cursor.getColumnIndex(OUT_AMPLIT2));
      int t2 = cursor.getInt(cursor.getColumnIndex(T2));
      int signal_type3 = cursor.getInt(cursor.getColumnIndex(SIGNAL_TYPE3));
      int frequency3 = cursor.getInt(cursor.getColumnIndex(FREQUENCY3));
      int clip3 = cursor.getInt(cursor.getColumnIndex(CLIP3));
      int out_amplit3 = cursor.getInt(cursor.getColumnIndex(OUT_AMPLIT3));
      int t3 = cursor.getInt(cursor.getColumnIndex(T3));
      int signal_type4 = cursor.getInt(cursor.getColumnIndex(SIGNAL_TYPE4));
      int frequency4 = cursor.getInt(cursor.getColumnIndex(FREQUENCY4));
      int clip4 = cursor.getInt(cursor.getColumnIndex(CLIP4));
      int out_amplit4 = cursor.getInt(cursor.getColumnIndex(OUT_AMPLIT4));
      int t4 = cursor.getInt(cursor.getColumnIndex(T4));

           ChimeModel model = new ChimeModel();
     model.setCid(cid);
     model.setCname(name);
     model.setMaster_volume(master_volume);
     model.setCrossfader(crossfader);
     model.setAttack(attack);
     model.setRel_type(rel_type);
     model.setRelease(release);
     model.setTa(ta);
     model.setTb(tb);
     model.setFs(fs);
     model.setAdditional_boost(additional_boost);
     model.setRepeat_time(repeat_time);
     model.setChange_th(change_th);
     model.setDecay_th(decay_th);
     model.setEffect(effect);
     model.setC02(c02);
     model.setC1(c1);
     model.setC3(c3);
     model.setNumber(number);
     model.setSuperposition(superposition);
     model.setSignal_type1(signal_type1);
     model.setFrequency1(frequency1);
     model.setClip1(clip1);
     model.setOut_amplit1(out_amplit1);
     model.setT1(t1);
     model.setSignal_type2(signal_type2);
     model.setFrequency2(frequency2);
     model.setClip2(clip2);
     model.setOut_amplit2(out_amplit2);
     model.setT2(t2);
     model.setSignal_type3(signal_type3);
     model.setFrequency3(frequency3);
     model.setClip3(clip3);
     model.setOut_amplit3(out_amplit3);
     model.setT3(t3);
     model.setSignal_type4(signal_type4);
     model.setFrequency4(frequency4);
     model.setClip4(clip4);
     model.setOut_amplit4(out_amplit4);
     model.setT4(t4);

     Log.i(TAG,"model.getMaster_volume()=" + model.getMaster_volume());
     list.add(model);
     cursor.moveToNext();
 }

      }

      cursor.close();
      //getWritableDatabase().close();
      mDatabase.close();

      return list;
      }

    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {

    }
    }

//获取U盘路径
public class FileUtils {
private static final String TAG = “FileUtils”;
/**
* 根据Uri获取图片绝对路径
* @param context context
* @param uri uri
*/
public static String getFileAbsolutePath(Context context, Uri uri) {
if (context == null || uri == null) return null;
// DocumentProvider
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, uri)) {
if (isExternalStorageDocument(uri)) {
final String docId = DocumentsContract.getDocumentId(uri);
final String[] split = docId.split("😊;
final String type = split[0];

            Log.i(TAG,"docId=" + docId);
            Log.i(TAG,"split[0]=" + split[0]);
            Log.i(TAG,"split[1]=" + split[1]);
            Log.i(TAG,"getUsbPath=" + getUsbPath());
            if ("primary".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/" + split[1];
            }else if ("home".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/documents/" + split[1];
            }else{
                return getUsbPath() + "/" + split[1];
            }
        } else if (isDownloadsDocument(uri)) {
            // DownloadsProvider
            final String id = DocumentsContract.getDocumentId(uri);
            if (TextUtils.isEmpty(id)) {
                return null;
            }
            if (id.startsWith("raw:")) {
                return id.substring(4);
            }
            String[] contentUriPrefixesToTry = new String[]{
                    "content://downloads/public_downloads",
                    "content://downloads/my_downloads",
                    "content://downloads/all_downloads"
            };
            for (String contentUriPrefix : contentUriPrefixesToTry) {
                try {
                    Uri contentUri = ContentUris.withAppendedId(Uri.parse(contentUriPrefix), Long.valueOf(id));
                    String path = getDataColumn(context, contentUri, null, null);
                    if (path != null) {
                        return path;
                    }
                } catch (Exception ignore) {
                }
            }
            try {
                String path = getDataColumn(context, uri, null, null);
                if (path != null) {
                    return path;
                }
            } catch (Exception ignore) {
            }
            // path could not be retrieved using ContentResolver, therefore copy file to accessible cache using streams
            return null;
        } else if (isMediaDocument(uri)) {
            // MediaProvider
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            Uri contentUri;
            Log.i(TAG,"type.toLowerCase(Locale.ENGLISH)=" + type.toLowerCase(Locale.ENGLISH));
            switch (type.toLowerCase(Locale.ENGLISH)) {
                case "image":
                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                    break;
                case "video":
                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                    break;
                case "audio":
                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                    break;
                default:
                    contentUri = MediaStore.Files.getContentUri("external");
                    break;
            }
            final String selection = MediaStore.MediaColumns._ID +"=?";
            final String[] selectionArgs = new String[]{split[1]};
            return getDataColumn(context, contentUri, selection, selectionArgs);
        }
    } else if (ContentResolver.SCHEME_CONTENT.equalsIgnoreCase(uri.getScheme())) {
        // MediaStore (and general)
        // Return the remote address
        if (isGooglePhotosUri(uri)) {
            return uri.getLastPathSegment();
        }
        return getDataColumn(context, uri, null, null);
    } else if (ContentResolver.SCHEME_FILE.equalsIgnoreCase(uri.getScheme())) {
        // File
        return uri.getPath();
    }
    return null;
}

/**
 * 通过游标获取当前文件路径
 * @param context       context
 * @param uri           uri
 * @param selection     selection
 * @param selectionArgs selectionArgs
 * @return 路径，未找到返回null
 */
public static String getDataColumn(Context context, @NonNull Uri uri, String selection, String[] selectionArgs) {
    Cursor cursor = null;
    String column = MediaStore.Images.Media.DATA;
    String[] projection = {column};
    try {
        cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
        if (cursor != null && cursor.moveToFirst()) {
            int index = cursor.getColumnIndexOrThrow(column);
            return cursor.getString(index);
        }
    } catch (Exception ignore) {
    } finally {
        if (cursor != null)
            cursor.close();
    }
    return null;
}

public static boolean isExternalStorageDocument(Uri uri) {
    return "com.android.externalstorage.documents".equals(uri.getAuthority());
}

public static boolean isDownloadsDocument(Uri uri) {
    return "com.android.providers.downloads.documents".equals(uri.getAuthority());
}

public static boolean isMediaDocument(Uri uri) {
    return "com.android.providers.media.documents".equals(uri.getAuthority());
}

public static boolean isGooglePhotosUri(Uri uri) {
    return "com.google.android.apps.photos.content".equals(uri.getAuthority());
}


private static String getUsbPath(){
    StorageManager mStorageManager;
    mStorageManager = (StorageManager) AudioApplication.getInstance().getSystemService(Context.STORAGE_SERVICE);
    //获取所有挂载的设备（内部sd卡、外部sd卡、挂载的U盘）
    List<StorageVolume> volumes = mStorageManager.getStorageVolumes();

    String path = null;

    try {
        Class<?> storageVolumeClazz = Class
                .forName("android.os.storage.StorageVolume");
        //通过反射调用系统hide的方法
        Method getPath = storageVolumeClazz.getMethod("getPath");
        Method isRemovable = storageVolumeClazz.getMethod("isRemovable");
        for (int i = 0; i < volumes.size(); i++) {
            StorageVolume storageVolume = volumes.get(i);//获取每个挂载的StorageVolume

            //通过反射调用getPath、isRemovable
            String storagePath = (String) getPath.invoke(storageVolume); //获取路径
            boolean isRemovableResult = (boolean) isRemovable.invoke(storageVolume);//是否可移除
            String description = storageVolume.getDescription(AudioApplication.getInstance());
            //Log.d(TAG, " i=" + i + " ,storagePath=" + storagePath + " ,isRemovableResult=" + isRemovableResult +" ,description="+description);
            if(isRemovableResult){
                path = storagePath;
            }
        }
    } catch (Exception e) {
        Log.d("jason", " e:" + e);
    }

    return path;
}

}

sunxiaolin2016
关注
专栏目录
用win32 API监听U盘插拔并取得其盘符/取得当前插入U盘的盘符
u012297136的专栏
02-25 5350
1.使用RegisterDeviceNotification()函数注册 static const GUID GUID_DEVINTERFACE_USB_DEVICE = {0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED}}; void RegisterDeviceNotify() {
java获取u盘_自写java小程序 U盘偷取小文件
weixin_29048775的博客
02-17 250
[Java] 纯文本查看 复制代码package com.atguigu.java;import java.io.*;public class Detection {public void runopen() {System.out.println("启动检测U盘......-----Duan");byte[] words = null;// File.listRoots(); 返回我们电脑上所有...
java获得U盘根目录、读取图片视频头文件信息、获取视频时长
程序员Monkey的专栏
03-13 4724
1、获得U盘根目录，例如我们取名U盘名称为"测试U盘"，一般插入U盘后，在系统的H盘 /** * 得到系统U盘根目录 */ public String findURootPath(){ FileSystemView sys = FileSystemView.getFileSystemView(); //循环盘符 File[] files = File.list
android 获取U盘文件
最新发布
weixin_40544096的博客
08-12 103
Android 获取 U 盘文件的完整指南 在 Android 应用开发中，有时需要从 U 盘中获取文件。对于初学者来说，这可能会显得有些复杂。在本教程中，我们将详细介绍如何在 Android 应用中实现获取 U 盘文件的功能，并为你提供清晰的步骤和代码示例。 整体流程 为了帮助你更好地理解整个过程，下面是我们将要进行的步...
如何得到插入U盘的盘符
03-24 416
使用GetDriveType函数得到插入U盘的盘符，具体实现代码如下：  for (szDrierName[0]=C;szDriverName[0]{              if(GetDriveType(szDriverName)==DRIVER_REMOVABLE)                /搜索盘符，获得磁盘类型是DRIVER_REMOVABLE ,即U盘。
通过U盘的盘符找到USB设备
Five_Sea的博客
06-10 4237
1.判断磁盘的类型 if (GetDriveType(szRootPathName) != DRIVE_REMOVABLE) { m_csErrorMsg.Format(_T("该磁盘不是可移动磁盘")); } csLogicDisk.Format(_T("\\\\.\\%c:"), csDiskSymbol[0]);
Android U盘读写 反射获取U盘路径
04-09
由于Android的安全机制，开发者不能直接通过常规方式获取到U盘的路径，而是需要通过反射技术来实现。本文将详细讲解如何在Android应用中进行U盘读写操作以及如何反射获取U盘路径。 首先，我们需要理解Android的存储...
Android 获取OTG U盘路径 sdcard路径
05-23
在Android系统中，获取OTG（On-The-Go）U盘的路径以及内部或外部SD卡的路径是进行文件操作的基础。这篇详细解释将围绕如何在Android M及以上版本的设备上实现这一功能，并提供一个简单实用的代码示例。 首先，我们...
Android N获取外置SD卡或挂载U盘路径的方法
01-04
在Android N上并没有提供直接的方法获取外置SD卡或挂载U盘路径，可以通过下面方法获取内置sd卡路径 Environment.getExternalStorageDirectory().getAbsolutePath(); 通过查看getExternalStorageDirectory源码发现，...
android通过usb读取U盘的方法
08-27
Android 通过 USB 读取 U 盘的方法需要 Android 设备支持 USB 主机模式，添加相应的权限声明和特征声明，注册监听 U 盘插入和拔出的广播，获取 U 盘的设备实例，获取 U 盘的分区信息，读取 U 盘中的文件。...
visual c++获取U盘信息
12-27
首先，我们需要知道的是Windows操作系统中的设备驱动模型（Device Driver Model, DDM）和文件系统枚举机制。当U盘插入计算机时，操作系统会为它创建一个设备节点，通常在"设备管理器"中可以看到。我们可以通过查询...
Android 实现读写U盘文件
06-05
Android 基于libaums实现读写U盘文件，相关博客：https://blog.csdn.net/a512337862/article/details/80505128
VC++获取U盘盘符（各种类型的驱动器都可以）
haoshen1987的专栏
11-09 4128
CString GetUDiskRoot() { CString UDiskRoot = ""; UINT DiskType; size_t szAllDriveStr = GetLogicalDriveStrings(0,NULL); char *pDriveStr = new char[szAllDriveStr + sizeof(_T(" "))]; char *pForDelet
读取插入电脑指定的USB接口U盘链接地址（sda、sdb）
净无邪博客
02-27 1522
下面是读取插入电脑指定的USB接口U盘参考链接。 https://blog.csdn.net/weixin_38717571/article/details/83045040（参考：完整解决方案） http://bbs.chinaunix.net/thread-4172823-1-1.html（参考：修改固定usb端口中的设备名称） https://www.cnblogs.com/ynxf/...
如何获取U盘里的文件实际路径
wujiang_android的博客
06-08 4060
public void onClick(View view) {    switch (view.getId()) {        case R.id.btn_sql_path:            Intent intent;            if (android.os.Build.VERSION.SDK_INT &gt;= android.os.Build.VERSION_CODE...
Windows下USB磁盘开发系列三：枚举系统中U盘、并获取其设备信息
爬行的菜鸟的博客
11-02 2947
前面我们介绍了枚举系统中的U盘盘符（见《Windows下USB磁盘开发系列一：枚举系统中U盘的盘符》）、以及获取USB设备的信息（见《Windows下USB磁盘开发系列二：枚举系统中所有USB设备》）。有个时候我们不仅仅需要获取U盘盘符（路径），而且需要获取该U盘的硬件信息，比如厂商、friendly name、描述等等。那么我们可以通过前面两个方法，把U盘盘符和设备信息匹配起来吗？答案是肯定的，...
Android开发，获取U盘插拔状态，并获取U盘的路径
afufufufu的博客
07-01 3521
Android开发中，获取U盘的路径
Android获取U盘或SD卡路径
u010823818的博客
12-22 820
【代码】Android获取U盘或SD卡路径。
Android获取U盘路径并复制文件夹
wolf0706的专栏
04-11 1388
本文介绍如何复制设备目录到外接U盘目录。
android 读取u盘指定路径的文件
06-07
您可以使用Android提供的Storage Access Framework (SAF) API来读取U盘中指定路径的文件。 以下是示例代码： ```java // 在activity中启动SAF API private static final int READ_REQUEST_CODE = 42; public void ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sunxiaolin2016

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值