FileUtils

package com.warmlight.voicepacket.utils;

import android.annotation.SuppressLint;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.text.TextUtils;

import com.facebook.drawee.backends.pipeline.Fresco;
import com.facebook.drawee.controller.AbstractDraweeController;
import com.facebook.drawee.view.SimpleDraweeView;
import com.facebook.imagepipeline.postprocessors.IterativeBoxBlurPostProcessor;
import com.facebook.imagepipeline.request.ImageRequest;
import com.facebook.imagepipeline.request.ImageRequestBuilder;
import com.warmlight.voicepacket.R;
import com.warmlight.voicepacket.bean.upload.LocalVideoBean;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

public class FileUtils {
    /**
     * 本地文件路径及文件名
     */

    // SD卡目录
    public static final String SD_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/";

    // QQ下载目录
    public static final String QQ_DOWNLOAD_PATH = SD_PATH + "tencent/QQfile_recv/";
    // QQ语音目录
    public static final String QQ_VOICE_PATH = SD_PATH + "tencent/MobileQQ/";
    // 微信语音目录
    public static final String WX_VOICE_PATH = SD_PATH + "tencent/MicroMsg/";
    // 目录下留下多少条语音
    public static final int VOICE_NUM = 100;

    // App根目录
    public static final String APP_PATH = SD_PATH + "wanpi/";
    // App分享图片名
    public static final String SHARE_PIC = "share.png";

    // Assets语音包目录
    public static final String ASSETS_VOICE_PATH = "voice";

    // 音频文件夹目录
    public static final String VOICE_PATH = APP_PATH + "voice/";
    public static final String OK_DOWNLOAD_PATH = "wanpi/" + "download/";
    public static final String DOWNLOAD_PATH = SD_PATH + OK_DOWNLOAD_PATH;
    public static final String TTS_PATH = APP_PATH + "tts/";
    public static final String VOICE_ICON = "icon.jpg";

    public static final String ADFILE = APP_PATH + "ad/";

    public static String getRecordFile(Context context){
        File filesDir = context.getExternalFilesDir(null);

        File file = new File(filesDir,"record");
        if (!file.exists()){
            file.mkdirs();
        }
        return file.getAbsolutePath();
    }


    // 获取当前目录下所有的文件夹
    public static Vector getFolderName(String fileAbsolutePath) {
        Vector vecFile = new Vector();
        File file = new File(fileAbsolutePath);
        File[] subFile = file.listFiles();

        if (subFile == null) {
            return vecFile;
        }

        for (int iFileLength = 0; iFileLength < subFile.length; iFileLength++) {
            // 判断是否为文件夹
            if (subFile[iFileLength].isDirectory()) {
                String filename = subFile[iFileLength].getName();
                vecFile.add(filename);
            }
        }
        return vecFile;
    }

    // 获取当前目录下所有的mp3文件
    public static Vector getVoiceFileName(String fileAbsolutePath) {
        Vector vecFile = new Vector();
        File file = new File(fileAbsolutePath);
        File[] subFile = file.listFiles();

        for (int iFileLength = 0; iFileLength < subFile.length; iFileLength++) {
            // 判断是否为文件夹
            if (!subFile[iFileLength].isDirectory()) {
                String filename = subFile[iFileLength].getName();
                // 判断是否为MP3结尾
                if (filename.trim().toLowerCase().endsWith(".mp3")
                        || filename.trim().toLowerCase().endsWith(".wma")
                        || filename.trim().toLowerCase().endsWith(".arm")
                        || filename.trim().toLowerCase().endsWith(".m4a")
                        || filename.trim().toLowerCase().endsWith(".wav")
                        // QQ的，需要特殊处理
                        || filename.trim().toLowerCase().endsWith(".slk")
                        || filename.trim().toLowerCase().endsWith(".amr")
                        // 我自己的
                        || filename.trim().toLowerCase().endsWith(".mvod")) {
                    vecFile.add(filename);
                }
            }
        }
        return vecFile;
    }

    // 遍历所有的mp3文件
    public static Vector getAllVoiceFileName(String strPath) {
        Vector voiceList = new Vector();

        String filename;//文件名
        String suf;//文件后缀
        File dir = new File(strPath);//文件夹dir
        File[] files = dir.listFiles();//文件夹下的所有文件或文件夹

        if (files == null) {
            return voiceList;
        }

        for (int i = 0; i < files.length; i++) {
            if (files[i].isDirectory()) {
                voiceList.addAll(getAllVoiceFileName(files[i].getAbsolutePath())); // 递归文件夹！！！
            } else {
                filename = files[i].getName();
                int j = filename.lastIndexOf(".");
                suf = filename.substring(j + 1);//得到文件后缀

                // 判断是否为MP3结尾
                if (suf.equalsIgnoreCase("slk")
                        || suf.equalsIgnoreCase("amr")) {
                    String strFileName = files[i].getAbsolutePath().toLowerCase();
                    voiceList.add(files[i].getAbsolutePath()); // 对于文件才把它的路径加到filelist中
                }
            }
        }
        return voiceList;
    }

    // 获取文件创建时间
    public static long getFileTime(String filePath) {
        File f = new File(filePath);
        if (f.exists()) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(f);
                // 文件文件创建时间
//                String time = new SimpleDateFormat("yyyy-MM-dd")
//                        .format(new Date(f.lastModified()));
                return f.lastModified();
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        return 0;
    }

    // 通过路径获取文件名，带后缀
    public static String getFileNameHandExtension(String pathHandName) {
        if (!isFileExists(pathHandName)) {
            return "未知路径";
        }
        int start = pathHandName.lastIndexOf("/");
//        int end = pathHandName.lastIndexOf(".");
        int end = pathHandName.length();
        if (start != -1 && end != -1) {
            return pathHandName.substring(start + 1, end);
        } else {
            return "未知文件";
        }
    }

    // android获取文件及后缀名    不带.
    public static String[] getFileName(String fileName) {
        int dot = fileName.lastIndexOf(".");
        String str1 = fileName.substring(0, dot);
        String str2 = fileName.substring(dot + 1, fileName.length());
        String[] name = {str1, str2};
        return name;
    }

    /**
     * 通过URL 截取文件名 HTTP：www.www/adf/adf.apk  or  file:root/user/name/a.apk
     * @param url
     * @return
     */
    public static String getFileNameUrl(String url){
        if (TextUtils.isEmpty(url)){
            return "ad";
        }
        url = url.substring(url.lastIndexOf('/')+1);
        url = url.substring(0,url.indexOf("."));
        return url;
    }

    /**
     * @param filePath      原始文件路径
     * @param newName       新名称（有后缀）
     * @param admitCopyName 当命名冲突时，是否允许生成副本名（如果是多选重命名的话，是需要允许的；单个文件重命名则设置为不允许）
     * @return 是否修改成功
     * @Description 对文件进行重新命名
     */
    public static boolean fileRename(String filePath, String newName, boolean admitCopyName) {
        //1.判断参数阈值
        if (!isFileExists(filePath) || newName == null || newName.isEmpty()) {
            return false;
        }
        //2.得到原文件全路径
        String oldPath = filePath;
        //3-1.得到文件所在路径
        String rootPath = getPathFromFilepath(oldPath); //得到文件所在路径（即全路径去掉完整文件名）
        //3-2.得到新全路径
        String newPath = makePath(rootPath, newName); //根据根路径和文件名形成新的完整路径
        //4.比较是否变更了名称
        if (oldPath.endsWith(newPath)) { //和原来名称一样，不需要改变
            return true;
        }

        //5.根据新路径得到File类型数据
        File newFile = new File(newPath);
        //6.判断是否已经存在同样名称的文件（即出现重名）
        if (isFileExists(newPath) && !admitCopyName) { //出现重命名且不允许生成副本名
            return false; //重命名失败
        }
        //7.循环判断直到生成可用的副本名
        while (newFile.exists()) {
            //重命名重名定义规范--Util.getCopyNameFromOriginal(String)-自定义方法：根据自定义规则生成原名称副本
            newPath = getCopyNameFromOriginal(newPath);
            newFile = new File(newPath);
        }
        //8.得到原文件File类型数据
        File file = new File(oldPath);
        //9.调用固有方法去重命名
        boolean ret = file.renameTo(newFile);
        /*if (ret) {
            //FIXME:这里通过更改形参来改变实参，是不好的写法，不建议这样写！
            fileInfo.setFileName(getNameFromFilepath(newPath)); //更新文件名
            fileInfo.setmFilePath(newPath); //更新新路径
        }*/
        return ret;
    }

    /**
     * @param originalName 原本的名字，XXX.xx 或者完整路径 xx/xx/XXX.xx ， 也可以没有后缀.xx
     * @return 副本名称
     * @Description 得到文件副本名称，可供粘贴及多选重命名方法使用
     * 命名规则为：普通文件后加“ 1”，若文件末尾已有“ 数字”，则数字递增。
     * 比如，有个文件叫“我.jpg”，使用本方法后得到了“我 1.jpg”，再次使用本方法后得到“我 2.jpg”
     */
    public static String getCopyNameFromOriginal(final String originalName) {
        //1.判断阈值
        if (originalName == null || originalName.isEmpty()) {
            return null;
        }
        String copyName = null;
        //2.得到文件名和后缀名
        String[] nameAndExt = getFileName(getFileNameHandExtension(originalName));
        if (nameAndExt == null) {
            return null;
        }
        String fileName = nameAndExt[0];
        String fileExt = nameAndExt[1];
        //3.判断文件名是否包含我们定义副本规范的标记字符（空格）  原来是空格，我改为_下划线
//        String mark = " ";  // 原来是空格，我改为_下划线
        String mark = "_";  // 原来是空格，我改为_下划线
        if (fileName.contains(mark)) { //如果文件名包涵空格，进行判断是否已经为副本名称
            //4-1.得到end
            String[] array = fileName.split(mark);
            String end = array[array.length - 1]; //得到标记字符后面的值
            //4-2.确保end得到的是最后面的值（防止出现类似路径中的目录也有标记字符的情况，如："mnt/sda/wo de/zhao pian/我的 照片 1.png"）
            while (end.contains(mark)) {
                array = fileName.split(mark);
                end = array[array.length - 1];
            }
            //5.判断标记字符后的字符串是否复合规范（是否是数字）
            boolean isDigit = end.matches("[0-9]+"); //用正则表达式判断是否是正整数
            if (isDigit) {
                try {
                    int index = Integer.parseInt(end) + 1; //递增副本记数
                    int position = fileName.lastIndexOf(mark); //得到最后的空格的位置，用于截取前面的字符串
                    if (position != -1) {
                        //6-1.构造新的副本名（数字递增）
                        copyName = fileName.substring(0, position + 1) + String.valueOf(index);
                    }
                } catch (Exception e) { //转化成整形错误
                    e.printStackTrace();
                    return null;
                }
            } else { //如果空格后不是纯数字，即不为我们定义副本的规范
                //6-2.构造新的副本名（数字初始为1）
                copyName = fileName + mark + "1";
            }
        } else { //如果没有，则变为副本名称格式
            //6-3.构造新的副本名（数字初始为1）
            copyName = fileName + mark + "1";
        }
        //6.返回副本名+后缀名
        String newName = getPathFromFilepath(originalName) + "/" + copyName + "." + fileExt;
        return newName;
    }

    /**
     * @param filepath 文件全路径名称，like mnt/sda/XX.xx
     * @return 根路径，like mnt/sda
     * @Description 得到文件所在路径（即全路径去掉完整文件名）
     */
    public static String getPathFromFilepath(final String filepath) {
        int pos = filepath.lastIndexOf('/');
        if (pos != -1) {
            return filepath.substring(0, pos);
        }
        return "";
    }

    /**
     * @param path1 路径一
     * @param path2 路径二
     * @return 新路径
     * @Description 重新整合路径，将路径一和路径二通过'/'连接起来得到新路径
     */
    public static String makePath(final String path1, final String path2) {
        // 用"/"或File.separator ， 原来用的File.separator，可能一样
        if (path1.endsWith("/")) {
            return path1 + path2;
        }
        return path1 + "/" + path2;
    }

    // 看文件是否存在
    public static boolean isFileExists(String path) {
        try {
            File f = new File(path);
            if (!f.exists()) {
                return false;
            }
        } catch (Exception e) {
            // TODO: handle exception
            return false;
        }
        return true;
    }

    // 创建文件夹
    public static void mkdirPath(String path) {
        //获取内部存储状态
        String state = Environment.getExternalStorageState();
        //如果状态不是mounted，无法读写
        if (!state.equals(Environment.MEDIA_MOUNTED)) {
            return;
        }

        File dir = new File(path);
        if (!dir.exists()) {
            dir.mkdirs();
        }
    }

    // 修改文件及文件夹名
    public static void filesRename(String oldPath, String newPath) {
//        new File("f:/a/a.xlsx").renameTo(new File("f:/a/b.xlsx"));
        //将原文件夹更改为A，其中路径是必要的。注意
        new File(oldPath).renameTo(new File(newPath));
    }

    // 保存图片到本地
    public static void savePic(String path, String fileName, Bitmap bitmap) {
        try {
            File dir = new File(path);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            File file = new File(path, fileName);
            FileOutputStream out = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 保存分享图片到本地+\
     */
    public static void saveSharePic(Context context, String appPath, String fileName) {
        //获取内部存储状态
        String state = Environment.getExternalStorageState();
        //如果状态不是mounted，无法读写
        if (!state.equals(Environment.MEDIA_MOUNTED)) {
            return;
        }

        try {
            File dir = new File(appPath);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            File file = new File(appPath, fileName);
            FileOutputStream out = new FileOutputStream(file);
            // 在这里改分享的图片哦
            Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.bg_audio_name);
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除文件，可以是文件或文件夹
     *
     * @param fileName 要删除的文件名
     * @return 删除成功返回true，否则返回false
     */
    public static boolean delete(String fileName) {
        File file = new File(fileName);
        if (!file.exists()) {
//            System.out.println("删除文件失败:" + fileName + "不存在！");
            return false;
        } else {
            if (file.isFile())
                return deleteFile(fileName);
            else
                return deleteDirectory(fileName);
        }
    }

    /**
     * 删除单个文件
     *
     * @param fileName 要删除的文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
//                System.out.println("删除单个文件" + fileName + "成功！");
                return true;
            } else {
//                System.out.println("删除单个文件" + fileName + "失败！");
                return false;
            }
        } else {
//            System.out.println("删除单个文件失败：" + fileName + "不存在！");
            return false;
        }
    }

    /**
     * 删除目录及目录下的文件
     *
     * @param dir 要删除的目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(String dir) {
        // 如果dir不以文件分隔符结尾，自动添加文件分隔符
        if (!dir.endsWith(File.separator))
            dir = dir + File.separator;
        File dirFile = new File(dir);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if ((!dirFile.exists()) || (!dirFile.isDirectory())) {
//            System.out.println("删除目录失败：" + dir + "不存在！");
            return false;
        }
        boolean flag = true;
        // 删除文件夹中的所有文件包括子目录
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            // 删除子文件
            if (files[i].isFile()) {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
            // 删除子目录
            else if (files[i].isDirectory()) {
                flag = deleteDirectory(files[i]
                        .getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag) {
//            System.out.println("删除目录失败！");
            return false;
        }
        // 删除当前目录
        if (dirFile.delete()) {
//            System.out.println("删除目录" + dir + "成功！");
            return true;
        } else {
            return false;
        }

    }

    /**
     * 删除指定目录下文件及目录
     *
     * @param deleteThisPath
     * @param
     * @return
     */
    public static void deleteFolderFile(String filePath, boolean deleteThisPath) {
        if (!TextUtils.isEmpty(filePath)) {
            try {
                File file = new File(filePath);
                if (file.isDirectory()) {// 处理目录
                    File files[] = file.listFiles();
                    for (int i = 0; i < files.length; i++) {
                        if (files[i].getAbsolutePath().contains(".pcm") || files[i].getAbsolutePath().contains(".wav")) {
                            deleteFolderFile(files[i].getAbsolutePath(), true);
                        }
                    }
                }
                if (deleteThisPath) {
                    if (!file.isDirectory()) {// 如果是文件，删除
                        file.delete();
                    } else {// 目录
                        if (file.listFiles().length == 0) {// 目录下没有文件或者目录，删除
                            file.delete();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 复制单个文件
     *
     * @param oldPath String 原文件路径 如：c:/fqf.txt
     * @param newPath String 复制后路径 如：f:/fqf.txt
     * @return boolean
     */
    public static void copyFile(String oldPath, String newPath) {
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPath);
            if (oldfile.exists()) { //文件存在时  可能是说文件夹
                InputStream inStream = new FileInputStream(oldPath); //读入原文件
                FileOutputStream fs = new FileOutputStream(newPath);
                byte[] buffer = new byte[1444];
                int length;
                while ((byteread = inStream.read(buffer)) != -1) {
                    bytesum += byteread; //字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        } catch (Exception e) {
//            System.out.println("复制单个文件操作出错");
            e.printStackTrace();

        }finally {

        }

    }

    /**
     * 复制整个文件夹内容
     *
     * @param oldPath String 原文件路径 如：c:/fqf
     * @param newPath String 复制后路径 如：f:/fqf/ff
     * @return boolean
     */
    public static void copyFolder(String oldPath, String newPath) {

        try {
            (new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹
            File a = new File(oldPath);
            String[] file = a.list();
            File temp = null;
            for (int i = 0; i < file.length; i++) {
                if (oldPath.endsWith(File.separator)) {
                    temp = new File(oldPath + file[i]);
                } else {
                    temp = new File(oldPath + File.separator + file[i]);
                }

                if (temp.isFile()) {
                    FileInputStream input = new FileInputStream(temp);
                    FileOutputStream output = new FileOutputStream(newPath + "/" +
                            (temp.getName()).toString());
                    byte[] b = new byte[1024 * 5];
                    int len;
                    while ((len = input.read(b)) != -1) {
                        output.write(b, 0, len);
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if (temp.isDirectory()) {//如果是子文件夹
                    copyFolder(oldPath + "/" + file[i], newPath + "/" + file[i]);
                }
            }
        } catch (Exception e) {
//            System.out.println("复制整个文件夹内容操作出错");
            e.printStackTrace();

        }

    }

    /**
     * 获取文件大小
     *
     * @param file
     * @return
     */
    public static long getFolderSize(File file) {
        long size = 0;
        try {
            File[] fileList = file.listFiles();
            for (int i = 0; i < fileList.length; i++) {
                if (fileList[i].isDirectory()) {
                    size = size + getFolderSize(fileList[i]);

                } else {
                    size = size + fileList[i].length();
                }
            }
        } catch (Exception e) {

            e.printStackTrace();
        }
        return size; // return size/1048576;
    }

    /**
     * 格式化单位
     *
     * @param size
     * @return
     */
    public static String getFormatSize(double size) {
        double kiloByte = size / 1024;
        if (kiloByte < 1) {
            return size + "B";
        }

        double megaByte = kiloByte / 1024;
        if (megaByte < 1) {
            BigDecimal result1 = new BigDecimal(Double.toString(kiloByte));
            return result1.setScale(2, BigDecimal.ROUND_HALF_UP)
                    .toPlainString() + "K";
        }

        double gigaByte = megaByte / 1024;
        if (gigaByte < 1) {
            BigDecimal result2 = new BigDecimal(Double.toString(megaByte));
            return result2.setScale(2, BigDecimal.ROUND_HALF_UP)
                    .toPlainString() + "M";
        }

        double teraBytes = gigaByte / 1024;
        if (teraBytes < 1) {
            BigDecimal result3 = new BigDecimal(Double.toString(gigaByte));
            return result3.setScale(2, BigDecimal.ROUND_HALF_UP)
                    .toPlainString() + "G";
        }
        BigDecimal result4 = new BigDecimal(teraBytes);
        return result4.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString()
                + "T";
    }

    /**
     * 以高斯模糊显示。
     *
     * @param draweeView View。
     * @param url        url.
     * @param iterations 迭代次数，越大越模糊。
     * @param blurRadius 模糊图半径，必须大于0，越大越模糊。
     */
    public static void showUrlBlur(SimpleDraweeView draweeView, String url, int iterations,
                                   int blurRadius) {
        try {
            Uri uri = Uri.parse(url);
            ImageRequest request = ImageRequestBuilder.newBuilderWithSource(uri)
                    .setPostprocessor(new IterativeBoxBlurPostProcessor(iterations, blurRadius))
                    .build();
            AbstractDraweeController controller = Fresco.newDraweeControllerBuilder()
                    .setOldController(draweeView.getController())
                    .setImageRequest(request)
                    .build();
            draweeView.setController(controller);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取本机所有的视频文件
     * @return
     */

    public static List getVideoData(ContentResolver contentResolver) {



        List videos = new ArrayList<>();
        String[] thumbColumns = {MediaStore.Video.Thumbnails.DATA,
                MediaStore.Video.Thumbnails.VIDEO_ID};
        Cursor cursor = null;
        try {
            cursor = contentResolver.query(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, null, null, null, MediaStore.Video.Media.DEFAULT_SORT_ORDER);
            while (cursor.moveToNext()) {
                String path = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATA));// 路径
                if (!FileUtils.isExists(path)) {
                    continue;
                }

                int id = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID));// 视频的id
                String name = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME)); // 视频名称
                String resolution = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.RESOLUTION)); //分辨率
                String width = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.WIDTH)); //宽
                String height = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.HEIGHT)); //高
//                if (width == null){
//                    width = "480";
//                }
//                if (height == null){
//                    height = "320";
//                }
                long size = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE));// 大小
                long duration = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION));// 时长
                long date = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATE_MODIFIED));//修改时间

                String thumb = "";

                Cursor thumbCursor = contentResolver.query(
                        MediaStore.Video.Thumbnails.EXTERNAL_CONTENT_URI,
                        thumbColumns, MediaStore.Video.Thumbnails.VIDEO_ID
                                + "=" + id, null, null);
                if (thumbCursor.moveToFirst()) {
                    thumb = thumbCursor.getString(thumbCursor
                            .getColumnIndex(MediaStore.Video.Thumbnails.DATA));
                }

//                MediaMetadataRetriever retriever = new MediaMetadataRetriever();
//                retriever.setDataSource(path);
//
//                Bitmap bmp = retriever.getFrameAtTime(0, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);
//
//                // 首先保存图片
//                File appDir = new File(Constants.CALL_PICTURE_FILE_PATH);
//
//                if (!appDir.exists()) {
//                    appDir.mkdir();
//                }
//                String fileName = name + ".png";
//                File file = new File(appDir, fileName);
//                try {
//                    FileOutputStream fos = new FileOutputStream(file);
//                    bmp.compress(Bitmap.CompressFormat.JPEG, 100, fos);
//                    fos.flush();
//                    fos.close();
//
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//
//                //获取视频封面图的路径
//                String corver=file.getAbsolutePath();
//
//                Log.e("视频封面图"+corver);

                LocalVideoBean video = new LocalVideoBean(id, path, name, resolution,width,height,size, date, duration,thumb);
                videos.add(video);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
        return videos;
    }

    /**
     * 判断文件是否存在
     * @param path 文件的路径
     * @return
     */
    public static boolean isExists(String path) {
        File file = new File(path);
        return file.exists();
    }

    /**
     * 获取视频缩略图
     */
    private static Bitmap getVideoThumbnail(int id,ContentResolver contentResolver) {
        Bitmap bitmap = null;
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inDither = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        bitmap = MediaStore.Video.Thumbnails.getThumbnail(contentResolver, id, MediaStore.Images.Thumbnails.MICRO_KIND, options);
        return bitmap;
    }


    /**
     * 删除文件
     *
     * @param fileName 文件路径
     */
    public static void delFile(String fileName) {
        File file = new File(fileName);
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
//                System.out.println("删除成功>"+fileName);
                android.util.Log.i("zhouke","删除成功>>"+fileName);
            }
        }
    }

    //将List按照时间倒序排列
    @SuppressLint("SimpleDateFormat")
    public static List invertOrderList(List videoBean){
        long d1;
        long d2;
        LocalVideoBean video;
        //做一个冒泡排序，大的在数组的前列
        for(int i=0; i