1、HttpUrlSource.fetchContentInfo()
此方法作用是获取url的length(长度)和mime(文件类型)，在HttpUrlSource.length()和HttpUrlSource.getMime()中被调用，而调用HttpUrlSource.length()和HttpUrlSource.getMime()则是在HttpProxyCache.newResponseHeaders()中。
public synchronized int length() throws ProxyCacheException {
if (length == Integer.MIN_VALUE) {
fetchContentInfo();
}
return length;
}
public synchronized String getMime() throws ProxyCacheException {
if (TextUtils.isEmpty(mime)) {
fetchContentInfo();
}
return mime;
}
private void fetchContentInfo() throws ProxyCacheException {
Log.d(LOG_TAG, "Read content info from " + url);
HttpURLConnection urlConnection = null;
InputStream inputStream = null;
try {
urlConnection = openConnection(0, 10000);
length = urlConnection.getContentLength();
mime = urlConnection.getContentType();
inputStream = urlConnection.getInputStream();
Log.i(LOG_TAG, "Content info for `" + url + "`: mime: " + mime + ", content-length: " + length);
} catch (IOException e) {
Log.e(LOG_TAG, "Error fetching info from " + url, e);
} finally {
ProxyCacheUtils.close(inputStream);
if (urlConnection != null) {
urlConnection.disconnect();
}
}
}
private HttpURLConnection openConnection(int offset, int timeout) throws IOException, ProxyCacheException {
HttpURLConnection connection;
boolean redirected;
int redirectCount = 0;
String url = this.url;
do {
Log.d(LOG_TAG, "Open connection " + (offset > 0 ? " with offset " + offset : "") + " to " + url);
connection = (HttpURLConnection) new URL(url).openConnection();
if (offset > 0) {
connection.setRequestProperty("Range", "bytes=" + offset + "-");
}
if (timeout > 0) {
connection.setConnectTimeout(timeout);
connection.setReadTimeout(timeout);
}
int code = connection.getResponseCode();
redirected = code == HTTP_MOVED_PERM || code == HTTP_MOVED_TEMP || code == HTTP_SEE_OTHER;
if (redirected) {
url = connection.getHeaderField("Location");
redirectCount++;
connection.disconnect();
}
if (redirectCount > MAX_REDIRECTS) {
throw new ProxyCacheException("Too many redirects: " + redirectCount);
}
} while (redirected);
return connection;
}
从以上代码可以看到fetchContentInfo()利用HttpURLConnection获取url的长度和文件类型，默认是"GET"方法，返回了BODY数据，在fetchContentInfo()中，BODY里面的数据根本就没有用到，并且在某些API版本中HttpURLConnection.disconnect()方法会将HttpURLConnection中的数据流读完才会关闭，耗时数秒甚至更长(取决于url指向的文件大小)。而url的length(长度)和mime(文件类型)这两个值是存在Http响应的头部，那么可以使用Http的“HEAD”方法，只返回头部，不需要BODY，既可以提高响应速度也可以减少网络流量。只需要增加一行代码即可，但是openConnection()方法在其它地方也会用到，因此应该单独为fetchContentInfo()写一个openConnection()方法，如openConnectionForHeader():
private HttpURLConnection openConnectionForHeader(int timeout) throws IOException, ProxyCacheException {
HttpURLConnection connection;
boolean redirected;
int redirectCount = 0;
String url = this.url;
do {
VideoCacheLog.d(LOG_TAG, "Open connection for header to " + url);
connection = (HttpURLConnection) new URL(url).openConnection();
if (timeout > 0) {
connection.setConnectTimeout(timeout);
connection.setReadTimeout(timeout);
}
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.d(LOG_TAG, "Redirect to:" + url);
redirectCount++;
connection.disconnect();
VideoCacheLog.d(LOG_TAG, "Redirect closed:" + url);
}
if (redirectCount > MAX_REDIRECTS) {
throw new ProxyCacheException("Too many redirects: " + redirectCount);
}
} while (redirected);
return connection;
}
2、一般情况下，url对应的长度和文件类型是不会变化的，因此将url的length(长度)和mime(文件类型)加入到缓存，不用每次都打开HttpURLConnection。增加IMimeCache类和UrlMime类：
public interface IMimeCache {
public void putMime(String url,int length,String mime);
public UrlMime getMime(String url);
}
public class UrlMime {
protected int length = Integer.MIN_VALUE;
protected String mime;
public UrlMime(){
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public String getMime() {
return mime;
}
public void setMime(String mime) {
this.mime = mime;
}
}
由HttpProxyCacheServer实现此接口，利用HashMap保存数据，并通过HttpProxyCacheServerClients的构造函数注入IMimeCache，在HttpProxyCacheServerClients.newHttpProxyCache()方法中通过HttpUrlSource的构造函数注入IMimeCache，最后在fetchContentInfo()调用之后将数据缓存，以便下次直接获取缓存。
private void fetchContentInfo() throws ProxyCacheException {
VideoCacheLog.d(LOG_TAG, "Read content info from " + url);
HttpURLConnection urlConnection = null;
InputStream inputStream = null;
try {
urlConnection = openConnectionForHeader(10000);
length = urlConnection.getContentLength();
mime = urlConnection.getContentType();
//将数据放入缓存
tryPutMimeCache();
inputStream = urlConnection.getInputStream();
VideoCacheLog.i(LOG_TAG, "Content info for `" + url + "`: mime: " + mime + ", content-length: " + length);
} catch (IOException e) {
VideoCacheLog.e(LOG_TAG, "Error fetching info from " + url, e);
} finally {
ProxyCacheUtils.close(inputStream);
if (urlConnection != null) {
urlConnection.disconnect();
urlConnection = null ;
}
VideoCacheLog.d(LOG_TAG, "Closed connection from :" + url);
}
}
public synchronized String getMime() throws ProxyCacheException {
if (TextUtils.isEmpty(mime)) {
tryLoadMimeCache();
}
if (TextUtils.isEmpty(mime)) {
fetchContentInfo();
}
return mime;
}
public synchronized int length() throws ProxyCacheException {
if (length == Integer.MIN_VALUE) {
tryLoadMimeCache();
}
if (length == Integer.MIN_VALUE) {
fetchContentInfo();
}
return length;
}
private void tryLoadMimeCache(){
if(mimeCache!=null){
UrlMime urlMime = mimeCache.getMime(url);
if(urlMime!=null && !TextUtils.isEmpty(urlMime.getMime()) && urlMime.getLength()!=Integer.MIN_VALUE){
this.mime = urlMime.getMime();
this.length = urlMime.getLength() ;
}
}
}
private void tryPutMimeCache(){
if(mimeCache!=null){
mimeCache.putMime(url,length,mime);
}
}
3、HttpProxyCache.responseWithoutCache()方法中的bug
对于同一个url，AndroidVideoCache使用同一个HttpProxyCacheServerClients实例，
private HttpProxyCacheServerClients getClients(String url) throws ProxyCacheException {
synchronized (clientsLock) {
HttpProxyCacheServerClients clients = clientsMap.get(url);
if (clients == null) {
clients = new HttpProxyCacheServerClients(this,url, config);
clientsMap.put(url, clients);
}
return clients;
}
}
在HttpProxyCacheServerClients中共享着同一个HttpProxyCache实例，
public void processRequest(GetRequest request, Socket socket) throws ProxyCacheException, IOException {
startProcessRequest();
try {
clientsCount.incrementAndGet();
proxyCache.processRequest(request, socket);
} finally {
finishProcessRequest();
}
}
private synchronized void startProcessRequest() throws ProxyCacheException {
proxyCache = proxyCache == null ? newHttpProxyCache() : proxyCache;
}
private HttpProxyCache newHttpProxyCache() throws ProxyCacheException {
HttpUrlSource source = new HttpUrlSource(url);
FileCache cache = new FileCache(config.generateCacheFile(url), config.diskUsage);
HttpProxyCache httpProxyCache = new HttpProxyCache(source, cache);
httpProxyCache.registerCacheListener(uiCacheListener);
return httpProxyCache;
}
当MediaPlayer有多个请求时，HttpProxyCache.processRequest()方法会分别运行在多个线程中，在HttpProxyCache.responseWithoutCache()方法的finally语句块则会导致其他线程ProxyCache.readSource()方法出错。
private void responseWithoutCache(OutputStream out, long offset) throws ProxyCacheException, IOException {
try {
HttpUrlSource source = new HttpUrlSource(this.source);
source.open((int) offset);
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int readBytes;
while ((readBytes = source.read(buffer)) != -1) {
out.write(buffer, 0, readBytes);
offset += readBytes;
}
out.flush();
} finally {
source.close();
}
}
情况是：如果此时有另外一个线程执行的是HttpProxyCache.responseWithCache()，
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();
}
那么就会进入到HttpProxyCache的父类ProxyCache.read(byte[] buffer, long offset, int length)方法中，
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;
}
然后会执行到ProxyCache.readSource()方法中，
private void readSource() {
int sourceAvailable = -1;
int 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();
} catch (Throwable e) {
readSourceErrorsCount.incrementAndGet();
onError(e);
} finally {
closeSource();
notifyNewCacheDataAvailable(offset, sourceAvailable);
}
}
而此时HttpProxyCache.responseWithoutCache()方法中的source.close()则会导致父类ProxyCache中的source被close，从而导致ProxyCache.readSource()方法抛出异常，进而导致MediaPlayer的一个请求线程出错，最后的结果是MediaPlayer出错，触发OnErrorListener。解决办法则是修改HttpProxyCache.responseWithoutCache()方法，关闭try语句块中的source。
4、由于HttpURLConnection.disconnect()耗时太久导致HttpUrlSource.fetchContentInfo()耗时过长
使用了"HEAD"方法代替"GET"方法后，在一些Android手机上HttpURLConnection.disconnect()方法仍然耗时太久，进行导致MediaPlayer要等待很久才会开始播放，因此决定使用okhttp替换HttpURLConnection。
增加一个抽象类UrlSource继承Source类，使之前的HttpUrlSource和新增的OkHttpSource继承UrlSource，这样使得HttpURLConnection和okhttp同时存在，并且可以随时切换。
public abstract class UrlSource implements Source{
protected String url;
protected volatile int length = Integer.MIN_VALUE;
protected volatile String mime;
public UrlSource(String url){
this.url = url ;
}
public UrlSource(UrlSource urlSource){
this.url = urlSource.url;
this.length = urlSource.length;
this.mime = urlSource.mime ;
}
public abstract String getMime() throws ProxyCacheException;
@Override
public String toString() {
return "UrlSource{" +
"url='" + url + '\'' +
", length=" + length +
", mime='" + mime + '\'' +
'}';
}
}
OkHttpSource代码如下：
public class OkHttpSource extends UrlSource{
private static final int MAX_REDIRECTS = 5;
//
private IMimeCache mimeCache ;
private OkHttpClient httpClient = new OkHttpClient();
private InputStream inputStream;
public OkHttpSource(IMimeCache mimeCache,String url) {
super(url);
this.mimeCache = mimeCache ;
}
public OkHttpSource(UrlSource urlSource){
super(urlSource);
}
@Override
public int length() throws ProxyCacheException {
if (length == Integer.MIN_VALUE) {
tryLoadMimeCache();
}
if (length == Integer.MIN_VALUE) {
fetchContentInfo();
}
return length;
}
@Override
public String getMime() throws ProxyCacheException {
if (TextUtils.isEmpty(mime)) {
tryLoadMimeCache();
}
if (TextUtils.isEmpty(mime)) {
fetchContentInfo();
}
return mime;
}
@Override
public void open(int offset) throws ProxyCacheException {
try {
Response response = openConnection(offset, -1);
mime = response.body().contentType().toString();
length = readSourceAvailableBytes(response, offset);
inputStream = new BufferedInputStream(response.body().byteStream(), DEFAULT_BUFFER_SIZE);
} catch (IOException e) {
throw new ProxyCacheException("Error opening connection for " + url + " with offset " + offset, e);
}
}
private int readSourceAvailableBytes(Response response, int offset) throws IOException {
int responseCode = response.code() ;
int contentLength = (int) response.body().contentLength();
return responseCode == HTTP_OK ? contentLength
: responseCode == HTTP_PARTIAL ? contentLength + offset : length;
}
@Override
public int read(byte[] buffer) throws ProxyCacheException {
if (inputStream == null) {
throw new ProxyCacheException("Error reading data from " + url + ": connection 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);
}
}
@Override
public void close() throws ProxyCacheException {
ProxyCacheUtils.close(inputStream);
}
private void fetchContentInfo() throws ProxyCacheException {
VideoCacheLog.d(LOG_TAG, "Read content info from " + url);
Response response = null ;
try {
response = openConnectionForHeader(10000);
if(response==null || !response.isSuccessful()){
throw new ProxyCacheException("Fail to fetchContentInfo: " + url);
}
length = (int) response.body().contentLength();
mime = response.body().contentType().toString();
tryPutMimeCache();
VideoCacheLog.i(LOG_TAG, "Content info for `" + url + "`: mime: " + mime + ", content-length: " + length);
} catch (IOException e) {
VideoCacheLog.e(LOG_TAG, "Error fetching info from " + url, e);
} finally {
VideoCacheLog.d(LOG_TAG, "Closed connection from :" + url);
}
}
private Response openConnectionForHeader(int timeout) throws IOException, ProxyCacheException {
if(timeout>0){
httpClient.setConnectTimeout(timeout, TimeUnit.MILLISECONDS);
httpClient.setReadTimeout(timeout, TimeUnit.MILLISECONDS);
httpClient.setWriteTimeout(timeout, TimeUnit.MILLISECONDS);
}
Response response ;
boolean isRedirect = false;
String newUrl = this.url ;
int redirectCount = 0;
do {
Request request = new Request.Builder()
.head()
.url(newUrl)
.build();
response = httpClient.newCall(request).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 ;
}
private Response openConnection(int offset,int timeout) throws IOException, ProxyCacheException {
if(timeout>0){
httpClient.setConnectTimeout(timeout, TimeUnit.MILLISECONDS);
httpClient.setReadTimeout(timeout, TimeUnit.MILLISECONDS);
httpClient.setWriteTimeout(timeout, TimeUnit.MILLISECONDS);
}
Response response ;
boolean isRedirect = false;
String newUrl = this.url ;
int redirectCount = 0;
do {
VideoCacheLog.d(LOG_TAG, "Open connection" + (offset > 0 ? " with offset " + offset : "") + " to " + url);
Request.Builder requestBuilder = new Request.Builder();
requestBuilder.get();
requestBuilder.url(newUrl);
if (offset > 0) {
requestBuilder.addHeader("Range", "bytes=" + offset + "-");
}
response = httpClient.newCall(requestBuilder.build()).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 ;
}
private void tryLoadMimeCache(){
if(mimeCache!=null){
UrlMime urlMime = mimeCache.getMime(url);
if(urlMime!=null && !TextUtils.isEmpty(urlMime.getMime()) && urlMime.getLength()!=Integer.MIN_VALUE){
this.mime = urlMime.getMime();
this.length = urlMime.getLength() ;
}
}
}
private void tryPutMimeCache(){
if(mimeCache!=null){
mimeCache.putMime(url,length,mime);
}
}
}
最后将之前使用HttpUrlSource的地方替换为OkHttpSource即可。测试之后发现使用okhttp确实避免了MediaPlayer要等待很久才会开始播放的问题。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
