1.AndroidHttpClient的创建
DownloadManager:
在DownloadThread的run方法里
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//从DownloadInfo转化成State
State state = new State(mInfo);
AndroidHttpClient client = null;
PowerManager.WakeLock wakeLock = null;
int finalStatus = Downloads.STATUS_UNKNOWN_ERROR;
try {
//阻止后台休眠
PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, Constants.TAG);
wakeLock.acquire();
if (Constants.LOGV) {
Log.v(Constants.TAG, "initiating download for " + mInfo.mUri);
}
client = AndroidHttpClient.newInstance(userAgent(), mContext);
userAgent方法，如果DownloadInfo中有设置ua就用设置了的UA,没有就用默认的"AndroidDownloadManager“
/**
* Returns the user agent provided by the initiating app, or use the default one
*/
private String userAgent() {
String userAgent = mInfo.mUserAgent;
if (userAgent != null) {
}
if (userAgent == null) {
userAgent = Constants.DEFAULT_USER_AGENT;
}
return userAgent;
}
Volley:
Volley中的HttpClient创建是在请求线程发出前，如果获取包名异常则使用"volley/0"作为ua，如果SDK版本大于9就用HttpUrlStack
String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException e) {
} if (stack == null) {
if (Build.VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
// Prior to Gingerbread, HttpUrlConnection was unreliable.
// See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
Volley是根据SDK版本区分，2.3之后用Hurl之前就用AndroidHttpClient，Hurl在后面的版本支持gzip和请求缓存。
2.performRequest执行请求
由于DownloadManager是用HttpClient和HttpGet来执行请求的，所以获取到一个HttpResponse，然后得到一个输入流，然后把流读出来写入到一个文件。
DM:
DownloadThread中run方法，executeDownload执行下载
boolean finished = false;
while (!finished) {
Log.i(Constants.TAG, "Initiating request for download " + mInfo.mId);
HttpGet request = new HttpGet(state.mRequestUri);
try {
//执行下载
executeDownload(state, client, request);
finished = true;
} catch (RetryDownload exc) {
// fall through
} finally {
request.abort();
request = null;
}
}
请求过程，设置目标文件，添加请求头（断点续传），检查网络，发送请求，处理异常Http状态码，获取输入流转移数据到目标文件。
setupDestinationFile(state, innerState);
addRequestHeaders(innerState, request); // check just before sending the request to avoid using an invalid
// connection at all
checkConnectivity(state);//发起请求检查连接 //发送请求获取Response
HttpResponse response = sendRequest(state, client, request);
handleExceptionalStatus(state, innerState, response); if (Constants.LOGV) {
Log.v(Constants.TAG, "received response for " + mInfo.mUri);
} processResponseHeaders(state, innerState, response);
//从获取输入流
InputStream entityStream = openResponseEntity(state, response);
//数据读取
transferData(state, innerState, data, entityStream);
Volley：
NetworkDispatch中run方法，请求队列取出一个请求，检查是否需要取消，设置标签，发送请求，获取网络响应，转化为Responces，分发结果
public void run() {
//这里和dm中一样，线程设置为Backgound优先级
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Request<?> request;
while (true) {
try {
// Take a request from the queue.队列中取出一个请求
request = mQueue.take();
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
}
try {
request.addMarker("network-queue-take");
// If the request was cancelled already, do not perform the
// network request.检查是否需要取消
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
continue;
}
addTrafficStatsTag(request);
// Perform the network request.执行网络请求
NetworkResponse networkResponse = mNetwork.performRequest(request);
request.addMarker("network-http-complete");
// If the server returned 304 AND we delivered a response already,
// we're done -- don't deliver a second identical response.
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
continue;
}
// Parse the response here on the worker thread.解析网络响应
Response<?> response = request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete");
// Write to cache if applicable.
// TODO: Only update cache metadata instead of entire record for 304s.
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
// Post the response back.
request.markDelivered();
mDelivery.postResponse(request, response);//分发响应结果
} catch (VolleyError volleyError) {
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
mDelivery.postError(request, new VolleyError(e));
}
}
}
真正的网络请求过程在这个BasicNetwork的performRequest方法，最终返回一个含响应状态码和转成byte数组的结果对象
// Gather headers.获取HTTP头部
Map<String, String> headers = new HashMap<String, String>();
addCacheHeaders(headers, request.getCacheEntry());
httpResponse = mHttpStack.performRequest(request, headers);
StatusLine statusLine = httpResponse.getStatusLine();
int statusCode = statusLine.getStatusCode(); responseHeaders = convertHeaders(httpResponse.getAllHeaders());
// Handle cache validation.处理缓存校验
if (statusCode == HttpStatus.SC_NOT_MODIFIED) {
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED,
request.getCacheEntry() == null ? null : request.getCacheEntry().data,
responseHeaders, true);
} // Some responses such as 204s do not have content. We must check.
if (httpResponse.getEntity() != null) {//把HttpEntity转换成byte数组
responseContents = entityToBytes(httpResponse.getEntity());
} else {
// Add 0 byte response as a way of honestly representing a
// no-content request.
responseContents = new byte[0];
} // if the request is slow, log it.
long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
logSlowRequests(requestLifetime, request, responseContents, statusLine); if (statusCode < 200 || statusCode > 299) {
throw new IOException();
}
//返回一个带状态码和byte数组和响应头部的NetworkResponse对象
returnnew NetworkResponse(statusCode, responseContents, responseHeaders, false);
错了，上面还只是个代理，真正执行请求的还是HttpClient和HttpUrlConnection
先来看HttpClient的：
public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
throws IOException, AuthFailureError {
HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);
addHeaders(httpRequest, additionalHeaders);
addHeaders(httpRequest, request.getHeaders());
onPrepareRequest(httpRequest);
HttpParams httpParams = httpRequest.getParams();
int timeoutMs = request.getTimeoutMs();
// TODO: Reevaluate this connection timeout based on more wide-scale
// data collection and possibly different for wifi vs. 3G.
HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);
return mClient.execute(httpRequest);
}
这个过程其实还是很简单，首先转换头部，然后把Volley中Request转换成Apache的HttpUriRequest，然后调用HttpClient.ececute(HttpUriRequest)方法得到一个HttpResponse
再来看他是怎么把Volley的Request转换成Apache的HttpUriRequest
static HttpUriRequest createHttpRequest(Request<?> request,
Map<String, String> additionalHeaders) throws AuthFailureError {
switch (request.getMethod()) {
case Method.GET://GET不需要设置参数
return new HttpGet(request.getUrl());
case Method.POST: {
HttpPost postRequest = new HttpPost(request.getUrl());
postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
setEntityIfNonEmptyBody(postRequest, request);
return postRequest;
} }
然后设置Entity，Volley内request.getBody()方法返回一个byte数组，把这个数组包装成一个HttpEntity然后就用HttpRequest.setEntity方法设置进去
private static void setEntityIfNonEmptyBody(HttpEntityEnclosingRequestBase httpRequest,
Request<?> request) throws AuthFailureError {
byte[] body = request.getBody();
if (body != null) {
HttpEntity entity = new ByteArrayEntity(body);
httpRequest.setEntity(entity);
}
}
上面都是HttpClient的实现方法，再来看HttpUrlConnection的实现
HurlStack的performRequest方法
String url = request.getUrl();
HashMap<String, String> map = new HashMap<String, String>();
map.putAll(request.getHeaders());
map.putAll(additionalHeaders);
if (mUrlRewriter != null) {
String rewritten = mUrlRewriter.rewriteUrl(url);
if (rewritten == null) {
throw new IOException("URL blocked by rewriter: " + url);
}
url = rewritten;
}
//构建Url
URL parsedUrl = new URL(url);
//打开连接
HttpURLConnection connection = openConnection(parsedUrl, request);
for (String headerName : map.keySet()) {
connection.addRequestProperty(headerName, map.get(headerName));
}
//设置请求方法，Get或Post
setConnectionParametersForRequest(connection, request);
// Initialize HttpResponse with data from the HttpURLConnection.
ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);
int responseCode = connection.getResponseCode();
if (responseCode == -1) {
// -1 is returned by getResponseCode() if the response code could not be retrieved.
// Signal to the caller that something was wrong with the connection.
throw new IOException("Could not retrieve response code from HttpUrlConnection.");
}
//状态码
StatusLine responseStatus = new BasicStatusLine(protocolVersion,
connection.getResponseCode(), connection.getResponseMessage());
BasicHttpResponse response = new BasicHttpResponse(responseStatus);
//实体内容
response.setEntity(entityFromConnection(connection));
for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {
if (header.getKey() != null) {
Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
response.addHeader(h);
}
}
return response;
打开连接的实现方法：
private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {
HttpURLConnection connection = createConnection(url);
int timeoutMs = request.getTimeoutMs();
connection.setConnectTimeout(timeoutMs);
connection.setReadTimeout(timeoutMs);
connection.setUseCaches(false);
connection.setDoInput(true);
// use caller-provided custom SslSocketFactory, if any, for HTTPS
if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
}
return connection;
}
protected HttpURLConnection createConnection(URL url) throws IOException {
return (HttpURLConnection) url.openConnection();
}
Hurl中把获取出来的输入流转换成HttpEntity，setContent(InputStream)，可以看出来Hurl还是转换成Apache的标准
3.IO流数据转移
要实现进度监听也只能在这一步去实现
dm的数据转移在DownloadThread的transferData方法，innerState.mBytesSoFar就是当前进度，onProgress(long progress)把当前进度通知出去
private void transferData(State state, InnerState innerState, byte[] data,
InputStream entityStream) throws StopRequest {
for (;;) {
//读取Response
int bytesRead = readFromResponse(state, innerState, data, entityStream);
if (bytesRead == -1) { // success, end of stream already reached
//读完了去处理
handleEndOfStream(state, innerState);
return;
} state.mGotData = true;
//把byte数组写到目标文件
writeDataToDestination(state, data, bytesRead);
innerState.mBytesSoFar += bytesRead;
reportProgress(state, innerState);//报告下载进度 if (Constants.LOGVV) {
Log.v(Constants.TAG, "downloaded " + innerState.mBytesSoFar + " for " + mInfo.mUri);
} checkPausedOrCanceled(state);
}
}
Volley则是把输入流读到一个byte数组池，只要存在读流的地方就可以射出进度
/** Reads the contents of HttpEntity into a byte[]. */
private byte[] entityToBytes(HttpEntity entity) throws IOException, ServerError {
PoolingByteArrayOutputStream bytes =
new PoolingByteArrayOutputStream(mPool, (int) entity.getContentLength());
byte[] buffer = null;
try {
InputStream in = entity.getContent();
if (in == null) {
throw new ServerError();
}
buffer = mPool.getBuf(1024);
int count;
while ((count = in.read(buffer)) != -1) {
bytes.write(buffer, 0, count);
}
return bytes.toByteArray();
} finally {
try {
// Close the InputStream and release the resources by "consuming the content".
entity.consumeContent();
} catch (IOException e) {
// This can happen if there was an exception above that left the entity in
// an invalid state.
VolleyLog.v("Error occured when calling consumingContent");
}
mPool.returnBuf(buffer);
bytes.close();
}
}
dm从输入流读出来写进FileOutputStream,volley是读到ByteArrayOutputStream，HttpUrlConnection只能得到一个输入流，HttpClient能获取一个HttpEntity，然后可以通过Apache的工具直接转换成要的类型，当然HttpEntity也可以直接获得一个输入流，输入流也可以转成一个HttpEntity，如果用Apache的工具去读的话可能不符合自己想要的效果，还是要自己去继承扩展或者直接读取输入流转换成自己想要的类型。