/// <summary>
/// 初始化缓存
/// </summary>
public void Initialize()
{
lock (this)
{
if (!mRootDirectory.Exists)
{
mRootDirectory.Create();
if (!mRootDirectory.Exists)
{
VolleyLog.E("Unable to create cache dir {0}", mRootDirectory.FullName);
}
return;
}
//获取已缓存文件并添加到缓存表中
FileInfo[] files = mRootDirectory.GetFiles();
if (files == null)
{
return;
}
foreach (FileInfo file in files)
{
FileStream fs = null;
try
{
fs = file.Open(FileMode.OpenOrCreate);
CacheHeader entry = CacheHeader.ReadHeader(fs);
entry.Size = fs.Length;
PutEntry(entry.Key, entry);
}
catch (IOException)
{
if (file != null)
{
file.Delete();
}
}
finally
{
try
{
if (fs != null)
{
fs.Close();
}
}
catch (IOException) { }
}
}
}
}
public override Response ParseNetworkResponse(NetworkResponse response)
{
lock (sDecodeLock)
{
try
{
return(DoParse(response));
}
catch (Java.Lang.OutOfMemoryError e)
{
VolleyLog.E("Caught OOM for {0} byte image,url={1}", response.Data.Length, Url);
return(Response.Error(new ParseError(e)));
}
}
}
/// <summary>
/// 处理请求的核心
/// 不包含底层请求的创建
/// </summary>
public NetworkResponse PerformRequest(Request request)
{
long requestStart = SystemClock.ElapsedRealtime();
while (true)
{
HttpWebResponse httpResponse = null;
byte[] responseContents = null;
Dictionary <String, String> responseHeaders = null;
try
{
Dictionary <String, String> headers = new Dictionary <string, string>();
AddCacheHeaders(headers, request.CacheEntry);
//处理请求
httpResponse = mHttpStack.PerformRequest(request, headers);
var statusCode = httpResponse.StatusCode;
responseHeaders = ConvertHeaders(httpResponse.Headers);
if (statusCode == HttpStatusCode.MovedPermanently || statusCode == HttpStatusCode.Moved)
{
String newUrl = responseHeaders["Location"];
request.SetRedirectUrl(newUrl);
}
//获取请求到的内容
Stream output = httpResponse.GetResponseStream();
if (output != null)
{
responseContents = EntityToBytes(output);
}
else
{
responseContents = new byte[0];
}
long requestLifetime = SystemClock.ElapsedRealtime() - requestStart;
LogSlowRequests(requestLifetime, request, responseContents, statusCode);
if (statusCode < HttpStatusCode.OK || (int)statusCode > 299)
{
throw new IOException();
}
return(new NetworkResponse(statusCode, responseContents, responseHeaders, false,
SystemClock.ElapsedRealtime() - requestStart));
}
catch (WebException ex)
{
if (ex.Response != null)
{
var result = ex.Response as HttpWebResponse;
if (result.StatusCode == HttpStatusCode.NotModified)
{
Entry entry = request.CacheEntry;
if (entry == null)
{
return(new NetworkResponse(HttpStatusCode.NotModified, null,
responseHeaders, true,
SystemClock.ElapsedRealtime() - requestStart));
}
//entry.ResponseHeaders = entry.ResponseHeaders.Intersect(responseHeaders).ToDictionary(x => x.Key, x => x.Value);
return(new NetworkResponse(HttpStatusCode.NotModified, entry.Data,
entry.ResponseHeaders, true,
SystemClock.ElapsedRealtime() - requestStart));
}
}
throw new NetworkError(ex);
}
catch (TimeoutException)
{
AttempRetryOnException("connection", request, new TimeoutError());
}
catch (IOException e)
{
HttpStatusCode statusCode = 0;
NetworkResponse networkResponse = null;
if (httpResponse != null)
{
statusCode = httpResponse.StatusCode;
}
else
{
throw new NoConnectionError(e);
}
if (statusCode == HttpStatusCode.MovedPermanently)
{
VolleyLog.E("Request at {0} has been redirected to {1}", request.OriginUrl, request.Url);
}
else
{
VolleyLog.E("Unexpected response code {0} for {1}", statusCode, request.Url);
}
if (responseContents != null)
{
networkResponse = new NetworkResponse(statusCode, responseContents,
responseHeaders, false, SystemClock.ElapsedRealtime() - requestStart);
if (statusCode == HttpStatusCode.Unauthorized || statusCode == HttpStatusCode.Forbidden)
{
AttempRetryOnException("auth", request, new AuthFailureError());
}
else if (statusCode == HttpStatusCode.MovedPermanently || statusCode == HttpStatusCode.Moved)
{
AttempRetryOnException("redirect", request, new AuthFailureError(networkResponse));
}
else
{
throw new ServerError(networkResponse);
}
}
else
{
throw new NetworkError(networkResponse);
}
}
}
}
public override void Run()
{
Process.SetThreadPriority(ThreadPriority.Background);
while (true)
{
long startTimeMs = SystemClock.ElapsedRealtime();
Request request;
if (!mQueue.TryDequeue(out request))
{
if (mQuit)
{
return;
}
continue;
}
try
{
request.AddMarker("network-queue-take");
if (request.IsCanceled)
{
request.Finish("network-discard-cancelled");
continue;
}
AddTrafficStatsTag(request);
NetworkResponse networkResponse = mNetwork.PerformRequest(request);
request.AddMarker("network-http-complete");
if (networkResponse.NotModified && request.HasHadResponseDelivered())
{
request.Finish("not-modified");
continue;
}
Response response = request.ParseNetworkResponse(networkResponse);
request.AddMarker("network-parse-complete");
if (request.ShouldCache() && response.CacheEntry != null)
{
mCache.Put(request.GetCacheKey(), response.CacheEntry);
request.AddMarker("network-cache-written");
}
request.MarkDelivered();
mDelivery.PostResponse(request, response);
}
catch (VolleyError volleyError)
{
volleyError.NetworkTimeMs = SystemClock.ElapsedRealtime() - startTimeMs;
ParseAndDeliverNetworkError(request, volleyError);
}
catch (Exception e)
{
VolleyLog.E(e, "Unhandled exception {0}", e.ToString());
VolleyError volleyError = new VolleyError(e);
volleyError.NetworkTimeMs = SystemClock.ElapsedRealtime() - startTimeMs;
mDelivery.PostError(request, volleyError);
}
}
}
