AndroidVideoCache:实现视屏播放边下边播

  categories:资料  author:

前言

现在在Android上实现视频播放已不是什么难事,这方面的轮子已经很多,不管是Google的 ExoPlayer、B站的 ijkplayer,还是一些其他的,基本上都能满足我们的需求。

但现在视频播放我们追求的是更好的用户体验:播放流畅,没有卡顿,不跳帧。因此,如何优化体验是一件十分重要的事情。

另外,做过视频播放的小伙伴都知道:在CDN的情况下,实现视频边缓冲边播是不可能的。而只有在P2P下才能实现视频边下边播。如果,产品经理让你实现边下边播的功能,你心里肯定一万只草泥马奔腾而过~,然后,还得耐心给她介绍:这功能实现不了,因为xxx实现不了,云云……

上面的问题真的就解决不了吗?在CDN下就真的不能边下边播吗?

其实,不然,AndroidVideoCache就能满足你的需求,解决上述问题

简介

AndroidVideoCache是国外大神Alexey Danilov写的一个android开源库。一个视频/音频缓存库,利用本地代理实现了边下边播,支VideoView/MediaPlayer,    ExoPlayer ,IJK等播放器的边下载边播放。集成简单,与业务无关。

代码的架构写的也很不错,很值得研究阅读和学习借鉴。网络用httpurlconnect,实现了文件缓存处理,文件最大限度策略,回调监听处理,断点续传,代理服务等功能。

目前 1.9k star,491个fork,最新版本2.7.0

特性

AndroidVideoCache是一个音视频边下边播缓存库,按照github列出支持的特性如下:

1、支持边下边播

2、流媒体磁盘缓存

音视频播放的时候会将多媒体数据存储于磁盘上面

3、资源离线缓存

如果播放的数据已经缓存,支持离线播放

4、局部加载

支持部分加载

5、缓存限制

可以设置缓存配置,如缓存的大小,允许最大的缓存文件数量

6、支持多客户端

对于同一个url地址请求源,允许有多个请求客户端链接

7、封装简单,容易集成到自己的项目,与业务无关

8.、采用本地代理模式实现边下边播

注意,AndroidVideoCache只对媒体文件使用直接url,它不支持任何流技术,如DASH,平滑流,HLS。

原理

项目的原理其实就是将url链接转化为本地链接 h t t p://127.0.0.1:LocalPort/url ,然后它开一个服务器一边下载缓存视频,一边把缓存的数据正常返回给你的播放器,如果已经缓存过的这里会返回一个本地文件路径。

一般情况下是直接塞播放地址给播放器,它就可以直接播放。现在我们要在中间加一层本地代理,播放器播放的时候(获取数据)是通过我们的本地代理的地址来播放的,这样我们就可以很好的在中间层(本地代理层)做一些处理,比如:文件缓存,预缓存(秒开处理),监控等。

AndroidVideoCache 就是通过代理的策略实现一个中间层将我们的网络请求转移到本地实现的代理服务器上,这样我们真正请求的数据就会被代理拿到,这样代理一边向本地写入数据,一边根据我们需要的数据看是读网络数据还是读本地缓存数据再提供给我们,真正做到了数据的复用。

如下图,左边是传统的视频播放模式,右边是AndroidVideoCache的实现方式

v1

架构图

  1. 采用了本地代理服务的方式,通过原始url给播放器返回一个本地代理的一个url ,代理URL类似:http://127.0.0.1:x x x x/真实url;(真实url是为了真正的下载),然后播放器播放的时候请求到了你本地的代理上了。
  2. 读取客户端就是socket来读取数据(http协议请求)解析http协议。
  3. 根据url检查视频文件是否存在,读取文件数据给播放器,也就是往socket里写入数据(socket通信)。同时如果没有下载完成会进行断点下载,当然弱网的话数据需要生产消费同步处理。

这就和我们使用的抓包软件性质一样,具体时序图如下,这样更清晰:

v2

代理服务器策略

实战

AndroidVideoCache接入简单,使用简单

  1. gradle中配置,目前最新版本2.7.0:

2.使用代理URL代替原始视频URL:

3.全局初始化一个本地代理服务器: 单例HttpProxyCacheServer

4.参数配置:

更多使用和特性参见官方:https://github.com/danikula/AndroidVideoCache

Demo地址

项目地址:  https://github.com/danikula/AndroidVideoCache

Demo地址:https://github.com/danikula/AndroidVideoCache/tree/exoPlayer

                      https://github.com/CarGuo/GSYVideoPlayer

 

来源: https://juejin.im/entry/5a2f51ca6fb9a044fa19d327

对于视频/音频软件,音乐软件,视频软件,都有缓存这个功能,那如何实现边下边播功能:

  • 如何实现这个边下边播功能?
  • 文件是否支持同时读写?(Mediaplayer 播放文件,从网络上下载文件)
  • 播放与下载进度如何协调?
  • 已缓存的文件需及时清理

经过一番折腾,我 find 了 : [ AndroidVideoCache ],这个库是 danikula 大神写,看完源码后收益匪浅。实现流媒体边下边播原理利用socket 开启一个本机的代理服务器

结合自身需求,修改了该库,使用okhttp进行网络请求:
AndroidVideoCache (改成 okhttp 缓存)

package com.danikula.videocache;

import android.text.TextUtils;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import com.danikula.videocache.file.MyLog;

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

import static com.danikula.videocache.ProxyCacheUtils.DEFAULT_BUFFER_SIZE;
import static com.danikula.videocache.ProxyCacheUtils.LOG_TAG;
import static java.net.HttpURLConnection.HTTP_OK;
import static java.net.HttpURLConnection.HTTP_PARTIAL;

/**
 * {@link Source} that uses http resource as source for {@link ProxyCache}.
 *
 * @author Alexey Danilov (danikula@gmail.com).
 * 
 *  从URL 获取数据
 */
public class HttpUrlSource implements Source {

    private static final int MAX_REDIRECTS = 5;
    public final String url;
    private static OkHttpClient okHttpClient = new OkHttpClient();
    private Call requestCall = null;
    private InputStream inputStream;
    private volatile int length = Integer.MIN_VALUE;
    private volatile String mime;
    private Map<String, String> headers;

    public HttpUrlSource(String url) {
        this(url, ProxyCacheUtils.getSupposablyMime(url));
    }

    public HttpUrlSource(String url, Map<String, String> headers) {
        this(url, ProxyCacheUtils.getSupposablyMime(url));
        this.headers = headers;
    }

    public HttpUrlSource(String url, String mime) {
        this.url = Preconditions.checkNotNull(url);
        this.mime = mime;
    }

    public HttpUrlSource(HttpUrlSource source) {
        this.url = source.url;
        this.mime = source.mime;
        this.length = source.length;
    }

    @Override
    public synchronized int length() throws ProxyCacheException {
        if (length == Integer.MIN_VALUE) {
            fetchContentInfo();
        }
        return length;
    }

    @Override
    public void open(int offset) throws ProxyCacheException {
        try {
            Response response = openConnection(offset, -1);
            mime = response.header("Content-Type");
            inputStream = new BufferedInputStream(response.body().byteStream(), DEFAULT_BUFFER_SIZE);
            length = readSourceAvailableBytes(response, offset, response.code());
        } catch (IOException e) {
            throw new ProxyCacheException("Error opening okHttpClient for " + url + " with offset " + offset, e);
        }
    }

    private int readSourceAvailableBytes(Response response, int offset, int responseCode) throws IOException {
        int contentLength = Integer.valueOf(response.header("Content-Length", "-1"));

        return responseCode == HTTP_OK ? contentLength
                : responseCode == HTTP_PARTIAL ? contentLength + offset : length;
    }

    @Override
    public void close() throws ProxyCacheException {
        if (okHttpClient != null && inputStream != null && requestCall != null) {
            try {
                inputStream.close();
                requestCall.cancel();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public int read(byte[] buffer) throws ProxyCacheException {
        if (inputStream == null) {
            throw new ProxyCacheException("Error reading data from " + url + ": okHttpClient is absent!");
        }
        try {
            return inputStream.read(buffer, 0, buffer.length);
        } catch (InterruptedIOException e) {
            throw new InterruptedProxyCacheException("Reading source " + url + " is interrupted", e);
        } catch (IOException e) {
            throw new ProxyCacheException("Error reading data from " + url, e);
        }
    }

    private void fetchContentInfo() throws ProxyCacheException {
        MyLog.d(LOG_TAG, "Read content info from " + url);
        Response response = null;
        InputStream inputStream = null;
        try {
            response = openConnection(0, 20000);
            length = Integer.valueOf(response.header("Content-Length", "-1"));
            mime = response.header("Content-Type");
            inputStream = response.body().byteStream();
            MyLog.i(LOG_TAG, "Content info for `" + url + "`: mime: " + mime + ", content-length: " + length);
        } catch (IOException e) {
            MyLog.e(LOG_TAG, "Error fetching info from " + url, e);
        } finally {
            ProxyCacheUtils.close(inputStream);
            if (response != null) {
                requestCall.cancel();
            }
        }
    }

    private Response openConnection(int offset, int timeout) throws IOException, ProxyCacheException {
        boolean redirected;
        int redirectCount = 0;
        String url = this.url;
        Request request = null;
        //do {
            MyLog.d(LOG_TAG, "Open okHttpClient " + (offset > 0 ? " with offset " + offset : "") + " to " + url);
//            okHttpClient = (HttpURLConnection) new URL(url).openConnection();
            Request.Builder builder = new Request.Builder();
            builder.url(url);
            //flac
            if(headers != null) {
                //设置请求头
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    MyLog.i(LOG_TAG, "请求头信息 key:" + entry.getKey() +" Value" + entry.getValue());
//                    okHttpClient.setRequestProperty(entry.getKey(), entry.getValue());
                    builder.addHeader(entry.getKey(), entry.getValue());
                }
            }
            if (offset > 0) {
                builder.addHeader("Range", "bytes=" + offset + "-");
            }

            request = builder.build();
            requestCall = okHttpClient.newCall(request);
            /*if (redirected) {
                url = okHttpClient.getHeaderField("Location");
                redirectCount++;
                okHttpClient.disconnect();
            }
            if (redirectCount > MAX_REDIRECTS) {
                throw new ProxyCacheException("Too many redirects: " + redirectCount);
            }*/
        //} while (redirected);

        return requestCall.execute();
    }

    public synchronized String getMime() throws ProxyCacheException {
        if (TextUtils.isEmpty(mime)) {
            fetchContentInfo();
        }
        return mime;
    }

    public String getUrl() {
        return url;
    }

    @Override
    public String toString() {
        return "HttpUrlSource{url='" + url + "}";
    }
}

 

 



快乐成长 每天进步一点点