今天分享一个开源库 AndroidVideoCache 。这个库主要是做视频缓存管理功能，支持边下边播，离线播放，缓存管理等。
用过MediaPlayer的小伙伴都知道，可以支持在线播放和播放本地资源，但是不支持缓存，下载后的数据直接交给播放器缓冲区，数据使用完了以后直接淘汰掉。
这样很消耗用户流量，这个时候AndroidVideoCache就派上用场了
AndroidVideoCache的用法
1.添加依赖 compile 'com.danikula:videocache:2.7.1'
2.在Application里面创建全局单例 HttpProxyCacheServer，代码如下：
public class App extends Application {
private HttpProxyCacheServer proxy;
public static HttpProxyCacheServer getProxy(Context context) {
App app = (App) context.getApplicationContext();
return app.proxy == null ? (app.proxy = app.newProxy()) : app.proxy;
}
private HttpProxyCacheServer newProxy() {
return new HttpProxyCacheServer(this);
}
}3.在给播放器设置url的时候通过生成代理url来实现视频的缓存，示例代码如下
private void startVideo() {
//拿到全局的单例 HttpProxyCacheServer
HttpProxyCacheServer proxy = App.getProxy(getActivity());
//注册下载缓存监听
proxy.registerCacheListener(this, url);
//生成代理url
String proxyUrl = proxy.getProxyUrl(url);
//给播放器设置播放路径的时候设置为上一步生成的proxyUrl
videoView.setVideoPath(proxyUrl);
videoView.start();
}以上就是AndroidVideoCache的使用，是不是特简单！当然它还可以设置缓存的大小，缓存路径、缓存文件的数量等，在初始化的时候设置即可，代码如下
private HttpProxyCacheServer newProxy() {
return new HttpProxyCacheServer.Builder(this)
.cacheDirectory(Utils.getVideoCacheDir(this))//缓存路径
.maxCacheFilesCount(100)//最大缓存文件数量
.maxCacheSize(1024 * 1024 * 1024) // 最大缓存大小 1 Gb for cache
.build();
}1.基本原理
AndroidVideoCache 通过代理的策略将我们的网络请求代理到本地服务，本地服务先判断是否有本地缓存，如果有本地缓存那么直接将本地缓存返回，如果没有本地缓存，那么ProxyServer会使用原视频url去远程服务器RemoteServer请求视频数据，获取到RemoteServer返回的数据后再缓存到本地(需要缓存则缓存)，再从本地返回给播放器播放。这样就做到了数据的复用。
分析源码当然要找一个入口，这里我们的入口当然是初始化HttpProxyCacheServer的地方，以上面的Builder方式初始化为例，我们看看HttpProxyCacheServer.Builder代码
public Builder(Context context) {
this.sourceInfoStorage = SourceInfoStorageFactory.newSourceInfoStorage(context);
//设置缓存路径
this.cacheRoot = StorageUtils.getIndividualCacheDirectory(context);
//设置缓存策略,采用限制大小的LRU策略
this.diskUsage = new TotalSizeLruDiskUsage(DEFAULT_MAX_SIZE);
//主要用来生成缓存文件名
this.fileNameGenerator = new Md5FileNameGenerator();
//默认不添加Http头信息
this.headerInjector = new EmptyHeadersInjector();
} 这里我们只分析this.sourceInfoStorage，其它的都已备注，没什么好解释的。我们看看SourceInfoStorageFactory
.newSourceInfoStorage做了什么，其实它只是new 了一个DatabaseSourceInfoStorage，源码如下
public class SourceInfoStorageFactory {
public static SourceInfoStorage newSourceInfoStorage(Context context) {
return new DatabaseSourceInfoStorage(context);
}
public static SourceInfoStorage newEmptySourceInfoStorage() {
return new NoSourceInfoStorage();
}
}通过名字我们可以看出，这个用到了SQLite,我们再跟进去看看DatabaseSourceInfoStorage的构造，就会发现缓存的信息其实是存储在数据库里面的
class DatabaseSourceInfoStorage extends SQLiteOpenHelper implements SourceInfoStorage {
private static final String TABLE = "SourceInfo";
private static final String COLUMN_ID = "_id";
private static final String COLUMN_URL = "url";
private static final String COLUMN_LENGTH = "length";
private static final String COLUMN_MIME = "mime";
private static final String[] ALL_COLUMNS = new String[]{COLUMN_ID, COLUMN_URL, COLUMN_LENGTH, COLUMN_MIME};
private static final String CREATE_SQL =
"CREATE TABLE " + TABLE + " (" +
COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," +
COLUMN_URL + " TEXT NOT NULL," +
COLUMN_MIME + " TEXT," +
COLUMN_LENGTH + " INTEGER" +
");";
DatabaseSourceInfoStorage(Context context) {
super(context, "AndroidVideoCache.db", null, 1);
checkNotNull(context);
}
@Override
public void onCreate(SQLiteDatabase db) {
checkNotNull(db);
db.execSQL(CREATE_SQL);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
throw new IllegalStateException("Should not be called. There is no any migration");
}
@Override
public SourceInfo get(String url) {
checkNotNull(url);
Cursor cursor = null;
try {
cursor = getReadableDatabase().query(TABLE, ALL_COLUMNS, COLUMN_URL + "=?", new String[]{url}, null, null, null);
return cursor == null || !cursor.moveToFirst() ? null : convert(cursor);
} finally {
if (cursor != null) {
cursor.close();
}
}
}
@Override
public void put(String url, SourceInfo sourceInfo) {
checkAllNotNull(url, sourceInfo);
SourceInfo sourceInfoFromDb = get(url);
boolean exist = sourceInfoFromDb != null;
ContentValues contentValues = convert(sourceInfo);
if (exist) {
getWritableDatabase().update(TABLE, contentValues, COLUMN_URL + "=?", new String[]{url});
} else {
getWritableDatabase().insert(TABLE, null, contentValues);
}
}
@Override
public void release() {
close();
}
private SourceInfo convert(Cursor cursor) {
return new SourceInfo(
cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_URL)),
cursor.getLong(cursor.getColumnIndexOrThrow(COLUMN_LENGTH)),
cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_MIME))
);
}
private ContentValues convert(SourceInfo sourceInfo) {
ContentValues values = new ContentValues();
values.put(COLUMN_URL, sourceInfo.url);
values.put(COLUMN_LENGTH, sourceInfo.length);
values.put(COLUMN_MIME, sourceInfo.mime);
return values;
}
}这个代码非常明了，其实就是做的数据库的初始化工作，数据库里面存的字段主要是url、length、mime ，SourceInfo这个类也仅仅是对这3个字段的封装，get put都是基于SourceInfo的，仅仅是方便而已，无需解释，这个主要是用来查找和保存缓存的信息
Builder走完后就到了build方法，build方法里面其实就是创建HttpProxyCacheServer的实例了，代码如下
private HttpProxyCacheServer(Config config) {
this.config = checkNotNull(config);
try {
//PROXY_HOST为127.0.0.1其实就是拿的localhost
InetAddress inetAddress = InetAddress.getByName(PROXY_HOST);
//通过localhost生成一个ServerSocket,localPort传0的话系统会随机分配一个端口号
this.serverSocket = new ServerSocket(0, 8, inetAddress);
//拿到系统分配的端口号
this.port = serverSocket.getLocalPort();
//将localhost添加到IgnoreHostProxySelector
IgnoreHostProxySelector.install(PROXY_HOST, port);
CountDownLatch startSignal = new CountDownLatch(1);
this.waitConnectionThread = new Thread(new WaitRequestsRunnable(startSignal));
this.waitConnectionThread.start();
startSignal.await(); // freeze thread, wait for server starts
this.pinger = new Pinger(PROXY_HOST, port);
LOG.info("Proxy cache server started. Is it alive? " + isAlive());
} catch (IOException | InterruptedException e) {
socketProcessor.shutdown();
throw new IllegalStateException("Error starting local proxy server", e);
}
}这里我们主要分析this.waitConnectionThread = new Thread(new WaitRequestsRunnable(startSignal)); 其它的都已注释。我们跟进去看看 WaitRequestRunnalbe里面做了什么
private final class WaitRequestsRunnable implements Runnable {
private final CountDownLatch startSignal;
public WaitRequestsRunnable(CountDownLatch startSignal) {
this.startSignal = startSignal;
}
@Override
public void run() {
startSignal.countDown();//信号量主要是为了保证这个run方法先执行
waitForRequest();
}
}
private void waitForRequest() {
try {
while (!Thread.currentThread().isInterrupted()) {
Socket socket = serverSocket.accept();
LOG.debug("Accept new socket " + socket);
socketProcessor.submit(new SocketProcessorRunnable(socket));
}
} catch (IOException e) {
onError(new ProxyCacheException("Error during waiting connection", e));
}
}我们可以看到waitForRequest 里面监听到请求后调用了socketProcessor.submit(new SocketProcessorRunnable(socket))；
到这里服务器socket一套比较清晰了，整理一下就是先构建一个全局的一个本地代理服务器 ServerSocket，指定一个随机端口，然后新开一个线程,在线程的 run 方法里，通过accept() 方法监听这个服务器socket的入站连接，accept() 方法会一直阻塞，直到有一个客户端尝试建立连接。
有了服务器，然后就是客户端的socket，先从使用时代理替换url地方开始看
public String getProxyUrl(String url) {
return getProxyUrl(url, true);
}
public String getProxyUrl(String url, boolean allowCachedFileUri) {
if (allowCachedFileUri && isCached(url)) {
//如果视频已缓存,直接返回本地视频uri
File cacheFile = getCacheFile(url);
//touchFileSafely只是更新视频的lastModifyTime,因为是LRUCache
touchFileSafely(cacheFile);
return Uri.fromFile(cacheFile).toString();
}
return isAlive() ? appendToProxyUrl(url) : url;
}
private String appendToProxyUrl(String url) {
return String.format(Locale.US, "http://%s:%d/%s", PROXY_HOST, port, ProxyCacheUtils.encode(url));
}整个策略就是如果本地已经缓存了，就直接那本地地址的Uri，并且touch一下文件，把时间更新后最新，因为后面LruCache是根据文件被访问的时间进行排序的，如果文件没有被缓存那么就会先走一下 isAlive() 方法， 这里会ping一下目标url，确保url是一个有效的，如果用户是通过代理访问的话，就会ping不通，这样就还是原生url，正常情况都会进入这个 appendToProxyUrl 方法里面。
这里拼接出来一个带有127.0.0.1目标地址及端口并携带原url的新地址，这个请求的话就会被我们的服务器socket监听到，也就是前面的accept() 会继续往下走，这里接收到的socket就是我们所请求的客户端socket。
socketProcessor.submit(new SocketProcessorRunnable(socket));整个socket会被包裹成一个runnable，发配给线程池。这个 runnable 的 run 方法中所做的事情就是调用了一个方法：
private void processSocket(Socket socket) {
try {
//1.操作socket调用GetRequest.read()
GetRequest request = GetRequest.read(socket.getInputStream());
LOG.debug("Request to cache proxy:" + request);
String url = ProxyCacheUtils.decode(request.uri);//获取到原生的请求url
if (pinger.isPingRequest(url)) {
pinger.responseToPing(socket);
} else {
HttpProxyCacheServerClients clients = getClients(url);
clients.processRequest(request, socket);
}
} catch (SocketException e) {
// There is no way to determine that client closed connection http://stackoverflow.com/a/10241044/999458
// So just to prevent log flooding don't log stacktrace
LOG.debug("Closing socket Socket is closed by client.");
} catch (ProxyCacheException | IOException e) {
onError(new ProxyCacheException("Error processing request", e));
} finally {
releaseSocket(socket);
LOG.debug("Opened connections: " + getClientsCount());
}
}
前面ping的过程其实也被会这个socket监听并且走进来这一段，不过这个比较简单，就不分析了，我们直接看里面的 else 框内的代码，这里一个 getClients 就是一个ConcurrentHashMap，重复url返回的是同一个HttpProxyCacheServerClients 。
如果是第一次就会根据url构建出一个HttpProxyCacheServerClients并被put到ConcurrentHashMap中，真正的操作都在这个客户端的 processRequest 操作中，并且传递过去一个是request，这是一个GetRequest 对象，是一个url和rangeoffset以及partial的包装类，另一个就是客户端socket。
public void processRequest(GetRequest request, Socket socket) throws ProxyCacheException, IOException {
startProcessRequest();
try {
clientsCount.incrementAndGet();
proxyCache.processRequest(request, socket);
} finally {
finishProcessRequest();
}
}这里 startProcessRequest 方法会得到一个HttpProxyCache 类
private synchronized void startProcessRequest() throws ProxyCacheException {
proxyCache = proxyCache == null ? newHttpProxyCache() : proxyCache;
}
private HttpProxyCache newHttpProxyCache() throws ProxyCacheException {
HttpUrlSource source = new HttpUrlSource(url, config.sourceInfoStorage);
FileCache cache = new FileCache(config.generateCacheFile(url), config.diskUsage);
HttpProxyCache httpProxyCache = new HttpProxyCache(source, cache);
httpProxyCache.registerCacheListener(uiCacheListener);
return httpProxyCache;
}在这里，我们构建一个基于原生url的HttpUrlSource ，这个类负责持有url，并开启HttpURLConnection来获取一个InputStream，这样才能通过这个输入流读数据，同时也创建了一个本地的临时文件，一个以.download结尾的临时文件，这个文件在成功下载完后的 FileCache 类中的 complete 方法中被更名。
我们构建了一个HttpProxyCache 类，也注册了一个CacheListener，这个listener可以用来回调进度。
做完这一切之后，然后这个HttpProxyCache 对象就开始 processRequest ，
public void processRequest(GetRequest request, Socket socket) throws IOException, ProxyCacheException {
OutputStream out = new BufferedOutputStream(socket.getOutputStream());
String responseHeaders = newResponseHeaders(request);
out.write(responseHeaders.getBytes("UTF-8"));
long offset = request.rangeOffset;
if (isUseCache(request)) {
responseWithCache(out, offset);
} else {
responseWithoutCache(out, offset);
}
}这里我们用传过来的那个客户端socket，拿到一个OutputStream输出流，这样我们就能往里面写数据了，如果不用缓存就走常规逻辑，这里我们只看走缓存的行为。
private void responseWithCache(OutputStream out, long offset) throws ProxyCacheException, IOException {
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int readBytes;
while ((readBytes = read(buffer, offset, buffer.length)) != -1) {
out.write(buffer, 0, readBytes);
offset += readBytes;
}
out.flush();
}构造一个8 * 1024字节的buffer，这里的read方法，实际上是调用的父类ProxyCache的实现
public int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
ProxyCacheUtils.assertBuffer(buffer, offset, length);
while (!cache.isCompleted() && cache.available() < (offset + length) && !stopped) {
//这里就是缓存到本地的操作了
readSourceAsync();
waitForSourceData();
checkReadSourceErrorsCount();
}
int read = cache.read(buffer, offset, length);
if (cache.isCompleted() && percentsAvailable != 100) {
percentsAvailable = 100;
onCachePercentsAvailableChanged(100);
}
return read;
}在while循环里面，开启了一个新的线程sourceReaderThread，其中封装了一个SourceReaderRunnable的Runnable，这个异步线程用来给cache，也就是本地文件写数据，同时还更新一下当前的缓存进度
private synchronized void readSourceAsync() throws ProxyCacheException {
boolean readingInProgress = sourceReaderThread != null && sourceReaderThread.getState() != Thread.State.TERMINATED;
if (!stopped && !cache.isCompleted() && !readingInProgress) {
//6.具体的缓存操作在SourceReaderRunnable里面
sourceReaderThread = new Thread(new SourceReaderRunnable(), "Source reader for " + source);
sourceReaderThread.start();
}
}
private class SourceReaderRunnable implements Runnable {
@Override
public void run() {
//7.到此，我们会发现所有的缓存操作都是方法readSource()做的了
readSource();
}
}
private void readSource() {
long sourceAvailable = -1;
long offset = 0;
try {
offset = cache.available();
source.open(offset);
sourceAvailable = source.length();
byte[] buffer = new byte[ProxyCacheUtils.DEFAULT_BUFFER_SIZE];
int readBytes;
while ((readBytes = source.read(buffer)) != -1) {
synchronized (stopLock) {
if (isStopped()) {
return;
}
cache.append(buffer, readBytes);
}
offset += readBytes;
notifyNewCacheDataAvailable(offset, sourceAvailable);//通知下载更新
}
tryComplete();
onSourceRead();//通知更新进度
} catch (Throwable e) {
readSourceErrorsCount.incrementAndGet();
onError(e);
} finally {
closeSource();
notifyNewCacheDataAvailable(offset, sourceAvailable);
}
}同时我们的另一个线程也会从cache中去读数据，在缓存结束后同样也会发送一个通知通知自己已经缓存完了，回调由外界控制。
以上差不多就是总体代码，这里我们在请求远程URL时将文件写到本地fileCache中，然后读数据从本地读取，写入到客户端socket里面，服务器Socket主要还是一个代理的作用，从中间拦截掉网络请求，然后实现对socket的读取和写入。
注意：对于m3u8格式的视频，url缓存是不一样的， m3u8是切片的数据 这个需要特殊的处理方式 缓存需要考虑切片索引以及视频文件拼接
扫一扫
1373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
