Detailed explanation of Android video and audio cache framework AndroidVideoCache (Okhttp)

For your reference, the specific content is as follows

For video/audio software, music software and video software, there is a cache function, so how to realize the function of broadcasting while playing:

How to realize this side-by-side broadcast function? Does the file support reading and writing at the same time? (Mediaplayer Play Files, Download Files from Network) How to coordinate the playing and downloading progress? Cached files need to be cleaned in time

After a toss, I find: [AndroidVideoCache], this library is written by danikula God, read the source code after a lot of profit. Realize the principle of streaming media playing while playing, and use socket to open a local proxy server

According to my own needs, I modified the library and used okhttp to make network requests:
AndroidVideoCache (changed to okhttp cache)

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).
 * 
 *  From URL  Get data 
 */
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) {
        // Set the request header 
        for (Map.Entry<String, String> entry : headers.entrySet()) {
          MyLog.i(LOG_TAG, " Request header information  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 + "}";
  }
}

Download address: Android video and audio cache framework AndroidVideoCache