Android視頻點播-邊播邊緩存-方案

Android視頻點播-邊播邊緩存-方案

簡述

一些知名的視頻app客戶端（優(yōu)酷，愛奇藝）播放視頻的時候都有一些緩存進度(二級進度緩存)，qq，微信有關(guān)的小視頻，還有一些短視頻app，都有邊播邊緩的處理。還有就是當(dāng)文件緩存完畢了再次播放的話就不再請求網(wǎng)絡(luò)了直接播放本地文件了。既節(jié)省了流程又提高了加載速度。
今天我們就是來研究討論實現(xiàn)這個邊播邊緩存的框架，因為它不和任何的業(yè)務(wù)邏輯耦合。

開源的項目

目前比較好的開源項目是：
https://github.com/danikula/AndroidVideoCache
代碼的架構(gòu)寫的也很不錯，網(wǎng)絡(luò)用的httpurlconnect，文件緩存處理，文件最大限度策略，回調(diào)監(jiān)聽處理，斷點續(xù)傳,代理服務(wù)等。很值得研究閱讀.
個人覺得項目中有幾個需要優(yōu)化的點，今天就來處理這幾個并簡要分析下原理
優(yōu)化點比如：

  1. 文件的緩存超過限制后沒有按照lru算法刪除，
  2. 處理返回給播放器的http響應(yīng)頭消息，響應(yīng)頭消息的獲取處理改為head請求（需服務(wù)器支持）
  3. 替換網(wǎng)絡(luò)庫為okhttp（因為大部分的項目都是以okhttp為網(wǎng)絡(luò)請求庫的）

該開源項目的原理分析-本地代理

原始的方式是直接塞播放地址給播放器，它就可以直接播放。現(xiàn)在我們要在中間加一層本地代理，播放器播放的時候（獲取數(shù)據(jù)）是通過我們的本地代理的地址來播放的，這樣我們就可以很好的在中間層（本地代理層）做一些處理，比如：文件緩存，預(yù)緩存（秒開處理），監(jiān)控等。

視頻點播框架圖.jpg
  1. 采用了本地代理服務(wù)的方式，通過原始url給播放器返回一個本地代理的一個url ，代理URL類似：http://127.0.0.1:57430/真實url；（57430端口為系統(tǒng)隨機分配的有效端口，真實url是為了真正的下載，當(dāng)然也可以是一定的加密規(guī)則），然后播放器播放的時候請求到了你本地的代理上了。
  2. 讀取客戶端就是socket來讀取數(shù)據(jù)（http協(xié)議請求）解析http協(xié)議。
  3. 根據(jù)url檢查視頻文件是否存在，讀取文件數(shù)據(jù)給播放器，也就是往socket里寫入數(shù)據(jù)（socket通信）。同時如果沒有下載完成會進行斷點下載,當(dāng)然弱網(wǎng)的話數(shù)據(jù)需要生產(chǎn)消費同步處理。

優(yōu)化點

1. 文件的緩存超過限制后沒有按照lru算法刪除.

Files類。
由于在移動設(shè)備上file.setLastModified（） 方法不支持毫秒級的時間處理，導(dǎo)致超出限制大小后本應(yīng)該刪除老的，卻沒有刪除拋出了異常。注釋掉主動拋出的異常即可。因為文件的修改時間就是對的。

    static void setLastModifiedNow(File file) throws IOException {
        if (file.exists()) {
            long now = System.currentTimeMillis();
            boolean modified = file.setLastModified(now/1000*1000); // on some devices (e.g. Nexus 5) doesn't work
            if (!modified) {
                modify(file);
//                if (file.lastModified() < now) {
//                    VideoCacheLog.debug("LruDiskUsage", "modified not ok ");
//                    throw new IOException("Error set last modified date to " + file);
//                }else{
//                    VideoCacheLog.debug("LruDiskUsage", "modified ok ");
//                }
            }
        }
    }

2. 處理返回給播放器的http響應(yīng)頭消息，響應(yīng)頭消息的獲取處理改為head請求(需要服務(wù)器支持)

HttpUrlSource類。fetchContentInfo方法是獲取視頻文件的Content-Type，Content-Length信息，是為了播放器播放的時候給播放器組裝http響應(yīng)頭信息用的。所以這一塊需要用數(shù)據(jù)庫保存，這樣播放器每次播放的時候不要在此獲取了，減少了請求的次數(shù)，節(jié)省了流量。既然是只需要頭信息，不需要響應(yīng)體，所以我們在獲取的時候可以直接采用HEAD方法。所以代碼增加了一個方法openConnectionForHeader如下：

  private void fetchContentInfo() throws ProxyCacheException {
        VideoCacheLog.debug(TAG,"Read content info from " + sourceInfo.url);
        HttpURLConnection urlConnection = null;
        InputStream inputStream = null;
        try {
            urlConnection = openConnectionForHeader(20000);
            long length = getContentLength(urlConnection);
            String mime = urlConnection.getContentType();
            inputStream = urlConnection.getInputStream();
            this.sourceInfo = new SourceInfo(sourceInfo.url, length, mime);
            this.sourceInfoStorage.put(sourceInfo.url, sourceInfo);
            VideoCacheLog.debug(TAG,"Source info fetched: " + sourceInfo);
        } catch (IOException e) {
            VideoCacheLog.error(TAG,"Error fetching info from " + sourceInfo.url ,e);
        } finally {
            ProxyCacheUtils.close(inputStream);
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
        }
    }

    // for HEAD
    private HttpURLConnection openConnectionForHeader(int timeout) throws IOException, ProxyCacheException {
        HttpURLConnection connection;
        boolean redirected;
        int redirectCount = 0;
        String url = this.sourceInfo.url;
        do {
            VideoCacheLog.debug(TAG, "Open connection for header to " + url);
            connection = (HttpURLConnection) new URL(url).openConnection();
            if (timeout > 0) {
                connection.setConnectTimeout(timeout);
                connection.setReadTimeout(timeout);
            }
            //只返回頭部，不需要BODY，既可以提高響應(yīng)速度也可以減少網(wǎng)絡(luò)流量
            connection.setRequestMethod("HEAD");
            int code = connection.getResponseCode();
            redirected = code == HTTP_MOVED_PERM || code == HTTP_MOVED_TEMP || code == HTTP_SEE_OTHER;
            if (redirected) {
                url = connection.getHeaderField("Location");
                VideoCacheLog.debug(TAG,"Redirect to:" + url);
                redirectCount++;
                connection.disconnect();
                VideoCacheLog.debug(TAG,"Redirect closed:" + url);
            }
            if (redirectCount > MAX_REDIRECTS) {
                throw new ProxyCacheException("Too many redirects: " + redirectCount);
            }
        } while (redirected);
        return connection;
    }

3.替換網(wǎng)絡(luò)庫為okhttp（因為大部分的項目都是以okhttp為網(wǎng)絡(luò)請求庫的）

為什么我們要換呢？！一是OKHttp是一款高效的HTTP客戶端，支持連接同一地址的鏈接共享同一個socket，通過連接池來減小響應(yīng)延遲，
還有透明的GZIP壓縮，請求緩存等優(yōu)勢，其核心主要有路由、連接協(xié)議、攔截器、代理、安全性認證、連接池以及網(wǎng)絡(luò)適配，攔截器主要是指添加，移除或者轉(zhuǎn)換請求或者回應(yīng)的頭部信息。得到了android開發(fā)的認可。二是大部分的app都是采用OKHttp，而且google會將其納入android 源碼中。
三是該作者代碼中用的httpurlconnet在HttpUrlSource有這么一段：

  @Override
    public void close() throws ProxyCacheException {
        if (connection != null) {
            try {
                connection.disconnect();
            } catch (NullPointerException | IllegalArgumentException e) {
                String message = "Wait... but why? WTF!? " +
                        "Really shouldn't happen any more after fixing https://github.com/danikula/AndroidVideoCache/issues/43. " +
                        "If you read it on your device log, please, notify me danikula@gmail.com or create issue here " +
                        "https://github.com/danikula/AndroidVideoCache/issues.";
                throw new RuntimeException(message, e);
            } catch (ArrayIndexOutOfBoundsException e) {
                VideoCacheLog.error(TAG,"Error closing connection correctly. Should happen only on Android L. " +
                        "If anybody know how to fix it, please visit https://github.com/danikula/AndroidVideoCache/issues/88. " +
                        "Until good solution is not know, just ignore this issue :(", e);
            }
        }
    }

在沒有像okhttp這些優(yōu)秀的網(wǎng)絡(luò)開源項目之前，android開發(fā)都是采用httpurlconnet或者httpclient，部分手機可能會遇到這個問題哈。
這里采用的 compile 'com.squareup.okhttp:okhttp:2.7.5' 版本的來實現(xiàn)該類的功能。在原作者的架構(gòu)思路上我們只需要增加實現(xiàn)Source接口的類OkHttpUrlSource即可，可見作者的代碼架構(gòu)還是不錯的，當(dāng)然我們同樣需要處理上文中提高的優(yōu)化點2中的問題。將項目中所有用到HttpUrlSource的地方改為OkHttpUrlSource即可。
源碼如下：

/**
 * ================================================
 * 作    者：顧修忠-guxiuzhong@youku.com/gfj19900401@163.com
 * 版    本：
 * 創(chuàng)建日期：2017/4/13-上午12:03
 * 描    述：在一些Android手機上HttpURLConnection.disconnect()方法仍然耗時太久，
 * 進行導(dǎo)致MediaPlayer要等待很久才會開始播放，因此決定使用okhttp替換HttpURLConnection
 * 修訂歷史：
 * ================================================
 */

public class OkHttpUrlSource implements Source {

    private static final String TAG = OkHttpUrlSource.class.getSimpleName();
    private static final int MAX_REDIRECTS = 5;
    private final SourceInfoStorage sourceInfoStorage;
    private SourceInfo sourceInfo;
    private OkHttpClient okHttpClient = new OkHttpClient();
    private Call requestCall = null;
    private InputStream inputStream;

    public OkHttpUrlSource(String url) {
        this(url, SourceInfoStorageFactory.newEmptySourceInfoStorage());
    }

    public OkHttpUrlSource(String url, SourceInfoStorage sourceInfoStorage) {
        this.sourceInfoStorage = checkNotNull(sourceInfoStorage);
        SourceInfo sourceInfo = sourceInfoStorage.get(url);
        this.sourceInfo = sourceInfo != null ? sourceInfo :
                new SourceInfo(url, Integer.MIN_VALUE, ProxyCacheUtils.getSupposablyMime(url));
    }

    public OkHttpUrlSource(OkHttpUrlSource source) {
        this.sourceInfo = source.sourceInfo;
        this.sourceInfoStorage = source.sourceInfoStorage;
    }

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

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

    private long readSourceAvailableBytes(Response response, long offset, int responseCode) throws IOException {
        long contentLength = getContentLength(response);
        return responseCode == HTTP_OK ? contentLength
                : responseCode == HTTP_PARTIAL ? contentLength + offset : sourceInfo.length;
    }

    private long getContentLength(Response response) {
        String contentLengthValue = response.header("Content-Length");
        return contentLengthValue == null ? -1 : Long.parseLong(contentLengthValue);
    }

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

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

    private void fetchContentInfo() throws ProxyCacheException {
        VideoCacheLog.debug(TAG, "Read content info from " + sourceInfo.url);
        Response response = null;
        InputStream inputStream = null;
        try {
            response = openConnectionForHeader(20000);
            if (response == null || !response.isSuccessful()) {
                throw new ProxyCacheException("Fail to fetchContentInfo: " + sourceInfo.url);
            }
            long length = getContentLength(response);
            String mime = response.header("Content-Type", "application/mp4");
            inputStream = response.body().byteStream();
            this.sourceInfo = new SourceInfo(sourceInfo.url, length, mime);
            this.sourceInfoStorage.put(sourceInfo.url, sourceInfo);
            VideoCacheLog.info(TAG, "Content info for `" + sourceInfo.url + "`: mime: " + mime + ", content-length: " + length);
        } catch (IOException e) {
            VideoCacheLog.error(TAG, "Error fetching info from " + sourceInfo.url, e);
        } finally {
            ProxyCacheUtils.close(inputStream);
            if (response != null && requestCall != null) {
                requestCall.cancel();
            }
        }
    }

    // for HEAD
    private Response openConnectionForHeader(int timeout) throws IOException, ProxyCacheException {
        if (timeout > 0) {
//            okHttpClient.setConnectTimeout(timeout, TimeUnit.MILLISECONDS);
//            okHttpClient.setReadTimeout(timeout, TimeUnit.MILLISECONDS);
//            okHttpClient.setWriteTimeout(timeout, TimeUnit.MILLISECONDS);
        }
        Response response;
        boolean isRedirect = false;
        String newUrl = this.sourceInfo.url;
        int redirectCount = 0;
        do {
            //只返回頭部，不需要BODY，既可以提高響應(yīng)速度也可以減少網(wǎng)絡(luò)流量
            Request request = new Request.Builder()
                    .head()
                    .url(newUrl)
                    .build();
            requestCall = okHttpClient.newCall(request);
            response = requestCall.execute();
            if (response.isRedirect()) {
                newUrl = response.header("Location");
                VideoCacheLog.debug(TAG, "Redirect to:" + newUrl);
                isRedirect = response.isRedirect();
                redirectCount++;
                requestCall.cancel();
                VideoCacheLog.debug(TAG, "Redirect closed:" + newUrl);
            }
            if (redirectCount > MAX_REDIRECTS) {
                throw new ProxyCacheException("Too many redirects: " + redirectCount);
            }
        } while (isRedirect);

        return response;
    }

    private Response openConnection(long offset, int timeout) throws IOException, ProxyCacheException {
        if (timeout > 0) {
//            okHttpClient.setConnectTimeout(timeout, TimeUnit.MILLISECONDS);
//            okHttpClient.setReadTimeout(timeout, TimeUnit.MILLISECONDS);
//            okHttpClient.setWriteTimeout(timeout, TimeUnit.MILLISECONDS);
        }
        Response response;
        boolean isRedirect = false;
        String newUrl = this.sourceInfo.url;
        int redirectCount = 0;
        do {
            VideoCacheLog.debug(TAG, "Open connection" + (offset > 0 ? " with offset " + offset : "") + " to " + sourceInfo.url);
            Request.Builder requestBuilder = new Request.Builder()
                    .get()
                    .url(newUrl);
            if (offset > 0) {
                requestBuilder.addHeader("Range", "bytes=" + offset + "-");
            }
            requestCall = okHttpClient.newCall(requestBuilder.build());
            response = requestCall.execute();
            if (response.isRedirect()) {
                newUrl = response.header("Location");
                isRedirect = response.isRedirect();
                redirectCount++;
            }
            if (redirectCount > MAX_REDIRECTS) {
                throw new ProxyCacheException("Too many redirects: " + redirectCount);
            }
        } while (isRedirect);

        return response;
    }

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

    public String getUrl() {
        return sourceInfo.url;
    }

    @Override
    public String toString() {
        return "OkHttpUrlSource{sourceInfo='" + sourceInfo + "}";
    }
}
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容