138 lines
4.5 KiB
Java
138 lines
4.5 KiB
Java
/*
|
|
* Copyright (C) 2011 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.volley.toolbox;
|
|
|
|
import com.android.volley.Cache;
|
|
import com.android.volley.NetworkResponse;
|
|
|
|
import org.apache.http.impl.cookie.DateParseException;
|
|
import org.apache.http.impl.cookie.DateUtils;
|
|
import org.apache.http.protocol.HTTP;
|
|
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Utility methods for parsing HTTP headers.
|
|
*/
|
|
public class HttpHeaderParser {
|
|
|
|
/**
|
|
* Extracts a {@link Cache.Entry} from a {@link NetworkResponse}.
|
|
*
|
|
* @param response The network response to parse headers from
|
|
* @return a cache entry for the given response, or null if the response is not cacheable.
|
|
*/
|
|
public static Cache.Entry parseCacheHeaders(NetworkResponse response) {
|
|
long now = System.currentTimeMillis();
|
|
|
|
Map<String, String> headers = response.headers;
|
|
|
|
long serverDate = 0;
|
|
long serverExpires = 0;
|
|
long softExpire = 0;
|
|
long maxAge = 0;
|
|
boolean hasCacheControl = false;
|
|
|
|
String serverEtag = null;
|
|
String headerValue;
|
|
|
|
headerValue = headers.get("Date");
|
|
if (headerValue != null) {
|
|
serverDate = parseDateAsEpoch(headerValue);
|
|
}
|
|
|
|
headerValue = headers.get("Cache-Control");
|
|
if (headerValue != null) {
|
|
hasCacheControl = true;
|
|
String[] tokens = headerValue.split(",");
|
|
for (int i = 0; i < tokens.length; i++) {
|
|
String token = tokens[i].trim();
|
|
if (token.equals("no-cache") || token.equals("no-store")) {
|
|
return null;
|
|
} else if (token.startsWith("max-age=")) {
|
|
try {
|
|
maxAge = Long.parseLong(token.substring(8));
|
|
} catch (Exception e) {
|
|
}
|
|
} else if (token.equals("must-revalidate") || token.equals("proxy-revalidate")) {
|
|
maxAge = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
headerValue = headers.get("Expires");
|
|
if (headerValue != null) {
|
|
serverExpires = parseDateAsEpoch(headerValue);
|
|
}
|
|
|
|
serverEtag = headers.get("ETag");
|
|
|
|
// Cache-Control takes precedence over an Expires header, even if both exist and Expires
|
|
// is more restrictive.
|
|
if (hasCacheControl) {
|
|
softExpire = now + maxAge * 1000;
|
|
} else if (serverDate > 0 && serverExpires >= serverDate) {
|
|
// Default semantic for Expire header in HTTP specification is softExpire.
|
|
softExpire = now + (serverExpires - serverDate);
|
|
}
|
|
|
|
Cache.Entry entry = new Cache.Entry();
|
|
entry.data = response.data;
|
|
entry.etag = serverEtag;
|
|
entry.softTtl = softExpire;
|
|
entry.ttl = entry.softTtl;
|
|
entry.serverDate = serverDate;
|
|
entry.responseHeaders = headers;
|
|
|
|
return entry;
|
|
}
|
|
|
|
/**
|
|
* Parse date in RFC1123 format, and return its value as epoch
|
|
*/
|
|
public static long parseDateAsEpoch(String dateStr) {
|
|
try {
|
|
// Parse date in RFC1123 format if this header contains one
|
|
return DateUtils.parseDate(dateStr).getTime();
|
|
} catch (DateParseException e) {
|
|
// Date in invalid format, fallback to 0
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the charset specified in the Content-Type of this header,
|
|
* or the HTTP default (ISO-8859-1) if none can be found.
|
|
*/
|
|
public static String parseCharset(Map<String, String> headers) {
|
|
String contentType = headers.get(HTTP.CONTENT_TYPE);
|
|
if (contentType != null) {
|
|
String[] params = contentType.split(";");
|
|
for (int i = 1; i < params.length; i++) {
|
|
String[] pair = params[i].trim().split("=");
|
|
if (pair.length == 2) {
|
|
if (pair[0].equals("charset")) {
|
|
return pair[1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return HTTP.UTF_8;
|
|
}
|
|
}
|