1/*
2 * Copyright (C) 2015 Square, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package com.squareup.okhttp;
17
18import com.squareup.okhttp.internal.huc.JavaApiConverter;
19
20import java.io.File;
21import java.io.IOException;
22import java.net.CacheRequest;
23import java.net.CacheResponse;
24import java.net.ResponseCache;
25import java.net.URI;
26import java.net.URLConnection;
27import java.util.List;
28import java.util.Map;
29
30/**
31 * A class provided for use by Android so that it can continue supporting a {@link ResponseCache}
32 * with stats.
33 */
34public class AndroidShimResponseCache extends ResponseCache {
35
36  private final Cache delegate;
37
38  private AndroidShimResponseCache(Cache delegate) {
39    this.delegate = delegate;
40  }
41
42  public static AndroidShimResponseCache create(File directory, long maxSize) throws IOException {
43    Cache cache = new Cache(directory, maxSize);
44    return new AndroidShimResponseCache(cache);
45  }
46
47  public boolean isEquivalent(File directory, long maxSize) {
48    Cache installedCache = getCache();
49    return (installedCache.getDirectory().equals(directory)
50        && installedCache.getMaxSize() == maxSize
51        && !installedCache.isClosed());
52  }
53
54  public Cache getCache() {
55    return delegate;
56  }
57
58  @Override public CacheResponse get(URI uri, String requestMethod,
59      Map<String, List<String>> requestHeaders) throws IOException {
60    Request okRequest = JavaApiConverter.createOkRequest(uri, requestMethod, requestHeaders);
61    Response okResponse = delegate.internalCache.get(okRequest);
62    if (okResponse == null) {
63      return null;
64    }
65    return JavaApiConverter.createJavaCacheResponse(okResponse);
66  }
67
68  @Override public CacheRequest put(URI uri, URLConnection urlConnection) throws IOException {
69    Response okResponse = JavaApiConverter.createOkResponseForCachePut(uri, urlConnection);
70    if (okResponse == null) {
71      // The URLConnection is not cacheable or could not be converted. Stop.
72      return null;
73    }
74    com.squareup.okhttp.internal.http.CacheRequest okCacheRequest =
75        delegate.internalCache.put(okResponse);
76    if (okCacheRequest == null) {
77      return null;
78    }
79    return JavaApiConverter.createJavaCacheRequest(okCacheRequest);
80  }
81
82  /**
83   * Returns the number of bytes currently being used to store the values in
84   * this cache. This may be greater than the {@link #maxSize} if a background
85   * deletion is pending.
86   */
87  public long size() throws IOException {
88    return delegate.getSize();
89  }
90
91  /**
92   * Returns the maximum number of bytes that this cache should use to store
93   * its data.
94   */
95  public long maxSize() {
96    return delegate.getMaxSize();
97  }
98
99  /**
100   * Force buffered operations to the filesystem. This ensures that responses
101   * written to the cache will be available the next time the cache is opened,
102   * even if this process is killed.
103   */
104  public void flush() throws IOException {
105    delegate.flush();
106  }
107
108  /**
109   * Returns the number of HTTP requests that required the network to either
110   * supply a response or validate a locally cached response.
111   */
112  public int getNetworkCount() {
113    return delegate.getNetworkCount();
114  }
115
116  /**
117   * Returns the number of HTTP requests whose response was provided by the
118   * cache. This may include conditional {@code GET} requests that were
119   * validated over the network.
120   */
121  public int getHitCount() {
122    return delegate.getHitCount();
123  }
124
125  /**
126   * Returns the total number of HTTP requests that were made. This includes
127   * both client requests and requests that were made on the client's behalf
128   * to handle a redirects and retries.
129   */
130  public int getRequestCount() {
131    return delegate.getRequestCount();
132  }
133
134  /**
135   * Uninstalls the cache and releases any active resources. Stored contents
136   * will remain on the filesystem.
137   */
138  public void close() throws IOException {
139    delegate.close();
140  }
141
142  /**
143   * Uninstalls the cache and deletes all of its stored contents.
144   */
145  public void delete() throws IOException {
146    delegate.delete();
147  }
148
149}
150