Java tutorial
/* * Copyright (C) 2012 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.sdklib.internal.repository; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.utils.Pair; import org.apache.http.Header; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.ProtocolVersion; import org.apache.http.message.BasicHttpResponse; import java.io.ByteArrayInputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.TreeMap; /** A mock UpdaterData that simply records what would have been installed. */ public class MockDownloadCache extends DownloadCache { private final File mCacheRoot; /** Map url => payload bytes, http code response. * If the payload pair is null, an exception such as FNF is thrown. */ private final Map<String, Payload> mDirectPayloads = new HashMap<String, Payload>(); /** Map url => payload bytes, http code response. * If the payload pair is null, an exception such as FNF is thrown. */ private final Map<String, Payload> mCachedPayloads = new HashMap<String, Payload>(); private final Map<String, Integer> mDirectHits = new TreeMap<String, Integer>(); private final Map<String, Integer> mCachedHits = new TreeMap<String, Integer>(); private Strategy mOverrideStrategy; public static final int THROW_FNF = -1; /** * Creates a download cache with a {@code DIRECT} strategy and * no root {@code $HOME/.android} folder, which effectively disables the cache. */ public MockDownloadCache() { super(DownloadCache.Strategy.DIRECT); mCacheRoot = null; } /** * Creates a download with the given strategy and the given cache root. */ public MockDownloadCache(DownloadCache.Strategy strategy, File cacheRoot) { super(strategy); mCacheRoot = cacheRoot; } @Override protected File initCacheRoot() { return mCacheRoot; } /** * Override the {@link DownloadCache.Strategy} of the cache. * This lets us set it temporarily to {@link DownloadCache.Strategy#ONLY_CACHE}, * which will force {@link #openCachedUrl(String, ITaskMonitor)} to throw an FNF, * essentially simulating an empty cache at first. * <p/> * Setting it back to null reverts the behavior to its default. */ public void overrideStrategy(DownloadCache.Strategy strategy) { mOverrideStrategy = strategy; } /** * Register a direct payload response. * * @param url The URL to match. * @param httpCode The expected response code. * Use {@link #THROW_FNF} to mean an FNF should be thrown (which is what the * httpClient stack seems to return instead of {@link HttpStatus#SC_NOT_FOUND}.) * @param content The payload to return. * As a shortcut a null will be replaced by an empty byte array. */ public void registerDirectPayload(String url, int httpCode, byte[] content) { mDirectPayloads.put(url, new Payload(httpCode, content)); } /** * Register a cached payload response. * * @param url The URL to match. * @param content The payload to return or null to throw a FNF. */ public void registerCachedPayload(String url, byte[] content) { mCachedPayloads.put(url, new Payload(content == null ? THROW_FNF : HttpStatus.SC_OK, content)); } public String[] getDirectHits() { ArrayList<String> list = new ArrayList<String>(); synchronized (mDirectHits) { for (Entry<String, Integer> entry : mDirectHits.entrySet()) { list.add(String.format("<%1$s : %2$d>", entry.getKey(), entry.getValue().intValue())); } } return list.toArray(new String[list.size()]); } public String[] getCachedHits() { ArrayList<String> list = new ArrayList<String>(); synchronized (mCachedHits) { for (Entry<String, Integer> entry : mCachedHits.entrySet()) { list.add(String.format("<%1$s : %2$d>", entry.getKey(), entry.getValue().intValue())); } } return list.toArray(new String[list.size()]); } public void clearDirectHits() { synchronized (mDirectHits) { mDirectHits.clear(); } } public void clearCachedHits() { synchronized (mCachedHits) { mCachedHits.clear(); } } /** * Override openDirectUrl to return one of the registered payloads or throw a FNF exception. * This totally ignores the cache's {@link DownloadCache.Strategy}. */ @Override public Pair<InputStream, HttpResponse> openDirectUrl(@NonNull String urlString, @Nullable Header[] headers, @NonNull ITaskMonitor monitor) throws IOException, CanceledByUserException { synchronized (mDirectHits) { Integer count = mDirectHits.get(urlString); mDirectHits.put(urlString, (count == null ? 0 : count.intValue()) + 1); } Payload payload = mDirectPayloads.get(urlString); if (payload == null || payload.mHttpCode == THROW_FNF) { throw new FileNotFoundException(urlString); } byte[] content = payload.mContent; if (content == null) { content = new byte[0]; } InputStream is = new ByteArrayInputStream(content); HttpResponse hr = new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1), payload.mHttpCode, "Http-Code-" + payload.mHttpCode); return Pair.of(is, hr); } /** * Override openCachedUrl to return one of the registered payloads or throw a FNF exception. * This totally ignores the cache's {@link DownloadCache.Strategy}. * It will however throw a FNF if {@link #overrideStrategy(Strategy)} is set to * {@link DownloadCache.Strategy#ONLY_CACHE}. */ @Override public InputStream openCachedUrl(String urlString, ITaskMonitor monitor) throws IOException, CanceledByUserException { synchronized (mCachedHits) { Integer count = mCachedHits.get(urlString); mCachedHits.put(urlString, (count == null ? 0 : count.intValue()) + 1); } if (Strategy.ONLY_CACHE.equals(mOverrideStrategy)) { // Override the cache to read only "local cached" data. // In this first phase, we assume there's nothing cached. // TODO register first-pass files later. throw new FileNotFoundException(urlString); } Payload payload = mCachedPayloads.get(urlString); if (payload == null || payload.mHttpCode != HttpStatus.SC_OK) { throw new FileNotFoundException(urlString); } byte[] content = payload.mContent; if (content == null) { content = new byte[0]; } return new ByteArrayInputStream(content); } private static class Payload { final byte[] mContent; final int mHttpCode; Payload(int httpCode, byte[] content) { mHttpCode = httpCode; mContent = content; } } }