Android videoview实现视频下载缓存播放前的思考

 

        最近在处理一个业务需求，其实也是视频播放普遍存在的一个问题，我们总不可能无休止去url不断去开请求下载一个视频资源的，顺便把这个实现的过程思路和一下问题记录下来，方便以后自己学习改进，我这是需求不是做一个完整视频播放器（不集现成网络下的缓存开源库实现）。而是Android 里面的常用控件videoview， 一个Fragment 页面应用VideoView用全屏居中展示播放出来，效果如下图：

 

           第一步：这个布局xml的代码：

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".testDemo.Fragment_one">

    <!-- TODO: Update blank fragment layout -->
    <VideoView
        android:id="@+id/video_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_gravity="center"/>


</FrameLayout>

 

        有了布局，我们就可以方便实现接下来的功能了，回到问题上，我们的要做的目的是什么，不就是app 里面在我上面的页面去播放我想要播放的视频资源嘛，我们随便开个线程，引用okhttp的下载文件，然后播放出来不就得咧，的确是！

        第二步，我这边用到的是一个网上流行的okhttp下载文件工具类（DownloadUtil ）：

package 填写属于你自己的项目包名;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

/**
 * 文件下载工具类（单例模式）
 */

public class DownloadUtil {

    private static DownloadUtil downloadUtil;
    private final OkHttpClient okHttpClient;

    public static DownloadUtil get() {
        if (downloadUtil == null) {
            downloadUtil = new DownloadUtil();
        }
        return downloadUtil;
    }

    public DownloadUtil() {
        okHttpClient = new OkHttpClient();
    }


    /**
     * @param url          下载连接
     * @param destFileDir  下载的文件储存目录
     * @param destFileName 下载文件名称，后面记得拼接后缀，否则手机没法识别文件类型
     * @param listener     下载监听
     */

    public void download(final String url, final String destFileDir, final String destFileName, final OnDownloadListener listener) {

        Request request = new Request.Builder()
                .url(url)
                .build();

        OkHttpClient client = new OkHttpClient();

        try {
            Response response = client.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //异步请求
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                // 下载失败监听回调
                listener.onDownloadFailed(e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

                InputStream is = null;
                byte[] buf = new byte[2048];
                int len = 0;
                FileOutputStream fos = null;

                //储存下载文件的目录
                File dir = new File(destFileDir);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                File file = new File(dir, destFileName);

                try {

                    is = response.body().byteStream();
                    long total = response.body().contentLength();
                    fos = new FileOutputStream(file);
                    long sum = 0;
                    while ((len = is.read(buf)) != -1) {
                        fos.write(buf, 0, len);
                        sum += len;
                        int progress = (int) (sum * 1.0f / total * 100);
                        //下载中更新进度条
                        listener.onDownloading(progress);
                    }
                    fos.flush();
                    //下载完成
                    listener.onDownloadSuccess(file);
                } catch (Exception e) {
                    listener.onDownloadFailed(e);
                }finally {

                    try {
                        if (is != null) {
                            is.close();
                        }
                        if (fos != null) {
                            fos.close();
                        }
                    } catch (IOException e) {

                    }

                }


            }
        });
    }


    public interface OnDownloadListener{

        /**
         * 下载成功之后的文件
         */
        void onDownloadSuccess(File file);

        /**
         * 下载进度
         */
        void onDownloading(int progress);

        /**
         * 下载异常信息
         */

        void onDownloadFailed(Exception e);
    }
}

 

       我们看看他的调用 是download（）方法，里面传递的参数，可以看代码。当然我们在调用这个方法的时候，不能直接调用，而是放到子线程去调用，至于为什么？应该是每个安卓开发者都要注意的线程使用问题，自己度娘吧。我这边是new Thread ()的方式去开启下载的： 

            new Thread(new Runnable() {
                            @Override
                            public void run() {
                            //uri2：下载链接 namepath: 自己保持的路径 filename：文件名
                                downFile(uri2, namepath, filename);  
                            }
                        }).start();

    /*@
     * 文件下载 url：地址 filepateh： 存放文件路径  filename: 文件名字
     */
    private void downFile(String url, String filepath, String filename) {
        DownloadUtil.get().download(url, filepath, filename,
                new DownloadUtil.OnDownloadListener() {
                    @Override
                    public void onDownloadSuccess(File file) {
                        //下载成功
                        Log.i(TAG, "onDownloadSuccess:....... ..................文件下载成功..............................");
                    }

                    @Override
                    public void onDownloading(int progress) {
                        //下载中
                        Log.i(TAG, "onDownloading:..............................文件下载中................................");
                    }

                    @Override
                    public void onDownloadFailed(Exception e) {
                        //下载异常进行相关提示操作
                        Log.e(TAG, "onDownloadFailed:..........................下载文件失败...............................");
                    //文件下载失败之后的处理
                   
                    }
                });
    }

 

        这里简单说一下downFile()传递参数问题吧，传递链接直接丢进来就行了，自己保存视频文件的路径也是自己定好就行，文件名的这里就要注意了，由于接口返回来的，你也可以用后台返回来的文件名，但是这样后台文件名更改了，我接下来的方式会出现一些bug,无论如何，我都不采用后台返回的字段，而是采用自己的一个正则表达式来提取相应文件名：

 //保留文件名及后缀
    public String getFileNameWithSuffix(String pathandname) {
        int start = pathandname.lastIndexOf("/");
        if (start != -1) {
            return pathandname.substring(start + 1);
        } else {
            return null;
        }
    }

         举例子，我传个url 进去=http://zexbrb.natappfree.cc/video/2019/10/21/92e172e5-8e5b-42c0-bf1e-6163457fd45d.mp4

getFileNameWithSuffix（）提取到文件名及后缀是 92e172e5-8e5b-42c0-bf1e-6163457fd45d.mp4 ，这个名字就会用来保存在我自己的文件夹下面，这是我成功下载的文件，也是我最终想要的效果：

 

 

        第三步，我们把视频文件下载完成之后，接下来是找到自己定义好的文件夹保存的路径，去查询该文件夹下面的资源文件，是否跟后台接口返回的文件一样。我这边是这样做的，用了一个getFiles(final String namepath, final String filename, long cont_length, final String uri2)方法，这里 namepath :传入本地下文件路径，filename:传入的是文件名，cont_length:传入的是url的url视频文件的大小， uri2：传入的是后台接口返回的url 访问路径

    private void getFiles(final String namepath, final String filename, long cont_length, final String uri2) {
        File file = new File(namepath);
        File[] files = file.listFiles();
        for (int i = 0; i < files.length; i++) {
            File childFile = files[i];
            String childName = childFile.getName();
            String fileSizeString = formetFileSize(childFile);
            Log.e(TAG, "本地文件名getFiles: " + childName);

            long filesize = Long.parseLong(fileSizeString);
            Log.e(TAG, "服务器文件长度fileLength=" + cont_length);
            Log.e(TAG, "本地文件长度fileLength=" + filesize);
            //如果文件名相等，就开始验证
            if (childName.equals(filename)) {
                if (cont_length == filesize) {
                    Log.i(TAG, "getFiles: 文件的大小跟服务器的大小一样，完整无损");
                    Log.e(TAG, "getFiles: 文件的链接1==" + uri2);
                } else {
                    Log.e(TAG, "getFiles: 文件的大小跟服务器的大小不一样，破损丢失");
                    Log.e(TAG, "getFiles: 文件的链接2==" + uri2);

                    if (childFile != null || childFile.exists()) {
                        childFile.delete();
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                downFile(uri2, namepath, filename);
                            }
                        }).start();
                    }

                }
            } else {
                Log.i(TAG, "getFiles:文件名不相等 ");
            }
        }
    }

    //获取本地上视频文件名与后台接口返回视频文件名相同，方法返回该视频的文件大小
    public String formetFileSize(File file) {
        String fileSize = "0";
        if (file == null) {
            fileSize = "文件不存在";
            return fileSize;
        }
        long fileLength = file.length();
        DecimalFormat df = new DecimalFormat("#");
        fileSize = df.format((double) fileLength);

        return fileSize;
    }

        如果你调用上面的getFiles()方法，你会纳闷上面的cont_length是从哪里拿的，这里也可是后台接口定义的字段取，如果没有的话，你就要用我下面的套路了，就是一个http协议的headers 去取了，用的是下面的方法：（我这种方式是在postman 调试工具上的） Content-Length这里看到是 文件的字节大小 

package 你的项目包名;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Date;

public class Headers_jc {
    private URL u;
    private URLConnection uc;

    public int headers_info(String usl) {
        try {
            u = new URL(usl);
            uc = u.openConnection();
            System.out.println("Content-type: " + uc.getContentType());
            if (uc.getContentEncoding() != null) {
                System.out.println("Content-encoding: " + uc.getContentEncoding());
            }
            if (uc.getDate() != 0) {
                System.out.println("Date: " + new Date(uc.getDate()));
            }
            if (uc.getLastModified() != 0) {
                System.out.println("Last Modified: " + new Date(uc.getLastModified()));
            }
            if (uc.getExpiration() != 0) {
                System.out.println("Expiration Date: " + uc.getExpiration());
            }
            if (uc.getContentLength() != 0) {
                System.out.println("Content-length: " + uc.getContentLength());
            }
        } catch (
                MalformedURLException e) {
            // TODO: handle exception
            System.err.println(e);
        } catch (IOException ex) {
            // TODO: handle exception
            System.err.println(ex);
        }
        return uc.getContentLength();
    }


}

//检测文件已经存在时，对比他的文件大小情况
因为我在activity里面写的，直接写没问题，但是你要想再fragment里面这样new 就不行了，

  Headers_jc headers_jc = new Headers_jc();
  int content_length = headers_jc.headers_info(uri); 
  Log.i(TAG,"拿到的url的文件大小是"+content_length );

fragment页面使用，必须开个子线程：

new Thread(new Runnable() {
    @Override
    public void run() {
        Headers_jc headers_jc = new Headers_jc();
        int content_length = headers_jc.headers_info(content);
      Log.i(TAG,"拿到的url的文件大小是"+content_length );
    }
}).start();

        上面是我自己踩到的问题，及解决方式。如果仅仅靠这个方法去url 的文件大小就会出现一个bug,当这个链接不能访问的时候，他也可以取出 Content-Length 值 为 38 

 

        那这值直接用上面的那些方法就比较判断来调用downFiles（）下载的话就会破坏了我们原本保存视频文件完整性了，也不能说上面做了这么多就没有用，我在按思路一步步写好之后，我们必须确保url为正常访问的前提下， 具体调用可以参考我下面的方法：

 //增加对视频url的请求状态验证
                        OkHttpClient okHttpClient_url = new OkHttpClient.Builder()
                                .connectTimeout(10 * 60 * 1000, TimeUnit.MILLISECONDS)
                                .readTimeout(10 * 60 * 1000, TimeUnit.MILLISECONDS)
                                .writeTimeout(10 * 60 * 1000, TimeUnit.MILLISECONDS)
                                .build();

                        Request request_url = new Request.Builder().url(uri).get().build(); //uri：把后台接口的访问链接传递进来判断
                        okHttpClient_url.newCall(request_url).enqueue(new Callback() {
                            @Override
                            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                                Log.i(TAG, "onFailure:视频链接状态失败 ");
                            }

                            @Override
                            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                                Log.i(TAG, "onResponse: 视频链接状态成功 ");
                                int url_code = response.code();
                                Log.i(TAG, "onResponse: 视频链接成功内容 " + url_code);
                               // 状态码判断！！！！
                                if (url_code != 404 && url_code == 200) {
                                    final String url_names = getFileNameWithSuffix(uri);
                                    //具体文件路径引用
                                    if (isSDCardMounted()) {
                                        rootfilepath = Environment.getExternalStorageDirectory().getPath() + UitlData.MEADIA_VIDEO;
                                    } else {
                                        rootfilepath = Environment.getDataDirectory().getPath() + UitlData.MEADIA_VIDEO;
                                    }
                                    List<String> videpath = GetVideoFileName(rootfilepath);
                                    boolean list_filecount = videpath.contains(url_names);
                                    if (!videpath.isEmpty() && list_filecount) {
                                        Log.i(TAG, "init_test_json: 本地视频文件不为空/已存在，不下载");
                                        //检测文件已经存在时，对比他的文件大小情况
                                        Headers_jc headers_jc = new Headers_jc();
                                        int content_length = headers_jc.headers_info(uri);
                                        //开始验证
                                        getFiles(rootfilepath, url_names, content_length, uri);

                                    } else {
                                        Log.i(TAG, "init_test_json: 本地视频文件为空/不存在，开启下载。。。。");
                                        new Thread(new Runnable() {
                                            @Override
                                            public void run() {
                                                downFile(uri, rootfilepath, url_names);
                                            }
                                        }).start();
                                    }
                                } else {
                                    Log.i(TAG, "onResponse: get 请求失败");
                                }
                            }
                        });

          上面用到方法都是在activity 做的逻辑判断处理，至于我为什么这样做，是我在activity+多fragment布局应用，核心代码和思想是在加载指定fragment页面前，先去获取url下载，接着去处理下载相应的资源文件，判断本地已存在的资源完整性，确保videoview控件 去加载文件播放是完整无损的状态，最后在fragment页面中的videoview控件引用之前判断一下，在本地的文件状态是还在下载中或者下载错误丢失，不完整的情况下我们最好用一个默认的视频播放，当下次进这个fragment页面时，去加载缓存好的视频就可以避免播放错误。

          实现上面的功能后，我们可以简单做个视频缓存和页面展示播放了，还有一个问题就是，我们不可能源源不断下载文件保存在自己的手机上，我们还与考虑机身的实际容量，所有要去设定他的文件大小，超过后就要去删掉，再去下载。

        我这边有两种方式删除，第一种如下，原理是根据我传进去的指定文件夹，获取该文件夹下面的文件数，如果超过了15个文件（自己定义的），我这边就会掉用方法去把改文件夹的文件全部清空，并且删除它的目录文件夹，重启程序。（注：我这里的确可以实现清空缓存问题，但是这样会把所有文件都清空，我这边想留下最后缓存的文件，来来播放就要重新去下载回来，造成不必要的操作，然后就是，方式二改进了这个问题）

   if (isSDCardMounted()) {
                                    rootfilepath = Environment.getExternalStorageDirectory().getPath() + UitlData.MEADIA_VIDEO;
                                } else {
                                    rootfilepath = Environment.getDataDirectory().getPath() + UitlData.MEADIA_VIDEO;
                                }
                                List<String> videpath2 = GetVideoFileName(rootfilepath);
                                Log.i(TAG, "onResponse: 数据不相同 当前下文件数" + videpath2);
                                if (videpath2.size() >= 15) {
                                    Log.i(TAG, "onResponse: 数据不相同 当前下文件数大于等于15个清空文件夹");
                                    deleteDir(UitlData.MEADIA_VIDEO);
                                }
                                Log.i(TAG, "onResponse: 数据不相同 当前下文件数小15个不清空文件夹");

 

/**
     * 删除文件夹
     *
     * @param path
     */
    public static void deleteDir(String path) {
        File dir = new File(path);
        deleteDirWihtFile(dir);
    }

    //删除文件及文件夹
    public static void deleteDirWihtFile(File dir) {
        if (dir == null || !dir.exists() || !dir.isDirectory())
            return;
        for (File file : dir.listFiles()) {
            if (file.isFile())
                file.delete(); // 删除所有文件
            else if (file.isDirectory())
                deleteDirWihtFile(file); // 递规的方式删除文件夹
        }
        dir.delete();// 删除目录本身
    }

      方式二，原理是一样，根据我传进去的指定文件夹，获取该文件夹下面的文件数，如果超过了15个文件（自己定义的）：就保留最后一个最新的文件（这里主要是用了文件按时间排序来处理），删除其余的旧文件，重启程序，方便videoview的播放。

文件按时间排序返回的处理方式如下+下面的代码配合使用: 

   https://blog.csdn.net/qq_36771930/article/details/103048738 

//这段代码是将排序后的文件夹顺序，旧到新，我这边拿最新的文件名来判断删除，其他旧文件。
String lastmax = list_delete.get(list_delete.size() - 1).getName();
Log.i("ZMS==", lastmax);

 

    /**
     * 删除文件夹排序
     */
    private static void deleteff(String paths, String filename) {
        File dirs = new File(paths);

        if (dirs == null || !dirs.exists() || !dirs.isDirectory())
            return;
        for (File file : dirs.listFiles()) {
            System.gc();
            if (file.isFile()) {
                if (!(file.getName().equals(filename))) {
                    System.out.println("文件排序=" + file.getName());
                    file.delete(); // 删除所有文件
                } else {
                    System.out.println("文件排序名字相等");
                }

            }

        }
    }

下面记录一下，自己的开发常用工具类或者方法的使用：

1.Android 创建指定文件夹路径

文件清单添加权限：

<uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" /> <!-- 文件权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

   
    public static String FILEPATH ="/Medx";
    //视频文件夹

    public static String MEADIA_VIDEO = FILEPATH + "/Video";
    //图片文件夹
    public static String MEADIA_IMAGE = FILEPATH + "/Image";

 private void init_rootfile() {
        if (isSDCardMounted()) {
            //sd卡下
            String  filepaths=Environment.getExternalStorageDirectory().getPath() + UitlData.MEADIA_VIDEO;
            makeRootDirectory(filepaths);
            Log.i(TAG, "12345;" + filepaths);

        } else {
            //   makeRootDirectory(UitlData.MEADIA_IMAGE);
            String  filepaths2=Environment.getDataDirectory().getPath() + UitlData.MEADIA_VIDEO;
            makeRootDirectory(filepaths2);
            Log.i(TAG, "123456" + filepaths2);
        }
    }

    public static void makeRootDirectory(String filePath) {
        try {
            File file = new File(filePath);
            if (!file.exists()) {
                file.mkdirs();
            } else {
            }
        } catch (Exception e) {
            Log.i(TAG,"文件夹创建失败"+e.getMessage());
        }
    }
    /**
     * sd卡是否安装
     */
    public static boolean isSDCardMounted() {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }

----------2020/7/ 24------上面方式一改良--------- 有网络很好的情况下-------------------

改良后下载缓存的方式：

1上面的方式在拿到视频下载链接之后开始：

  Log.i(TAG, "init_test_json:type=2,本地视频文件不存在，开启下载。。。。");
  new Thread(new VoidThread_Down(uri,url_names)).start();

 //开启视频线程下载
    private class VoidThread_Down implements Runnable {
        String thread_uri, thread_url_names;

        public VoidThread_Down(String thread_uri, String thread_url_names) {
            this.thread_uri = thread_uri;
            this.thread_url_names = thread_url_names;
        }

        @Override
        public void run() {
            Log.i(TAG, "VoidThread_Down链接=" + thread_uri);
            Log.i(TAG, "VoidThread_Down路径=" + rootFilepath());
            Log.i(TAG, "VoidThread_Down文件名=" + thread_url_names);
            downFile(thread_uri, rootFilepath(), thread_url_names);
        }
    }

      2.这是第一下载，有些某些原因，可能导致第一次下载文件存在破损的情况，导致视频不能播放，我们再做第二次视频文件的完整性判断：

  Log.i(TAG, "init_test_json:type=2,本地视频文件已存在，不下载");
  Headers_jc headers_jc = new Headers_jc();   //检测文件已经存在时，对比他的文件大小情况
  int content_length = headers_jc.headers_info(uri);
  getFilesvideo(url_names, content_length, uri);   //开始验证

 

 /**
     * 获取本地文件和服务器接口url返回的文件
     * 进行长度比较
     */
    private void getFilesvideo(final String filename, long cont_length, final String uri2) {
        File file = new File(rootFilepath());
        File[] files = file.listFiles();
        int videofile = getIndex(files, filename);
        Log.i(TAG, "getFilesvideo: videofile数组下标=" + videofile);

        if (videofile != -1) {
            Log.i(TAG, "getFilesvideo:文件名相等 ");
            String childName = files[videofile].getName();
            String fileSizeString = formetFileSize(files[videofile]);
            long filesize = Long.parseLong(fileSizeString);
            Log.e(TAG, "getFilesvideo：本地文件名=" + childName);
            //如果文件破损
            if (cont_length != filesize) {
                Log.i(TAG, "getFilesvideo: 文件的大小跟服务器的大小不一样，破损丢失");
                if (files[videofile] != null && files[videofile].exists()) {
                    files[videofile].delete();
                    new Thread(new VoidThread_Down(uri2, filename)).start();
                }
            } else {
                Log.i(TAG, "getFilesvideo: 文件的大小跟服务器的大小一样，完整无损");
            }

        } else {
            Log.i(TAG, "getFilesvideo:文件不存在 ");
            Log.i(TAG, "getFilesvideo:链接 " + uri2);
            Log.i(TAG, "getFilesvideo:路径 " + rootFilepath());
            Log.i(TAG, "getFilesvideo:名称 " + filename);
            new Thread(new VoidThread_Down(uri2, filename)).start();
        }

    }

    这里面多做了一个文件位置存放的方式：

/**
     * sd卡是否安装
     */
    public static boolean isSDCardMounted() {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }

    public static String rootFilepath() {
        String rootfile;
        if (isSDCardMounted()) {
            rootfile = Environment.getExternalStorageDirectory().getPath() + UitlData.MEADIA_VIDEO;
        } else {
            rootfile = Environment.getDataDirectory().getPath() + UitlData.MEADIA_VIDEO;
        }
        return rootfile;
    }

这里开一个线程去定时去检测本地存在的视频文件是破损：

 private VerifgVideoRunnable verifgVideoRunnable;




  private void VerifgVideoTime() {
        if (verifgVideoRunnable == null) {
            verifgVideoRunnable = new VerifgVideoRunnable();
            handler.postDelayed(verifgVideoRunnable, 0);

        }
    }

    //3.视频本地资源验证
    private class VerifgVideoRunnable implements Runnable {
        @Override
        public void run() {
            Log.i("video请求时间=", "15分钟");
            init_handerNum(9);
            handler.postDelayed(this, 15 * 60 * 1000);
        }
    }

@Override
    protected void onDestroy() {
        super.onDestroy();
        onclicknum = 0;
        handler.removeCallbacks(verifgVideoRunnable);
        verifgVideoRunnable = null;
        apkRunnable = null;
        handler.removeCallbacksAndMessages(null);
    }

最后在oncreate（）调用

  VerifgVideoTime(); //视频文件完整性验证

-------2020/7/ 27----8/5   --记录不依赖网络的情况下使用MediaMetadataRetriever（在Android4.4.2版本会出现无法解决的bug）----------不建议使用---------

1.MediaMetadataRetriever是什么？

官网看不了，可以看看这位大佬的文章：https://blog.csdn.net/alpgao/article/details/88995410，会发现，其实这个类压根没有文件破损的方法，这种方式是为了解决，有时候网络不好的情况下，去请求视频url，会有超时的情况下，体验不好，容易出现各种bug，起初用到该方法的是在，网上找的，拿下来简单测试了一下，就以为可以用了，但是徒劳，Android4.4.2版本上面导致我的页面白屏加载不出来，也找不到原因所在，就放弃了这种方式。

    /**
     * 获取本地文件和服务器接口url返回的文件
     * 破损分析
     * @param filename 视频文件名
     * @param uri2     视频链接
     */
    private void getFiles_videos(final String filename, final String uri2) {
        File file = new File(rootFilepath());
        File[] files = file.listFiles();
        int videofile = getIndex(files, filename);
        Log.i(TAG, "getFiles_videos: videofile数组下标=" + videofile);

        if (videofile != -1) {
            Log.i(TAG, "getFiles_videos:文件名相等 ");
            String videopath = files[videofile].getPath();
            boolean isVideo = isVideoStatus(videopath);
            if (!isVideo) {
                Log.i(TAG, "getFiles_videos: 文件破损丢失");
                if (files[videofile] != null && files[videofile].exists()) {
                    files[videofile].delete();
                    new Thread(new VoidThread_Down(uri2, filename)).start();
                }
            }
        } else {
            Log.i(TAG, "getFiles_videos:文件不存在 ");
            Log.i(TAG, "getFiles_videos:链接 " + uri2);
            Log.i(TAG, "getFiles_videos:路径 " + rootFilepath());
            Log.i(TAG, "getFiles_videos:名称 " + filename);
            new Thread(new VoidThread_Down(uri2, filename)).start();
        }

    }

 

 

 private boolean isVideoStatus(String videofile) {
        //新增视频文件是否破损检测
        boolean isVideo = false;
        retriever = new MediaMetadataRetriever();
        try {
            retriever.setDataSource(videofile);
            String hasVideo = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO);
            isVideo = "yes".equals(hasVideo);
            Log.i(TAG, "isVideoStatus: 是否破损isVideo=" + isVideo); //true 正常 false 破损
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }finally {
            retriever.release();
        }

        return isVideo;
    }

在拿到视频uri的地方，调用方法

getFiles_videos(url_names, uri); 即可去检测将要播放的视频文件是否存在破损的情况了，

-----第二种方式---------2020/7/31--------测试备注--------------------------------------------------------------- 

      第二种虽然不用okhttp请求头的，方式避免了一定视频文件的开始就是错误的使用，缺点是当视频文件只是下载了一半的情况下，第二种的方式也不能完全检测该文件的完整性，当我这边用videoview来播放的时候，才测试出来，有视频破损的情况，这里找了很多方式，结合自己的业务代码情况，找到一个折中的处理的办法，大概核心思路是：当我用videoview播放到有错误的视频文件，我就把他的文件名记录下来，然后开个定时循环的线程去检测我的一个list数组里面是不是存放有错误的文件名，把该文件名字对应接口的视频url地址，再去执行一次下载，确保该文件的下载完整。

  video_view.setOnErrorListener(new MediaPlayer.OnErrorListener() {
                    @Override
                    public boolean onError(MediaPlayer mp, int what, int extra) {
                        Log.e(TAG, "off_onlieGetFiles:setOnErrorListener  " + what + "***" + extra);
                        callBackValue.Fragemt_videodownlad(filename); //检测到视频错误，发送到主activity下载
                        iv_videoerror.setVisibility(View.VISIBLE);
                        video_view.pause();//暂停
                        video_view.stopPlayback();
                        video_view.suspend();//在任何状态下释放媒体播放器
                        return true;
                    }
                });

    //专门处理视频异常问题重新开启下载
    @Override
    public void Fragemt_videodownlad(String filename) {
        Log.i(TAG, "Fragemt_videodownlad: 出现播放异常的文件名是=" + filename);

        if (!error_videofile.contains(filename)) {
            error_videofile.add(filename);
        }
        for (int i = 0; i < error_videofile.size(); i++) {
            Log.i(TAG, "Fragemt_videodownlad: error_videofile=" + error_videofile.get(i));
        }
    }

 if (!error_videofile.isEmpty()) {
                err_file = error_videofile.contains(filename);
                Log.i(TAG, "getFiles_videos: err_file=" + err_file);
            }else {
                err_file=false;
            }

            if (isVideo == false || err_file == true) {
                Log.i(TAG, "getFiles_videos:文件存在，破损丢失 ");
                if (files[videofile] != null && files[videofile].exists()) {
                    files[videofile].delete();
                    new Thread(new VoidThread_Down(uri2, filename)).start();
                }
            }

 开始下载的时候，把list 数组保存的错误视频名删除掉

   downFile(thread_uri, rootFilepath(), thread_url_names);
              //及时删掉已经执行下载的数据
            if (!error_videofile.isEmpty()) {
                for (int i = 0; i < error_videofile.size(); i++) {
                  if(error_videofile.get(i).equals(thread_url_names)){
                      error_videofile.remove(i);
                  }
                }
            }

 第三种方式：

 

 ----------------------------------------2020 8-6-------------- 采坑的记录--------------------------------------

       上面代码不是完整的，大概处理方式是这样的，只能说是折中办法。

上面处理方式核心都是想检测到将要播放的视频是报错的，就把本地路径文件夹下的该视频删除掉，然后通过定时请求接口，判断文件是否存在，没有就下载。

        问了很多大佬，其他们都是一致建议我用MD5的方式来判断文件的完整性，在和后台接口对接方面，先和后台的小伙伴来商量好，除了返回视频的下载地址，还有的就是MD5的字段，方便我们后面的文件破损验证，完全不用再和我上面的方式一，二的处理了，更加简单省事。

        可见为了实现一个视频播放，也是不是那么轻松完事的，还要考虑其他bug的处理上，以及我们一开始选择的方向也很重要，但是我们可以清楚知道问题的优缺点，去处理问题，也是事半功倍。当然上面的涉及代码较多，主要是核心的处理方法，展示出来，有时间可以耐心看看，也可ctrl\c到自己的编辑器上去运行使用。完整demo源码不提供下载，当然本人的知识水平有限，如果在本文使用缓存视频文件，有好的建议或者错误，可以在评论区留言一起探讨，方便我的修改和学习，谢谢。