Android音频缓存（边播放变下载）

package com.danikula.videocache; import android.content.Context; import android.net.Uri; import com.danikula.videocache.file.DiskUsage; import com.danikula.videocache.file.FileNameGenerator; import com.danikula.videocache.file.Md5FileNameGenerator; import com.danikula.videocache.file.TotalCountLruDiskUsage; import com.danikula.videocache.file.TotalSizeLruDiskUsage; import com.danikula.videocache.sourcestorage.SourceInfoStorage; import com.danikula.videocache.sourcestorage.SourceInfoStorageFactory; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketException; import java.util.Locale; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import static com.danikula.videocache.Preconditions.checkAllNotNull; import static com.danikula.videocache.Preconditions.checkNotNull; /** * Simple lightweight proxy server with file caching support that handles HTTP requests. * Typical usage: * <pre><code> * public onCreate(Bundle state) { * super.onCreate(state); * <p/> * HttpProxyCacheServer proxy = getProxy(); * String proxyUrl = proxy.getProxyUrl(VIDEO_URL); * videoView.setVideoPath(proxyUrl); * } * <p/> * private HttpProxyCacheServer getProxy() { * // should return single instance of HttpProxyCacheServer shared for whole app. * } * <code/></pre> * * @author Alexey Danilov (danikula@gmail.com). */ public class HttpProxyCacheServer { private static final Logger LOG = LoggerFactory.getLogger("HttpProxyCacheServer"); private static final String PROXY_HOST = "127.0.0.1"; private final Object clientsLock = new Object(); private final ExecutorService socketProcessor = Executors.newFixedThreadPool(8); private final Map<String, HttpProxyCacheServerClients> clientsMap = new ConcurrentHashMap<>(); private final ServerSocket serverSocket; private final int port; private final Thread waitConnectionThread; private final Config config; private final Pinger pinger; public HttpProxyCacheServer(Context context) { this(new Builder(context).buildConfig()); } private HttpProxyCacheServer(Config config) { this.config = checkNotNull(config); try { InetAddress inetAddress = InetAddress.getByName(PROXY_HOST); this.serverSocket = new ServerSocket(0, 8, inetAddress); this.port = serverSocket.getLocalPort(); CountDownLatch startSignal = new CountDownLatch(1); this.waitConnectionThread = new Thread(new WaitRequestsRunnable(startSignal)); this.waitConnectionThread.start(); startSignal.await(); // freeze thread, wait for server starts this.pinger = new Pinger(PROXY_HOST, port); LOG.info("Proxy cache server started. Is it alive? " + isAlive()); } catch (IOException | InterruptedException e) { socketProcessor.shutdown(); throw new IllegalStateException("Error starting local proxy server", e); } } /** * Returns url that wrap original url and should be used for client (MediaPlayer, ExoPlayer, etc). * <p> * If file for this url is fully cached (it means method {@link #isCached(String)} returns {@code true}) * then file:// uri to cached file will be returned. * <p> * Calling this method has same effect as calling {@link #getProxyUrl(String, boolean)} with 2nd parameter set to {@code true}. * * @param url a url to file that should be cached. * @return a wrapped by proxy url if file is not fully cached or url pointed to cache file otherwise. */ public String getProxyUrl(String url) { return getProxyUrl(url, true); } /** * Returns url that wrap original url and should be used for client (MediaPlayer, ExoPlayer, etc). * <p> * If parameter {@code allowCachedFileUri} is {@code true} and file for this url is fully cached * (it means method {@link #isCached(String)} returns {@code true}) then file:// uri to cached file will be returned. * * @param url a url to file that should be cached. * @param allowCachedFileUri {@code true} if allow to return file:// uri if url is fully cached * @return a wrapped by proxy url if file is not fully cached or url pointed to cache file otherwise (if {@code allowCachedFileUri} is {@code true}). */ public String getProxyUrl(String url, boolean allowCachedFileUri) { if (allowCachedFileUri && isCached(url)) { File cacheFile = getCacheFile(url); touchFileSafely(cacheFile); return Uri.fromFile(cacheFile).toString(); } return isAlive() ? appendToProxyUrl(url) : url; } public void registerCacheListener(CacheListener cacheListener, String url) { checkAllNotNull(cacheListener, url); synchronized (clientsLock) { try { getClients(url).registerCacheListener(cacheListener); } catch (ProxyCacheException e) { LOG.warn("Error registering cache listener", e); } } } public void unregisterCacheListener(CacheListener cacheListener, String url) { checkAllNotNull(cacheListener, url); synchronized (clientsLock) { try { getClients(url).unregisterCacheListener(cacheListener); } catch (ProxyCacheException e) { LOG.warn("Error registering cache listener", e); } } } public void unregisterCacheListener(CacheListener cacheListener) { checkNotNull(cacheListener); synchronized (clientsLock) { for (HttpProxyCacheServerClients clients : clientsMap.values()) { clients.unregisterCacheListener(cacheListener); } } } /** * Checks is cache contains fully cached file for particular url. * * @param url an url cache file will be checked for. * @return {@code true} if cache contains fully cached file for passed in parameters url. */ public boolean isCached(String url) { checkNotNull(url, "Url can't be null!"); return getCacheFile(url).exists(); } public void shutdown() { LOG.info("Shutdown proxy server"); shutdownClients(); config.sourceInfoStorage.release(); waitConnectionThread.interrupt(); try { if (!serverSocket.isClosed()) { serverSocket.close(); } } catch (IOException e) { onError(new ProxyCacheException("Error shutting down proxy server", e)); } } private boolean isAlive() { return pinger.ping(3, 70); // 70+140+280=max~500ms } private String appendToProxyUrl(String url) { return String.format(Locale.US, "http://%s:%d/%s", PROXY_HOST, port, ProxyCacheUtils.encode(url)); } private File getCacheFile(String url) { File cacheDir = config.cacheRoot; String fileName = config.fileNameGenerator.generate(url); return new File(cacheDir, fileName); } private void touchFileSafely(File cacheFile) { try { config.diskUsage.touch(cacheFile); } catch (IOException e) { LOG.error("Error touching file " + cacheFile, e); } } private void shutdownClients() { synchronized (clientsLock) { for (HttpProxyCacheServerClients clients : clientsMap.values()) { clients.shutdown(); } clientsMap.clear(); } } private void waitForRequest() { try { while (!Thread.currentThread().isInterrupted()) { So