/* * Copyright (C) 2006 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 android.webkit; import android.content.Context; import android.net.http.AndroidHttpClient; import android.net.http.Headers; import android.os.FileUtils; import android.util.Log; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FilenameFilter; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.List; import java.util.Map; import com.android.org.bouncycastle.crypto.Digest; import com.android.org.bouncycastle.crypto.digests.SHA1Digest; /** * The class CacheManager provides the persistent cache of content that is * received over the network. The component handles parsing of HTTP headers and * utilizes the relevant cache headers to determine if the content should be * stored and if so, how long it is valid for. Network requests are provided to * this component and if they can not be resolved by the cache, the HTTP headers * are attached, as appropriate, to the request for revalidation of content. The * class also manages the cache size. * * CacheManager may only be used if your activity contains a WebView. * * @deprecated Access to the HTTP cache will be removed in a future release. */ @Deprecated public final class CacheManager { private static final String LOGTAG = "cache"; static final String HEADER_KEY_IFMODIFIEDSINCE = "if-modified-since"; static final String HEADER_KEY_IFNONEMATCH = "if-none-match"; private static final String NO_STORE = "no-store"; private static final String NO_CACHE = "no-cache"; private static final String MAX_AGE = "max-age"; private static final String MANIFEST_MIME = "text/cache-manifest"; private static long CACHE_THRESHOLD = 6 * 1024 * 1024; private static long CACHE_TRIM_AMOUNT = 2 * 1024 * 1024; // Limit the maximum cache file size to half of the normal capacity static long CACHE_MAX_SIZE = (CACHE_THRESHOLD - CACHE_TRIM_AMOUNT) / 2; private static boolean mDisabled; // Reference count the enable/disable transaction private static int mRefCount; // trimCacheIfNeeded() is called when a page is fully loaded. But JavaScript // can load the content, e.g. in a slideshow, continuously, so we need to // trim the cache on a timer base too. endCacheTransaction() is called on a // timer base. We share the same timer with less frequent update. private static int mTrimCacheCount = 0; private static final int TRIM_CACHE_INTERVAL = 5; private static WebViewDatabase mDataBase; private static File mBaseDir; // Flag to clear the cache when the CacheManager is initialized private static boolean mClearCacheOnInit = false; /** * This class represents a resource retrieved from the HTTP cache. * Instances of this class can be obtained by invoking the * CacheManager.getCacheFile() method. * * @deprecated Access to the HTTP cache will be removed in a future release. */ @Deprecated public static class CacheResult { // these fields are saved to the database int httpStatusCode; long contentLength; long expires; String expiresString; String localPath; String lastModified; String etag; String mimeType; String location; String encoding; String contentdisposition; String crossDomain; // these fields are NOT saved to the database InputStream inStream; OutputStream outStream; File outFile; public int getHttpStatusCode() { return httpStatusCode; } public long getContentLength() { return contentLength; } public String getLocalPath() { return localPath; } public long getExpires() { return expires; } public String getExpiresString() { return expiresString; } public String getLastModified() { return lastModified; } public String getETag() { return etag; } public String getMimeType() { return mimeType; } public String getLocation() { return location; } public String getEncoding() { return encoding; } public String getContentDisposition() { return contentdisposition; } // For out-of-package access to the underlying streams. public InputStream getInputStream() { return inStream; } public OutputStream getOutputStream() { return outStream; } // These fields can be set manually. public void setInputStream(InputStream stream) { this.inStream = stream; } public void setEncoding(String encoding) { this.encoding = encoding; } /** * @hide */ public void setContentLength(long contentLength) { this.contentLength = contentLength; } } /** * Initialize the CacheManager. * * Note that this is called automatically when a {@link android.webkit.WebView} is created. * * @param context The application context. */ static void init(Context context) { if (JniUtil.useChromiumHttpStack()) { // This isn't actually where the real cache lives, but where we put files for the // purpose of getCacheFile(). mBaseDir = new File(context.getCacheDir(), "webviewCacheChromiumStaging"); if (!mBaseDir.exists()) { mBaseDir.mkdirs(); } return; } mDataBase = WebViewDatabase.getInstance(context.getApplicationContext()); mBaseDir = new File(context.getCacheDir(), "webviewCache"); if (createCacheDirectory() && mClearCacheOnInit) { removeAllCacheFiles(); mClearCacheOnInit = false; } } /** * Create the cache directory if it does not already exist. * * @return true if the cache directory didn't exist and was created. */ static private boolean createCacheDirectory() { assert !JniUtil.useChromiumHttpStack(); if (!mBaseDir.exists()) { if(!mBaseDir.mkdirs()) { Log.w(LOGTAG, "Unable to create webviewCache directory"); return false; } FileUtils.setPermissions( mBaseDir.toString(), FileUtils.S_IRWXU | FileUtils.S_IRWXG, -1, -1); // If we did create the directory, we need to flush // the cache database. The directory could be recreated // because the system flushed all the data/cache directories // to free up disk space. // delete rows in the cache database WebViewWorker.getHandler().sendEmptyMessage( WebViewWorker.MSG_CLEAR_CACHE); return true; } return false; } /** * Get the base directory of the cache. Together with the local path of the CacheResult, * obtained from {@link android.webkit.CacheManager.CacheResult#getLocalPath}, this * identifies the cache file. * * Cache files are not guaranteed to be in this directory before * CacheManager#getCacheFile(String, Map) is called. * * @return File The base directory of the cache. * * @deprecated Access to the HTTP cache will be removed in a future release. */ @Deprecated public static File getCacheFileBaseDir() { return mBaseDir; } /** * Sets whether the cache is disabled. * * @param disabled Whether the cache should be disabled */ static void setCacheDisabled(boolean disabled) { assert !JniUtil.useChromiumHttpStack(); if (disabled == mDisabled) { return; } mDisabled = disabled; if (mDisabled) { removeAllCacheFiles(); } } /** * Whether the cache is disabled. * * @return return Whether the cache is disabled * * @deprecated Access to the HTTP cache will be removed in a future release. */ @Deprecated public static boolean cacheDisabled() { return mDisabled; } // only called from WebViewWorkerThread // make sure to call enableTransaction/disableTransaction in pair static boolean enableTransaction() { assert !JniUtil.useChromiumHttpStack(); if (++mRefCount == 1) { mDataBase.startCacheTransaction(); return true; } return false; } // only called from WebViewWorkerThread // make sure to call enableTransaction/disableTransaction in pair static boolean disableTransaction() { assert !JniUtil.useChromiumHttpStack(); if (--mRefCount == 0) { mDataBase.endCacheTransaction(); return true; } return false; } // only called from WebViewWorkerThread // make sure to call startTransaction/endTransaction in pair static boolean startTransaction() { assert !JniUtil.useChromiumHttpStack(); return mDataBase.startCacheTransaction(); } // only called from WebViewWorkerThread // make sure to call startTransaction/endTransaction in pair static boolean endTransaction() { assert !JniUtil.useChromiumHttpStack(); boolean ret = mDataBase.endCacheTransaction(); if (++mTrimCacheCount >= TRIM_CACHE_INTERVAL) { mTrimCacheCount = 0; trimCacheIfNeeded(); } return ret; } // only called from WebCore Thread // make sure to call startCacheTransaction/endCacheTransaction in pair /** * @deprecated Always returns false. */ @Deprecated public static boolean startCacheTransaction() { return false; } // only called from WebCore Thread // make sure to call startCacheTransaction/endCacheTransaction in pair /** * @deprecated Always returns false. */ @Deprecated public static boolean endCacheTransaction() { return false; } /** * Given a URL, returns the corresponding CacheResult if it exists, or null otherwise. * * The input stream of the CacheEntry object is initialized and opened and should be closed by * the caller when access to the underlying file is no longer required. * If a non-zero value is provided for the headers map, and the cache entry needs validation, * HEADER_KEY_IFNONEMATCH or HEADER_KEY_IFMODIFIEDSINCE will be set in headers. * * @return The CacheResult for the given URL * * @deprecated Access to the HTTP cache will be removed in a future release. */ @Deprecated public static CacheResult getCacheFile(String url, Map headers) { return getCacheFile(url, 0, headers); } static CacheResult getCacheFile(String url, long postIdentifier, Map headers) { if (mDisabled) { return null; } if (JniUtil.useChromiumHttpStack()) { CacheResult result = nativeGetCacheResult(url); if (result == null) { return null; } // A temporary local file will have been created native side and localPath set // appropriately. File src = new File(mBaseDir, result.localPath); try { // Open the file here so that even if it is deleted, the content // is still readable by the caller until close() is called. result.inStream = new FileInputStream(src); } catch (FileNotFoundException e) { Log.v(LOGTAG, "getCacheFile(): Failed to open file: " + e); // TODO: The files in the cache directory can be removed by the // system. If it is gone, what should we do? return null; } return result; } String databaseKey = getDatabaseKey(url, postIdentifier); CacheResult result = mDataBase.getCache(databaseKey); if (result == null) { return null; } if (result.contentLength == 0) { if (!isCachableRedirect(result.httpStatusCode)) { // This should not happen. If it does, remove it. mDataBase.removeCache(databaseKey); return null; } } else { File src = new File(mBaseDir, result.localPath); try { // Open the file here so that even if it is deleted, the content // is still readable by the caller until close() is called. result.inStream = new FileInputStream(src); } catch (FileNotFoundException e) { // The files in the cache directory can be removed by the // system. If it is gone, clean up the database. mDataBase.removeCache(databaseKey); return null; } } // A null value for headers is used by CACHE_MODE_CACHE_ONLY to imply // that we should provide the cache result even if it is expired. // Note that a negative expires value means a time in the far future. if (headers != null && result.expires >= 0 && result.expires <= System.currentTimeMillis()) { if (result.lastModified == null && result.etag == null) { return null; } // Return HEADER_KEY_IFNONEMATCH or HEADER_KEY_IFMODIFIEDSINCE // for requesting validation. if (result.etag != null) { headers.put(HEADER_KEY_IFNONEMATCH, result.etag); } if (result.lastModified != null) { headers.put(HEADER_KEY_IFMODIFIEDSINCE, result.lastModified); } } if (DebugFlags.CACHE_MANAGER) { Log.v(LOGTAG, "getCacheFile for url " + url); } return result; } /** * Given a url and its full headers, returns CacheResult if a local cache * can be stored. Otherwise returns null. The mimetype is passed in so that * the function can use the mimetype that will be passed to WebCore which * could be different from the mimetype defined in the headers. * forceCache is for out-of-package callers to force creation of a * CacheResult, and is used to supply surrogate responses for URL * interception. * @return CacheResult for a given url * @hide - hide createCacheFile since it has a parameter of type headers, which is * in a hidden package. * * @deprecated Access to the HTTP cache will be removed in a future release. */ @Deprecated public static CacheResult createCacheFile(String url, int statusCode, Headers headers, String mimeType, boolean forceCache) { if (JniUtil.useChromiumHttpStack()) { // This method is public but hidden. We break functionality. return null; } return createCacheFile(url, statusCode, headers, mimeType, 0, forceCache); } static CacheResult createCacheFile(String url, int statusCode, Headers headers, String mimeType, long postIdentifier, boolean forceCache) { assert !JniUtil.useChromiumHttpStack(); if (!forceCache && mDisabled) { return null; } String databaseKey = getDatabaseKey(url, postIdentifier); // according to the rfc 2616, the 303 response MUST NOT be cached. if (statusCode == 303) { // remove the saved cache if there is any mDataBase.removeCache(databaseKey); return null; } // like the other browsers, do not cache redirects containing a cookie // header. if (isCachableRedirect(statusCode) && !headers.getSetCookie().isEmpty()) { // remove the saved cache if there is any mDataBase.removeCache(databaseKey); return null; } CacheResult ret = parseHeaders(statusCode, headers, mimeType); if (ret == null) { // this should only happen if the headers has "no-store" in the // cache-control. remove the saved cache if there is any mDataBase.removeCache(databaseKey); } else { setupFiles(databaseKey, ret); try { ret.outStream = new FileOutputStream(ret.outFile); } catch (FileNotFoundException e) { // This can happen with the system did a purge and our // subdirectory has gone, so lets try to create it again if (createCacheDirectory()) { try { ret.outStream = new FileOutputStream(ret.outFile); } catch (FileNotFoundException e2) { // We failed to create the file again, so there // is something else wrong. Return null. return null; } } else { // Failed to create cache directory return null; } } ret.mimeType = mimeType; } return ret; } /** * Save the info of a cache file for a given url to the CacheMap so that it * can be reused later * * @deprecated Access to the HTTP cache will be removed in a future release. */ @Deprecated public static void saveCacheFile(String url, CacheResult cacheRet) { saveCacheFile(url, 0, cacheRet); } static void saveCacheFile(String url, long postIdentifier, CacheResult cacheRet) { try { cacheRet.outStream.close(); } catch (IOException e) { return; } if (JniUtil.useChromiumHttpStack()) { // This method is exposed in the public API but the API provides no way to obtain a // new CacheResult object with a non-null output stream ... // - CacheResult objects returned by getCacheFile() have a null output stream. // - new CacheResult objects have a null output stream and no setter is provided. // Since for the Android HTTP stack this method throws a null pointer exception in this // case, this method is effectively useless from the point of view of the public API. // We should already have thrown an exception above, to maintain 'backward // compatibility' with the Android HTTP stack. assert false; } if (!cacheRet.outFile.exists()) { // the file in the cache directory can be removed by the system return; } boolean redirect = isCachableRedirect(cacheRet.httpStatusCode); if (redirect) { // location is in database, no need to keep the file cacheRet.contentLength = 0; cacheRet.localPath = ""; } if ((redirect || cacheRet.contentLength == 0) && !cacheRet.outFile.delete()) { Log.e(LOGTAG, cacheRet.outFile.getPath() + " delete failed."); } if (cacheRet.contentLength == 0) { return; } mDataBase.addCache(getDatabaseKey(url, postIdentifier), cacheRet); if (DebugFlags.CACHE_MANAGER) { Log.v(LOGTAG, "saveCacheFile for url " + url); } } static boolean cleanupCacheFile(CacheResult cacheRet) { assert !JniUtil.useChromiumHttpStack(); try { cacheRet.outStream.close(); } catch (IOException e) { return false; } return cacheRet.outFile.delete(); } /** * Remove all cache files. * * @return Whether the removal succeeded. */ static boolean removeAllCacheFiles() { // Note, this is called before init() when the database is // created or upgraded. if (mBaseDir == null) { // This method should not be called before init() when using the // chrome http stack assert !JniUtil.useChromiumHttpStack(); // Init() has not been called yet, so just flag that // we need to clear the cache when init() is called. mClearCacheOnInit = true; return true; } // delete rows in the cache database if (!JniUtil.useChromiumHttpStack()) WebViewWorker.getHandler().sendEmptyMessage(WebViewWorker.MSG_CLEAR_CACHE); // delete cache files in a separate thread to not block UI. final Runnable clearCache = new Runnable() { public void run() { // delete all cache files try { String[] files = mBaseDir.list(); // if mBaseDir doesn't exist, files can be null. if (files != null) { for (int i = 0; i < files.length; i++) { File f = new File(mBaseDir, files[i]); if (!f.delete()) { Log.e(LOGTAG, f.getPath() + " delete failed."); } } } } catch (SecurityException e) { // Ignore SecurityExceptions. } } }; new Thread(clearCache).start(); return true; } static void trimCacheIfNeeded() { assert !JniUtil.useChromiumHttpStack(); if (mDataBase.getCacheTotalSize() > CACHE_THRESHOLD) { List pathList = mDataBase.trimCache(CACHE_TRIM_AMOUNT); int size = pathList.size(); for (int i = 0; i < size; i++) { File f = new File(mBaseDir, pathList.get(i)); if (!f.delete()) { Log.e(LOGTAG, f.getPath() + " delete failed."); } } // remove the unreferenced files in the cache directory final List fileList = mDataBase.getAllCacheFileNames(); if (fileList == null) return; String[] toDelete = mBaseDir.list(new FilenameFilter() { public boolean accept(File dir, String filename) { if (fileList.contains(filename)) { return false; } else { return true; } } }); if (toDelete == null) return; size = toDelete.length; for (int i = 0; i < size; i++) { File f = new File(mBaseDir, toDelete[i]); if (!f.delete()) { Log.e(LOGTAG, f.getPath() + " delete failed."); } } } } static void clearCache() { assert !JniUtil.useChromiumHttpStack(); // delete database mDataBase.clearCache(); } private static boolean isCachableRedirect(int statusCode) { if (statusCode == 301 || statusCode == 302 || statusCode == 307) { // as 303 can't be cached, we do not return true return true; } else { return false; } } private static String getDatabaseKey(String url, long postIdentifier) { assert !JniUtil.useChromiumHttpStack(); if (postIdentifier == 0) return url; return postIdentifier + url; } @SuppressWarnings("deprecation") private static void setupFiles(String url, CacheResult cacheRet) { assert !JniUtil.useChromiumHttpStack(); if (true) { // Note: SHA1 is much stronger hash. But the cost of setupFiles() is // 3.2% cpu time for a fresh load of nytimes.com. While a simple // String.hashCode() is only 0.6%. If adding the collision resolving // to String.hashCode(), it makes the cpu time to be 1.6% for a // fresh load, but 5.3% for the worst case where all the files // already exist in the file system, but database is gone. So it // needs to resolve collision for every file at least once. int hashCode = url.hashCode(); StringBuffer ret = new StringBuffer(8); appendAsHex(hashCode, ret); String path = ret.toString(); File file = new File(mBaseDir, path); if (true) { boolean checkOldPath = true; // Check hash collision. If the hash file doesn't exist, just // continue. There is a chance that the old cache file is not // same as the hash file. As mDataBase.getCache() is more // expansive than "leak" a file until clear cache, don't bother. // If the hash file exists, make sure that it is same as the // cache file. If it is not, resolve the collision. while (file.exists()) { if (checkOldPath) { CacheResult oldResult = mDataBase.getCache(url); if (oldResult != null && oldResult.contentLength > 0) { if (path.equals(oldResult.localPath)) { path = oldResult.localPath; } else { path = oldResult.localPath; file = new File(mBaseDir, path); } break; } checkOldPath = false; } ret = new StringBuffer(8); appendAsHex(++hashCode, ret); path = ret.toString(); file = new File(mBaseDir, path); } } cacheRet.localPath = path; cacheRet.outFile = file; } else { // get hash in byte[] Digest digest = new SHA1Digest(); int digestLen = digest.getDigestSize(); byte[] hash = new byte[digestLen]; int urlLen = url.length(); byte[] data = new byte[urlLen]; url.getBytes(0, urlLen, data, 0); digest.update(data, 0, urlLen); digest.doFinal(hash, 0); // convert byte[] to hex String StringBuffer result = new StringBuffer(2 * digestLen); for (int i = 0; i < digestLen; i = i + 4) { int h = (0x00ff & hash[i]) << 24 | (0x00ff & hash[i + 1]) << 16 | (0x00ff & hash[i + 2]) << 8 | (0x00ff & hash[i + 3]); appendAsHex(h, result); } cacheRet.localPath = result.toString(); cacheRet.outFile = new File(mBaseDir, cacheRet.localPath); } } private static void appendAsHex(int i, StringBuffer ret) { assert !JniUtil.useChromiumHttpStack(); String hex = Integer.toHexString(i); switch (hex.length()) { case 1: ret.append("0000000"); break; case 2: ret.append("000000"); break; case 3: ret.append("00000"); break; case 4: ret.append("0000"); break; case 5: ret.append("000"); break; case 6: ret.append("00"); break; case 7: ret.append("0"); break; } ret.append(hex); } private static CacheResult parseHeaders(int statusCode, Headers headers, String mimeType) { assert !JniUtil.useChromiumHttpStack(); // if the contentLength is already larger than CACHE_MAX_SIZE, skip it if (headers.getContentLength() > CACHE_MAX_SIZE) return null; // The HTML 5 spec, section 6.9.4, step 7.3 of the application cache // process states that HTTP caching rules are ignored for the // purposes of the application cache download process. // At this point we can't tell that if a file is part of this process, // except for the manifest, which has its own mimeType. // TODO: work out a way to distinguish all responses that are part of // the application download process and skip them. if (MANIFEST_MIME.equals(mimeType)) return null; // TODO: if authenticated or secure, return null CacheResult ret = new CacheResult(); ret.httpStatusCode = statusCode; ret.location = headers.getLocation(); ret.expires = -1; ret.expiresString = headers.getExpires(); if (ret.expiresString != null) { try { ret.expires = AndroidHttpClient.parseDate(ret.expiresString); } catch (IllegalArgumentException ex) { // Take care of the special "-1" and "0" cases if ("-1".equals(ret.expiresString) || "0".equals(ret.expiresString)) { // make it expired, but can be used for history navigation ret.expires = 0; } else { Log.e(LOGTAG, "illegal expires: " + ret.expiresString); } } } ret.contentdisposition = headers.getContentDisposition(); ret.crossDomain = headers.getXPermittedCrossDomainPolicies(); // lastModified and etag may be set back to http header. So they can't // be empty string. String lastModified = headers.getLastModified(); if (lastModified != null && lastModified.length() > 0) { ret.lastModified = lastModified; } String etag = headers.getEtag(); if (etag != null && etag.length() > 0) { ret.etag = etag; } String cacheControl = headers.getCacheControl(); if (cacheControl != null) { String[] controls = cacheControl.toLowerCase().split("[ ,;]"); boolean noCache = false; for (int i = 0; i < controls.length; i++) { if (NO_STORE.equals(controls[i])) { return null; } // According to the spec, 'no-cache' means that the content // must be re-validated on every load. It does not mean that // the content can not be cached. set to expire 0 means it // can only be used in CACHE_MODE_CACHE_ONLY case if (NO_CACHE.equals(controls[i])) { ret.expires = 0; noCache = true; // if cache control = no-cache has been received, ignore max-age // header, according to http spec: // If a request includes the no-cache directive, it SHOULD NOT // include min-fresh, max-stale, or max-age. } else if (controls[i].startsWith(MAX_AGE) && !noCache) { int separator = controls[i].indexOf('='); if (separator < 0) { separator = controls[i].indexOf(':'); } if (separator > 0) { String s = controls[i].substring(separator + 1); try { long sec = Long.parseLong(s); if (sec >= 0) { ret.expires = System.currentTimeMillis() + 1000 * sec; } } catch (NumberFormatException ex) { if ("1d".equals(s)) { // Take care of the special "1d" case ret.expires = System.currentTimeMillis() + 86400000; // 24*60*60*1000 } else { Log.e(LOGTAG, "exception in parseHeaders for " + "max-age:" + controls[i].substring(separator + 1)); ret.expires = 0; } } } } } } // According to RFC 2616 section 14.32: // HTTP/1.1 caches SHOULD treat "Pragma: no-cache" as if the // client had sent "Cache-Control: no-cache" if (NO_CACHE.equals(headers.getPragma())) { ret.expires = 0; } // According to RFC 2616 section 13.2.4, if an expiration has not been // explicitly defined a heuristic to set an expiration may be used. if (ret.expires == -1) { if (ret.httpStatusCode == 301) { // If it is a permanent redirect, and it did not have an // explicit cache directive, then it never expires ret.expires = Long.MAX_VALUE; } else if (ret.httpStatusCode == 302 || ret.httpStatusCode == 307) { // If it is temporary redirect, expires ret.expires = 0; } else if (ret.lastModified == null) { // When we have no last-modified, then expire the content with // in 24hrs as, according to the RFC, longer time requires a // warning 113 to be added to the response. // Only add the default expiration for non-html markup. Some // sites like news.google.com have no cache directives. if (!mimeType.startsWith("text/html")) { ret.expires = System.currentTimeMillis() + 86400000; // 24*60*60*1000 } else { // Setting a expires as zero will cache the result for // forward/back nav. ret.expires = 0; } } else { // If we have a last-modified value, we could use it to set the // expiration. Suggestion from RFC is 10% of time since // last-modified. As we are on mobile, loads are expensive, // increasing this to 20%. // 24 * 60 * 60 * 1000 long lastmod = System.currentTimeMillis() + 86400000; try { lastmod = AndroidHttpClient.parseDate(ret.lastModified); } catch (IllegalArgumentException ex) { Log.e(LOGTAG, "illegal lastModified: " + ret.lastModified); } long difference = System.currentTimeMillis() - lastmod; if (difference > 0) { ret.expires = System.currentTimeMillis() + difference / 5; } else { // last modified is in the future, expire the content // on the last modified ret.expires = lastmod; } } } return ret; } private static native CacheResult nativeGetCacheResult(String url); }