Home | History | Annotate | Download | only in okhttp 
      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  */
     16 package com.squareup.okhttp;
     17 
     18 import com.squareup.okhttp.internal.huc.JavaApiConverter;
     19 
     20 import java.io.File;
     21 import java.io.IOException;
     22 import java.net.CacheRequest;
     23 import java.net.CacheResponse;
     24 import java.net.ResponseCache;
     25 import java.net.URI;
     26 import java.net.URLConnection;
     27 import java.util.List;
     28 import 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  */
     34 public 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