header : extraHeaders.entrySet()) {
188 | connection.setRequestProperty(header.getKey(), header.getValue());
189 | }
190 | }
191 |
192 | public synchronized String getMime() throws ProxyCacheException {
193 | if (TextUtils.isEmpty(sourceInfo.mime)) {
194 | fetchContentInfo();
195 | }
196 | return sourceInfo.mime;
197 | }
198 |
199 | public String getUrl() {
200 | return sourceInfo.url;
201 | }
202 |
203 | @Override
204 | public String toString() {
205 | return "HttpUrlSource{sourceInfo='" + sourceInfo + "}";
206 | }
207 | }
208 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/IgnoreHostProxySelector.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import java.io.IOException;
4 | import java.net.Proxy;
5 | import java.net.ProxySelector;
6 | import java.net.SocketAddress;
7 | import java.net.URI;
8 | import java.util.Arrays;
9 | import java.util.List;
10 |
11 | import static com.danikula.videocache.Preconditions.checkNotNull;
12 |
13 | /**
14 | * {@link ProxySelector} that ignore system default proxies for concrete host.
15 | *
16 | * It is important to ignore system proxy for localhost connection.
17 | *
18 | * @author Alexey Danilov (danikula@gmail.com).
19 | */
20 | class IgnoreHostProxySelector extends ProxySelector {
21 |
22 | private static final List NO_PROXY_LIST = Arrays.asList(Proxy.NO_PROXY);
23 |
24 | private final ProxySelector defaultProxySelector;
25 | private final String hostToIgnore;
26 | private final int portToIgnore;
27 |
28 | IgnoreHostProxySelector(ProxySelector defaultProxySelector, String hostToIgnore, int portToIgnore) {
29 | this.defaultProxySelector = checkNotNull(defaultProxySelector);
30 | this.hostToIgnore = checkNotNull(hostToIgnore);
31 | this.portToIgnore = portToIgnore;
32 | }
33 |
34 | static void install(String hostToIgnore, int portToIgnore) {
35 | ProxySelector defaultProxySelector = ProxySelector.getDefault();
36 | ProxySelector ignoreHostProxySelector = new IgnoreHostProxySelector(defaultProxySelector, hostToIgnore, portToIgnore);
37 | ProxySelector.setDefault(ignoreHostProxySelector);
38 | }
39 |
40 | @Override
41 | public List select(URI uri) {
42 | boolean ignored = hostToIgnore.equals(uri.getHost()) && portToIgnore == uri.getPort();
43 | return ignored ? NO_PROXY_LIST : defaultProxySelector.select(uri);
44 | }
45 |
46 | @Override
47 | public void connectFailed(URI uri, SocketAddress address, IOException failure) {
48 | defaultProxySelector.connectFailed(uri, address, failure);
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/InterruptedProxyCacheException.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | /**
4 | * Indicates interruption error in work of {@link ProxyCache} fired by user.
5 | *
6 | * @author Alexey Danilov
7 | */
8 | public class InterruptedProxyCacheException extends ProxyCacheException {
9 |
10 | public InterruptedProxyCacheException(String message) {
11 | super(message);
12 | }
13 |
14 | public InterruptedProxyCacheException(String message, Throwable cause) {
15 | super(message, cause);
16 | }
17 |
18 | public InterruptedProxyCacheException(Throwable cause) {
19 | super(cause);
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/M3u8ProxyUtil.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import android.text.TextUtils;
4 |
5 | import java.io.BufferedReader;
6 | import java.io.IOException;
7 | import java.io.StringReader;
8 |
9 | public class M3u8ProxyUtil {
10 | private static final String TAG_MEDIA_EXT_INF = "#EXTINF";
11 | public static final String TAG_MEDIA_EXT_STEAM_INF = "#EXT-X-STREAM-INF";
12 |
13 | public static boolean isM3u8Url(String url) {
14 | if (!TextUtils.isEmpty(url) && url.endsWith(".m3u8")) {
15 | return true;
16 | }
17 | return false;
18 | }
19 |
20 | public static String rewriteProxyBody(String localProxySuffix, String requestHost, String m3u8Content) throws IOException {
21 | StringReader reader = new StringReader(m3u8Content);
22 | BufferedReader bufferReader = new BufferedReader(reader);
23 |
24 | String line;
25 | boolean mediaNextLine = false;
26 | StringBuilder result = new StringBuilder();
27 | while ((line = bufferReader.readLine()) != null) {
28 | line = line.trim();
29 | if (TextUtils.isEmpty(line))
30 | continue;
31 |
32 | /**
33 | * #EXTM3U
34 | * #EXT-X-VERSION:3 -->Constants.TAG_VERSION
35 | * #EXT-X-MEDIA-SEQUENCE:0 -->Constants.TAG_MEDIA_SEQUENCE
36 | * #EXT-X-ALLOW-CACHE:YES
37 | * #EXT-X-TARGETDURATION:16 -->Constants.TAG_TARGET_DURATION
38 | * #EXTINF:15.520000, -->Constants.TAG_MEDIA_DURATION
39 | * out-0000.ts
40 | * #EXTINF:14.360000,
41 | * out-0001.ts
42 | * #EXT-X-ENDLIST --> Constants.TAG_ENDLIST
43 | */
44 |
45 | if (mediaNextLine) {
46 | if (!line.startsWith("http")) {
47 | line = requestHost + "/" + line;
48 | }
49 | line = localProxySuffix + "/" + ProxyCacheUtils.encode(line);//拼接成代理url
50 | }
51 |
52 | mediaNextLine = !mediaNextLine && (line.startsWith(TAG_MEDIA_EXT_INF) || line.startsWith(TAG_MEDIA_EXT_STEAM_INF));
53 | result.append(line).append("\n");
54 | }
55 | return result.toString();
56 | }
57 |
58 |
59 | }
60 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/Pinger.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import org.slf4j.Logger;
4 | import org.slf4j.LoggerFactory;
5 |
6 | import java.io.IOException;
7 | import java.io.OutputStream;
8 | import java.net.Proxy;
9 | import java.net.ProxySelector;
10 | import java.net.Socket;
11 | import java.net.URI;
12 | import java.net.URISyntaxException;
13 | import java.util.Arrays;
14 | import java.util.List;
15 | import java.util.Locale;
16 | import java.util.concurrent.Callable;
17 | import java.util.concurrent.ExecutionException;
18 | import java.util.concurrent.ExecutorService;
19 | import java.util.concurrent.Executors;
20 | import java.util.concurrent.Future;
21 | import java.util.concurrent.TimeoutException;
22 |
23 | import static com.danikula.videocache.Preconditions.checkArgument;
24 | import static com.danikula.videocache.Preconditions.checkNotNull;
25 | import static java.util.concurrent.TimeUnit.MILLISECONDS;
26 |
27 | /**
28 | * Pings {@link HttpProxyCacheServer} to make sure it works.
29 | *
30 | * @author Alexey Danilov (danikula@gmail.com).
31 | */
32 |
33 | class Pinger {
34 |
35 | private static final Logger LOG = LoggerFactory.getLogger("Pinger");
36 | private static final String PING_REQUEST = "ping";
37 | private static final String PING_RESPONSE = "ping ok";
38 |
39 | private final ExecutorService pingExecutor = Executors.newSingleThreadExecutor();
40 | private final String host;
41 | private final int port;
42 |
43 | Pinger(String host, int port) {
44 | this.host = checkNotNull(host);
45 | this.port = port;
46 | }
47 |
48 | boolean ping(int maxAttempts, int startTimeout) {
49 | checkArgument(maxAttempts >= 1);
50 | checkArgument(startTimeout > 0);
51 |
52 | int timeout = startTimeout;
53 | int attempts = 0;
54 | while (attempts < maxAttempts) {
55 | try {
56 | Future pingFuture = pingExecutor.submit(new PingCallable());
57 | boolean pinged = pingFuture.get(timeout, MILLISECONDS);
58 | if (pinged) {
59 | return true;
60 | }
61 | } catch (TimeoutException e) {
62 | LOG.warn("Error pinging server (attempt: " + attempts + ", timeout: " + timeout + "). ");
63 | } catch (InterruptedException | ExecutionException e) {
64 | LOG.error("Error pinging server due to unexpected error", e);
65 | }
66 | attempts++;
67 | timeout *= 2;
68 | }
69 | String error = String.format(Locale.US, "Error pinging server (attempts: %d, max timeout: %d). " +
70 | "If you see this message, please, report at https://github.com/danikula/AndroidVideoCache/issues/134. " +
71 | "Default proxies are: %s"
72 | , attempts, timeout / 2, getDefaultProxies());
73 | LOG.error(error, new ProxyCacheException(error));
74 | return false;
75 | }
76 |
77 | private List getDefaultProxies() {
78 | try {
79 | ProxySelector defaultProxySelector = ProxySelector.getDefault();
80 | return defaultProxySelector.select(new URI(getPingUrl()));
81 | } catch (URISyntaxException e) {
82 | throw new IllegalStateException(e);
83 | }
84 | }
85 |
86 | boolean isPingRequest(String request) {
87 | return PING_REQUEST.equals(request);
88 | }
89 |
90 | void responseToPing(Socket socket) throws IOException {
91 | OutputStream out = socket.getOutputStream();
92 | out.write("HTTP/1.1 200 OK\n\n".getBytes());
93 | out.write(PING_RESPONSE.getBytes());
94 | }
95 |
96 | private boolean pingServer() throws ProxyCacheException {
97 | String pingUrl = getPingUrl();
98 | HttpUrlSource source = new HttpUrlSource(pingUrl);
99 | try {
100 | byte[] expectedResponse = PING_RESPONSE.getBytes();
101 | source.open(0);
102 | byte[] response = new byte[expectedResponse.length];
103 | source.read(response);
104 | boolean pingOk = Arrays.equals(expectedResponse, response);
105 | LOG.info("Ping response: `" + new String(response) + "`, pinged? " + pingOk);
106 | return pingOk;
107 | } catch (ProxyCacheException e) {
108 | LOG.error("Error reading ping response", e);
109 | return false;
110 | } finally {
111 | source.close();
112 | }
113 | }
114 |
115 | private String getPingUrl() {
116 | return String.format(Locale.US, "http://%s:%d/%s", host, port, PING_REQUEST);
117 | }
118 |
119 | private class PingCallable implements Callable {
120 |
121 | @Override
122 | public Boolean call() throws Exception {
123 | return pingServer();
124 | }
125 | }
126 |
127 | }
128 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/Preconditions.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | public final class Preconditions {
4 |
5 | public static T checkNotNull(T reference) {
6 | if (reference == null) {
7 | throw new NullPointerException();
8 | }
9 | return reference;
10 | }
11 |
12 | public static void checkAllNotNull(Object... references) {
13 | for (Object reference : references) {
14 | if (reference == null) {
15 | throw new NullPointerException();
16 | }
17 | }
18 | }
19 |
20 | public static T checkNotNull(T reference, String errorMessage) {
21 | if (reference == null) {
22 | throw new NullPointerException(errorMessage);
23 | }
24 | return reference;
25 | }
26 |
27 | static void checkArgument(boolean expression) {
28 | if (!expression) {
29 | throw new IllegalArgumentException();
30 | }
31 | }
32 |
33 | static void checkArgument(boolean expression, String errorMessage) {
34 | if (!expression) {
35 | throw new IllegalArgumentException(errorMessage);
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/ProxyCache.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import org.slf4j.Logger;
4 | import org.slf4j.LoggerFactory;
5 |
6 | import java.util.concurrent.atomic.AtomicInteger;
7 |
8 | import static com.danikula.videocache.Preconditions.checkNotNull;
9 |
10 | /**
11 | * Proxy for {@link Source} with caching support ({@link Cache}).
12 | *
13 | * Can be used only for sources with persistent data (that doesn't change with time).
14 | * Method {@link #read(byte[], long, int)} will be blocked while fetching data from source.
15 | * Useful for streaming something with caching e.g. streaming video/audio etc.
16 | *
17 | * @author Alexey Danilov (danikula@gmail.com).
18 | */
19 | class ProxyCache {
20 |
21 | private static final Logger LOG = LoggerFactory.getLogger("ProxyCache");
22 | private static final int MAX_READ_SOURCE_ATTEMPTS = 1;
23 |
24 | private final Source source;
25 | private final Cache cache;
26 | private final Object wc = new Object();
27 | private final Object stopLock = new Object();
28 | private final AtomicInteger readSourceErrorsCount;
29 | private volatile Thread sourceReaderThread;
30 | private volatile boolean stopped;
31 | private volatile int percentsAvailable = -1;
32 |
33 | public ProxyCache(Source source, Cache cache) {
34 | this.source = checkNotNull(source);
35 | this.cache = checkNotNull(cache);
36 | this.readSourceErrorsCount = new AtomicInteger();
37 | }
38 |
39 | public int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
40 | ProxyCacheUtils.assertBuffer(buffer, offset, length);
41 |
42 | while (!cache.isCompleted() && cache.available() < (offset + length) && !stopped) {
43 | readSourceAsync();
44 | waitForSourceData();
45 | checkReadSourceErrorsCount();
46 | }
47 | int read = cache.read(buffer, offset, length);
48 | if (cache.isCompleted() && percentsAvailable != 100) {
49 | percentsAvailable = 100;
50 | onCachePercentsAvailableChanged(100);
51 | }
52 | return read;
53 | }
54 |
55 | private void checkReadSourceErrorsCount() throws ProxyCacheException {
56 | int errorsCount = readSourceErrorsCount.get();
57 | if (errorsCount >= MAX_READ_SOURCE_ATTEMPTS) {
58 | readSourceErrorsCount.set(0);
59 | throw new ProxyCacheException("Error reading source " + errorsCount + " times");
60 | }
61 | }
62 |
63 | public void shutdown() {
64 | synchronized (stopLock) {
65 | LOG.debug("Shutdown proxy for " + source);
66 | try {
67 | stopped = true;
68 | if (sourceReaderThread != null) {
69 | sourceReaderThread.interrupt();
70 | }
71 | cache.close();
72 | } catch (ProxyCacheException e) {
73 | onError(e);
74 | }
75 | }
76 | }
77 |
78 | private synchronized void readSourceAsync() throws ProxyCacheException {
79 | boolean readingInProgress = sourceReaderThread != null && sourceReaderThread.getState() != Thread.State.TERMINATED;
80 | if (!stopped && !cache.isCompleted() && !readingInProgress) {
81 | sourceReaderThread = new Thread(new SourceReaderRunnable(), "Source reader for " + source);
82 | sourceReaderThread.start();
83 | }
84 | }
85 |
86 | private void waitForSourceData() throws ProxyCacheException {
87 | synchronized (wc) {
88 | try {
89 | wc.wait(1000);
90 | } catch (InterruptedException e) {
91 | throw new ProxyCacheException("Waiting source data is interrupted!", e);
92 | }
93 | }
94 | }
95 |
96 | private void notifyNewCacheDataAvailable(long cacheAvailable, long sourceAvailable) {
97 | onCacheAvailable(cacheAvailable, sourceAvailable);
98 |
99 | synchronized (wc) {
100 | wc.notifyAll();
101 | }
102 | }
103 |
104 | protected void onCacheAvailable(long cacheAvailable, long sourceLength) {
105 | boolean zeroLengthSource = sourceLength == 0;
106 | int percents = zeroLengthSource ? 100 : (int) ((float) cacheAvailable / sourceLength * 100);
107 | boolean percentsChanged = percents != percentsAvailable;
108 | boolean sourceLengthKnown = sourceLength >= 0;
109 | if (sourceLengthKnown && percentsChanged) {
110 | onCachePercentsAvailableChanged(percents);
111 | }
112 | percentsAvailable = percents;
113 | }
114 |
115 | protected void onCachePercentsAvailableChanged(int percentsAvailable) {
116 | }
117 |
118 | private void readSource() {
119 | long sourceAvailable = -1;
120 | long offset = 0;
121 | try {
122 | offset = cache.available();
123 | source.open(offset);
124 | sourceAvailable = source.length();
125 | byte[] buffer = new byte[ProxyCacheUtils.DEFAULT_BUFFER_SIZE];
126 | int readBytes;
127 | while ((readBytes = source.read(buffer)) != -1) {
128 | synchronized (stopLock) {
129 | if (isStopped()) {
130 | return;
131 | }
132 | cache.append(buffer, readBytes);
133 | }
134 | offset += readBytes;
135 | notifyNewCacheDataAvailable(offset, sourceAvailable);
136 | }
137 | tryComplete();
138 | onSourceRead();
139 | } catch (Throwable e) {
140 | readSourceErrorsCount.incrementAndGet();
141 | onError(e);
142 | } finally {
143 | closeSource();
144 | notifyNewCacheDataAvailable(offset, sourceAvailable);
145 | }
146 | }
147 |
148 | private void onSourceRead() {
149 | // guaranteed notify listeners after source read and cache completed
150 | percentsAvailable = 100;
151 | onCachePercentsAvailableChanged(percentsAvailable);
152 | }
153 |
154 | private void tryComplete() throws ProxyCacheException {
155 | synchronized (stopLock) {
156 | if (!isStopped() && cache.available() == source.length()) {
157 | cache.complete();
158 | }
159 | }
160 | }
161 |
162 | private boolean isStopped() {
163 | return Thread.currentThread().isInterrupted() || stopped;
164 | }
165 |
166 | private void closeSource() {
167 | try {
168 | source.close();
169 | } catch (ProxyCacheException e) {
170 | onError(new ProxyCacheException("Error closing source " + source, e));
171 | }
172 | }
173 |
174 | protected final void onError(final Throwable e) {
175 | boolean interruption = e instanceof InterruptedProxyCacheException;
176 | if (interruption) {
177 | LOG.debug("ProxyCache is interrupted");
178 | } else {
179 | LOG.error("ProxyCache error", e);
180 | }
181 | }
182 |
183 | private class SourceReaderRunnable implements Runnable {
184 |
185 | @Override
186 | public void run() {
187 | readSource();
188 | }
189 | }
190 | }
191 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/ProxyCacheException.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | /**
4 | * Indicates any error in work of {@link ProxyCache}.
5 | *
6 | * @author Alexey Danilov
7 | */
8 | public class ProxyCacheException extends Exception {
9 |
10 | private static final String LIBRARY_VERSION = ". Version: " + BuildConfig.VERSION_NAME;
11 |
12 | public ProxyCacheException(String message) {
13 | super(message + LIBRARY_VERSION);
14 | }
15 |
16 | public ProxyCacheException(String message, Throwable cause) {
17 | super(message + LIBRARY_VERSION, cause);
18 | }
19 |
20 | public ProxyCacheException(Throwable cause) {
21 | super("No explanation error" + LIBRARY_VERSION, cause);
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/ProxyCacheUtils.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import android.text.TextUtils;
4 | import android.webkit.MimeTypeMap;
5 |
6 | import org.slf4j.Logger;
7 | import org.slf4j.LoggerFactory;
8 |
9 | import java.io.Closeable;
10 | import java.io.IOException;
11 | import java.io.UnsupportedEncodingException;
12 | import java.net.URLDecoder;
13 | import java.net.URLEncoder;
14 | import java.security.MessageDigest;
15 | import java.security.NoSuchAlgorithmException;
16 | import java.util.Arrays;
17 |
18 | import static com.danikula.videocache.Preconditions.checkArgument;
19 | import static com.danikula.videocache.Preconditions.checkNotNull;
20 |
21 | /**
22 | * Just simple utils.
23 | *
24 | * @author Alexey Danilov (danikula@gmail.com).
25 | */
26 | public class ProxyCacheUtils {
27 |
28 | private static final Logger LOG = LoggerFactory.getLogger("ProxyCacheUtils");
29 | static final int DEFAULT_BUFFER_SIZE = 8 * 1024;
30 | static final int MAX_ARRAY_PREVIEW = 16;
31 |
32 | static String getSupposablyMime(String url) {
33 | MimeTypeMap mimes = MimeTypeMap.getSingleton();
34 | String extension = MimeTypeMap.getFileExtensionFromUrl(url);
35 | return TextUtils.isEmpty(extension) ? null : mimes.getMimeTypeFromExtension(extension);
36 | }
37 |
38 | static void assertBuffer(byte[] buffer, long offset, int length) {
39 | checkNotNull(buffer, "Buffer must be not null!");
40 | checkArgument(offset >= 0, "Data offset must be positive!");
41 | checkArgument(length >= 0 && length <= buffer.length, "Length must be in range [0..buffer.length]");
42 | }
43 |
44 | static String preview(byte[] data, int length) {
45 | int previewLength = Math.min(MAX_ARRAY_PREVIEW, Math.max(length, 0));
46 | byte[] dataRange = Arrays.copyOfRange(data, 0, previewLength);
47 | String preview = Arrays.toString(dataRange);
48 | if (previewLength < length) {
49 | preview = preview.substring(0, preview.length() - 1) + ", ...]";
50 | }
51 | return preview;
52 | }
53 |
54 | static String encode(String url) {
55 | try {
56 | return URLEncoder.encode(url, "utf-8");
57 | } catch (UnsupportedEncodingException e) {
58 | throw new RuntimeException("Error encoding url", e);
59 | }
60 | }
61 |
62 | static String decode(String url) {
63 | try {
64 | return URLDecoder.decode(url, "utf-8");
65 | } catch (UnsupportedEncodingException e) {
66 | throw new RuntimeException("Error decoding url", e);
67 | }
68 | }
69 |
70 | static void close(Closeable closeable) {
71 | if (closeable != null) {
72 | try {
73 | closeable.close();
74 | } catch (IOException e) {
75 | LOG.error("Error closing resource", e);
76 | }
77 | }
78 | }
79 |
80 | public static String computeMD5(String string) {
81 | try {
82 | MessageDigest messageDigest = MessageDigest.getInstance("MD5");
83 | byte[] digestBytes = messageDigest.digest(string.getBytes());
84 | return bytesToHexString(digestBytes);
85 | } catch (NoSuchAlgorithmException e) {
86 | throw new IllegalStateException(e);
87 | }
88 | }
89 |
90 | private static String bytesToHexString(byte[] bytes) {
91 | StringBuffer sb = new StringBuffer();
92 | for (byte b : bytes) {
93 | sb.append(String.format("%02x", b));
94 | }
95 | return sb.toString();
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/Source.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | /**
4 | * Source for proxy.
5 | *
6 | * @author Alexey Danilov (danikula@gmail.com).
7 | */
8 | public interface Source {
9 |
10 | /**
11 | * Opens source. Source should be open before using {@link #read(byte[])}
12 | *
13 | * @param offset offset in bytes for source.
14 | * @throws ProxyCacheException if error occur while opening source.
15 | */
16 | void open(long offset) throws ProxyCacheException;
17 |
18 | /**
19 | * Returns length bytes or negative value if length is unknown.
20 | *
21 | * @return bytes length
22 | * @throws ProxyCacheException if error occur while fetching source data.
23 | */
24 | long length() throws ProxyCacheException;
25 |
26 | /**
27 | * Read data to byte buffer from source with current offset.
28 | *
29 | * @param buffer a buffer to be used for reading data.
30 | * @return a count of read bytes
31 | * @throws ProxyCacheException if error occur while reading source.
32 | */
33 | int read(byte[] buffer) throws ProxyCacheException;
34 |
35 | /**
36 | * Closes source and release resources. Every opened source should be closed.
37 | *
38 | * @throws ProxyCacheException if error occur while closing source.
39 | */
40 | void close() throws ProxyCacheException;
41 | }
42 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/SourceInfo.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | /**
4 | * Stores source's info.
5 | *
6 | * @author Alexey Danilov (danikula@gmail.com).
7 | */
8 | public class SourceInfo {
9 |
10 | public final String url;
11 | public final long length;
12 | public final String mime;
13 |
14 | public SourceInfo(String url, long length, String mime) {
15 | this.url = url;
16 | this.length = length;
17 | this.mime = mime;
18 | }
19 |
20 | @Override
21 | public String toString() {
22 | return "SourceInfo{" +
23 | "url='" + url + '\'' +
24 | ", length=" + length +
25 | ", mime='" + mime + '\'' +
26 | '}';
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/StorageUtils.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache;
2 |
3 | import android.content.Context;
4 | import android.os.Environment;
5 |
6 | import org.slf4j.Logger;
7 | import org.slf4j.LoggerFactory;
8 |
9 | import java.io.File;
10 |
11 | import static android.os.Environment.MEDIA_MOUNTED;
12 |
13 | /**
14 | * Provides application storage paths
15 | *
16 | * See https://github.com/nostra13/Android-Universal-Image-Loader
17 | *
18 | * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
19 | * @since 1.0.0
20 | */
21 | final class StorageUtils {
22 |
23 | private static final Logger LOG = LoggerFactory.getLogger("StorageUtils");
24 | private static final String INDIVIDUAL_DIR_NAME = "video-cache";
25 |
26 | /**
27 | * Returns individual application cache directory (for only video caching from Proxy). Cache directory will be
28 | * created on SD card ("/Android/data/[app_package_name]/cache/video-cache") if card is mounted .
29 | * Else - Android defines cache directory on device's file system.
30 | *
31 | * @param context Application context
32 | * @return Cache {@link File directory}
33 | */
34 | public static File getIndividualCacheDirectory(Context context) {
35 | File cacheDir = getCacheDirectory(context, true);
36 | return new File(cacheDir, INDIVIDUAL_DIR_NAME);
37 | }
38 |
39 | /**
40 | * Returns application cache directory. Cache directory will be created on SD card
41 | * ("/Android/data/[app_package_name]/cache") (if card is mounted and app has appropriate permission) or
42 | * on device's file system depending incoming parameters.
43 | *
44 | * @param context Application context
45 | * @param preferExternal Whether prefer external location for cache
46 | * @return Cache {@link File directory}.
47 | * NOTE: Can be null in some unpredictable cases (if SD card is unmounted and
48 | * {@link android.content.Context#getCacheDir() Context.getCacheDir()} returns null).
49 | */
50 | private static File getCacheDirectory(Context context, boolean preferExternal) {
51 | File appCacheDir = null;
52 | String externalStorageState;
53 | try {
54 | externalStorageState = Environment.getExternalStorageState();
55 | } catch (NullPointerException e) { // (sh)it happens
56 | externalStorageState = "";
57 | }
58 | if (preferExternal && MEDIA_MOUNTED.equals(externalStorageState)) {
59 | appCacheDir = getExternalCacheDir(context);
60 | }
61 | if (appCacheDir == null) {
62 | appCacheDir = context.getCacheDir();
63 | }
64 | if (appCacheDir == null) {
65 | String cacheDirPath = "/data/data/" + context.getPackageName() + "/cache/";
66 | LOG.warn("Can't define system cache directory! '" + cacheDirPath + "%s' will be used.");
67 | appCacheDir = new File(cacheDirPath);
68 | }
69 | return appCacheDir;
70 | }
71 |
72 | private static File getExternalCacheDir(Context context) {
73 | File dataDir = new File(new File(Environment.getExternalStorageDirectory(), "Android"), "data");
74 | File appCacheDir = new File(new File(dataDir, context.getPackageName()), "cache");
75 | if (!appCacheDir.exists()) {
76 | if (!appCacheDir.mkdirs()) {
77 | LOG.warn("Unable to create external cache directory");
78 | return null;
79 | }
80 | }
81 | return appCacheDir;
82 | }
83 | }
84 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/DiskUsage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import java.io.File;
4 | import java.io.IOException;
5 |
6 | /**
7 | * Declares how {@link FileCache} will use disc space.
8 | *
9 | * @author Alexey Danilov (danikula@gmail.com).
10 | */
11 | public interface DiskUsage {
12 |
13 | void touch(File file) throws IOException;
14 |
15 | }
16 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/FileCache.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import com.danikula.videocache.Cache;
4 | import com.danikula.videocache.ProxyCacheException;
5 |
6 | import java.io.File;
7 | import java.io.IOException;
8 | import java.io.RandomAccessFile;
9 |
10 | /**
11 | * {@link Cache} that uses file for storing data.
12 | *
13 | * @author Alexey Danilov (danikula@gmail.com).
14 | */
15 | public class FileCache implements Cache {
16 |
17 | public static final String TEMP_POSTFIX = ".download";
18 |
19 | private final DiskUsage diskUsage;
20 | public File file;
21 | private RandomAccessFile dataFile;
22 |
23 | public FileCache(File file) throws ProxyCacheException {
24 | this(file, new UnlimitedDiskUsage());
25 | }
26 |
27 | public FileCache(File file, DiskUsage diskUsage) throws ProxyCacheException {
28 | try {
29 | if (diskUsage == null) {
30 | throw new NullPointerException();
31 | }
32 | this.diskUsage = diskUsage;
33 | File directory = file.getParentFile();
34 | Files.makeDir(directory);
35 | boolean completed = file.exists();
36 | this.file = completed ? file : new File(file.getParentFile(), file.getName() + TEMP_POSTFIX);
37 | this.dataFile = new RandomAccessFile(this.file, completed ? "r" : "rw");
38 | } catch (IOException e) {
39 | throw new ProxyCacheException("Error using file " + file + " as disc cache", e);
40 | }
41 | }
42 |
43 | @Override
44 | public synchronized long available() throws ProxyCacheException {
45 | try {
46 | return (int) dataFile.length();
47 | } catch (IOException e) {
48 | throw new ProxyCacheException("Error reading length of file " + file, e);
49 | }
50 | }
51 |
52 | @Override
53 | public synchronized int read(byte[] buffer, long offset, int length) throws ProxyCacheException {
54 | try {
55 | dataFile.seek(offset);
56 | return dataFile.read(buffer, 0, length);
57 | } catch (IOException e) {
58 | String format = "Error reading %d bytes with offset %d from file[%d bytes] to buffer[%d bytes]";
59 | throw new ProxyCacheException(String.format(format, length, offset, available(), buffer.length), e);
60 | }
61 | }
62 |
63 | @Override
64 | public synchronized void append(byte[] data, int length) throws ProxyCacheException {
65 | try {
66 | if (isCompleted()) {
67 | throw new ProxyCacheException("Error append cache: cache file " + file + " is completed!");
68 | }
69 | dataFile.seek(available());
70 | dataFile.write(data, 0, length);
71 | } catch (IOException e) {
72 | String format = "Error writing %d bytes to %s from buffer with size %d";
73 | throw new ProxyCacheException(String.format(format, length, dataFile, data.length), e);
74 | }
75 | }
76 |
77 | @Override
78 | public synchronized void close() throws ProxyCacheException {
79 | try {
80 | dataFile.close();
81 | diskUsage.touch(file);
82 | } catch (IOException e) {
83 | throw new ProxyCacheException("Error closing file " + file, e);
84 | }
85 | }
86 |
87 | @Override
88 | public synchronized void complete() throws ProxyCacheException {
89 | if (isCompleted()) {
90 | return;
91 | }
92 |
93 | close();
94 | String fileName = file.getName().substring(0, file.getName().length() - TEMP_POSTFIX.length());
95 | File completedFile = new File(file.getParentFile(), fileName);
96 | boolean renamed = file.renameTo(completedFile);
97 | if (!renamed) {
98 | throw new ProxyCacheException("Error renaming file " + file + " to " + completedFile + " for completion!");
99 | }
100 | file = completedFile;
101 | try {
102 | dataFile = new RandomAccessFile(file, "r");
103 | diskUsage.touch(file);
104 | } catch (IOException e) {
105 | throw new ProxyCacheException("Error opening " + file + " as disc cache", e);
106 | }
107 | }
108 |
109 | @Override
110 | public synchronized boolean isCompleted() {
111 | return !isTempFile(file);
112 | }
113 |
114 | /**
115 | * Returns file to be used fo caching. It may as original file passed in constructor as some temp file for not completed cache.
116 | *
117 | * @return file for caching.
118 | */
119 | public File getFile() {
120 | return file;
121 | }
122 |
123 | private boolean isTempFile(File file) {
124 | return file.getName().endsWith(TEMP_POSTFIX);
125 | }
126 |
127 | }
128 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/FileNameGenerator.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | /**
4 | * Generator for files to be used for caching.
5 | *
6 | * @author Alexey Danilov (danikula@gmail.com).
7 | */
8 | public interface FileNameGenerator {
9 |
10 | String generate(String url);
11 |
12 | }
13 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/Files.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import org.slf4j.Logger;
4 | import org.slf4j.LoggerFactory;
5 |
6 | import java.io.File;
7 | import java.io.IOException;
8 | import java.io.RandomAccessFile;
9 | import java.util.Arrays;
10 | import java.util.Collections;
11 | import java.util.Comparator;
12 | import java.util.Date;
13 | import java.util.LinkedList;
14 | import java.util.List;
15 |
16 | /**
17 | * Utils for work with files.
18 | *
19 | * @author Alexey Danilov (danikula@gmail.com).
20 | */
21 | class Files {
22 |
23 | private static final Logger LOG = LoggerFactory.getLogger("Files");
24 |
25 | static void makeDir(File directory) throws IOException {
26 | if (directory.exists()) {
27 | if (!directory.isDirectory()) {
28 | throw new IOException("File " + directory + " is not directory!");
29 | }
30 | } else {
31 | boolean isCreated = directory.mkdirs();
32 | if (!isCreated) {
33 | throw new IOException(String.format("Directory %s can't be created", directory.getAbsolutePath()));
34 | }
35 | }
36 | }
37 |
38 | static List getLruListFiles(File directory) {
39 | List result = new LinkedList<>();
40 | File[] files = directory.listFiles();
41 | if (files != null) {
42 | result = Arrays.asList(files);
43 | Collections.sort(result, new LastModifiedComparator());
44 | }
45 | return result;
46 | }
47 |
48 | static void setLastModifiedNow(File file) throws IOException {
49 | if (file.exists()) {
50 | long now = System.currentTimeMillis();
51 | boolean modified = file.setLastModified(now); // on some devices (e.g. Nexus 5) doesn't work
52 | if (!modified) {
53 | modify(file);
54 | if (file.lastModified() < now) {
55 | // NOTE: apparently this is a known issue (see: http://stackoverflow.com/questions/6633748/file-lastmodified-is-never-what-was-set-with-file-setlastmodified)
56 | LOG.warn("Last modified date {} is not set for file {}", new Date(file.lastModified()), file.getAbsolutePath());
57 | }
58 | }
59 | }
60 | }
61 |
62 | static void modify(File file) throws IOException {
63 | long size = file.length();
64 | if (size == 0) {
65 | recreateZeroSizeFile(file);
66 | return;
67 | }
68 |
69 | RandomAccessFile accessFile = new RandomAccessFile(file, "rwd");
70 | accessFile.seek(size - 1);
71 | byte lastByte = accessFile.readByte();
72 | accessFile.seek(size - 1);
73 | accessFile.write(lastByte);
74 | accessFile.close();
75 | }
76 |
77 | private static void recreateZeroSizeFile(File file) throws IOException {
78 | if (!file.delete() || !file.createNewFile()) {
79 | throw new IOException("Error recreate zero-size file " + file);
80 | }
81 | }
82 |
83 | private static final class LastModifiedComparator implements Comparator {
84 |
85 | @Override
86 | public int compare(File lhs, File rhs) {
87 | return compareLong(lhs.lastModified(), rhs.lastModified());
88 | }
89 |
90 | private int compareLong(long first, long second) {
91 | return (first < second) ? -1 : ((first == second) ? 0 : 1);
92 | }
93 | }
94 |
95 | }
96 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/LruDiskUsage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import org.slf4j.Logger;
4 | import org.slf4j.LoggerFactory;
5 |
6 | import java.io.File;
7 | import java.io.IOException;
8 | import java.util.List;
9 | import java.util.concurrent.Callable;
10 | import java.util.concurrent.ExecutorService;
11 | import java.util.concurrent.Executors;
12 |
13 | /**
14 | * {@link DiskUsage} that uses LRU (Least Recently Used) strategy to trim cache.
15 | *
16 | * @author Alexey Danilov (danikula@gmail.com).
17 | */
18 | public abstract class LruDiskUsage implements DiskUsage {
19 |
20 | private static final Logger LOG = LoggerFactory.getLogger("LruDiskUsage");
21 | private final ExecutorService workerThread = Executors.newSingleThreadExecutor();
22 |
23 | @Override
24 | public void touch(File file) throws IOException {
25 | workerThread.submit(new TouchCallable(file));
26 | }
27 |
28 | private void touchInBackground(File file) throws IOException {
29 | Files.setLastModifiedNow(file);
30 | List files = Files.getLruListFiles(file.getParentFile());
31 | trim(files);
32 | }
33 |
34 | protected abstract boolean accept(File file, long totalSize, int totalCount);
35 |
36 | private void trim(List files) {
37 | long totalSize = countTotalSize(files);
38 | int totalCount = files.size();
39 | for (File file : files) {
40 | boolean accepted = accept(file, totalSize, totalCount);
41 | if (!accepted) {
42 | long fileSize = file.length();
43 | boolean deleted = file.delete();
44 | if (deleted) {
45 | totalCount--;
46 | totalSize -= fileSize;
47 | LOG.info("Cache file " + file + " is deleted because it exceeds cache limit");
48 | } else {
49 | LOG.error("Error deleting file " + file + " for trimming cache");
50 | }
51 | }
52 | }
53 | }
54 |
55 | private long countTotalSize(List files) {
56 | long totalSize = 0;
57 | for (File file : files) {
58 | totalSize += file.length();
59 | }
60 | return totalSize;
61 | }
62 |
63 | private class TouchCallable implements Callable {
64 |
65 | private final File file;
66 |
67 | public TouchCallable(File file) {
68 | this.file = file;
69 | }
70 |
71 | @Override
72 | public Void call() throws Exception {
73 | touchInBackground(file);
74 | return null;
75 | }
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/Md5FileNameGenerator.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import android.text.TextUtils;
4 |
5 | import com.danikula.videocache.ProxyCacheUtils;
6 |
7 | /**
8 | * Implementation of {@link FileNameGenerator} that uses MD5 of url as file name
9 | *
10 | * @author Alexey Danilov (danikula@gmail.com).
11 | */
12 | public class Md5FileNameGenerator implements FileNameGenerator {
13 |
14 | private static final int MAX_EXTENSION_LENGTH = 4;
15 |
16 | @Override
17 | public String generate(String url) {
18 | String extension = getExtension(url);
19 | String name = ProxyCacheUtils.computeMD5(url);
20 | return TextUtils.isEmpty(extension) ? name : name + "." + extension;
21 | }
22 |
23 | private String getExtension(String url) {
24 | int dotIndex = url.lastIndexOf('.');
25 | int slashIndex = url.lastIndexOf('/');
26 | return dotIndex != -1 && dotIndex > slashIndex && dotIndex + 2 + MAX_EXTENSION_LENGTH > url.length() ?
27 | url.substring(dotIndex + 1, url.length()) : "";
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/TotalCountLruDiskUsage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import java.io.File;
4 |
5 | /**
6 | * {@link DiskUsage} that uses LRU (Least Recently Used) strategy and trims cache size to max files count if needed.
7 | *
8 | * @author Alexey Danilov (danikula@gmail.com).
9 | */
10 | public class TotalCountLruDiskUsage extends LruDiskUsage {
11 |
12 | private final int maxCount;
13 |
14 | public TotalCountLruDiskUsage(int maxCount) {
15 | if (maxCount <= 0) {
16 | throw new IllegalArgumentException("Max count must be positive number!");
17 | }
18 | this.maxCount = maxCount;
19 | }
20 |
21 | @Override
22 | protected boolean accept(File file, long totalSize, int totalCount) {
23 | return totalCount <= maxCount;
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/TotalSizeLruDiskUsage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import java.io.File;
4 |
5 | /**
6 | * {@link DiskUsage} that uses LRU (Least Recently Used) strategy and trims cache size to max size if needed.
7 | *
8 | * @author Alexey Danilov (danikula@gmail.com).
9 | */
10 | public class TotalSizeLruDiskUsage extends LruDiskUsage {
11 |
12 | private final long maxSize;
13 |
14 | public TotalSizeLruDiskUsage(long maxSize) {
15 | if (maxSize <= 0) {
16 | throw new IllegalArgumentException("Max size must be positive number!");
17 | }
18 | this.maxSize = maxSize;
19 | }
20 |
21 | @Override
22 | protected boolean accept(File file, long totalSize, int totalCount) {
23 | return totalSize <= maxSize;
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/file/UnlimitedDiskUsage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.file;
2 |
3 | import java.io.File;
4 | import java.io.IOException;
5 |
6 | /**
7 | * Unlimited version of {@link DiskUsage}.
8 | *
9 | * @author Alexey Danilov (danikula@gmail.com).
10 | */
11 | public class UnlimitedDiskUsage implements DiskUsage {
12 |
13 | @Override
14 | public void touch(File file) throws IOException {
15 | // do nothing
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/headers/EmptyHeadersInjector.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.headers;
2 |
3 | import java.util.HashMap;
4 | import java.util.Map;
5 |
6 | /**
7 | * Empty {@link HeaderInjector} implementation.
8 | *
9 | * @author Lucas Nelaupe (https://github.com/lucas34).
10 | */
11 | public class EmptyHeadersInjector implements HeaderInjector {
12 |
13 | @Override
14 | public Map addHeaders(String url) {
15 | return new HashMap<>();
16 | }
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/headers/HeaderInjector.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.headers;
2 |
3 | import java.util.Map;
4 |
5 | /**
6 | * Allows to add custom headers to server's requests.
7 | *
8 | * @author Lucas Nelaupe (https://github.com/lucas34).
9 | */
10 | public interface HeaderInjector {
11 |
12 | /**
13 | * Adds headers to server's requests for corresponding url.
14 | *
15 | * @param url an url headers will be added for
16 | * @return a map with headers, where keys are header's names, and values are header's values. {@code null} is not acceptable!
17 | */
18 | Map addHeaders(String url);
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/preload/PreloadHelper.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.preload;
2 |
3 | import com.danikula.videocache.HttpProxyCacheServer;
4 | import com.danikula.videocache.file.FileCache;
5 |
6 | import java.io.File;
7 | import java.util.concurrent.ExecutorService;
8 | import java.util.concurrent.Executors;
9 |
10 | public class PreloadHelper {
11 | private static final long DEFAULT_PRELOAD_SIZE = 256 * 1024;//最小缓存大小 256kb
12 | private static final int DEFAULT_PRELOAD_THREAD_COUNT = 5;//默认预缓存线程数
13 |
14 | private final ExecutorService preloadThreadPool = Executors.newFixedThreadPool(DEFAULT_PRELOAD_THREAD_COUNT);
15 | private long preloadSize = DEFAULT_PRELOAD_SIZE;
16 |
17 | private PreloadHelper() {
18 | }
19 |
20 | public static PreloadHelper getInstance() {
21 | return PreloadHelperHolder.INSTANCE;
22 | }
23 |
24 | public void setPreloadSize(long size) {
25 | this.preloadSize = Math.max(preloadSize, size);
26 | }
27 |
28 | public void load(HttpProxyCacheServer cacheServer, String url) {
29 | String proxyUrl = cacheServer.getProxyUrl(url);
30 | File cacheFile = cacheServer.getCacheFile(url);
31 | File downloadCacheFile = new File(cacheFile.getParentFile(), cacheFile.getName() + FileCache.TEMP_POSTFIX);
32 |
33 | if (!proxyUrl.startsWith("http")) {
34 | PreloadLog.info("PreloadHelper::load(proxyUrl) => proxyUrl is not httpUrl, if startsWith File://.. it has been cached " + proxyUrl);
35 | return;
36 | }
37 |
38 | if (cacheFile.exists() || (downloadCacheFile.exists() && downloadCacheFile.length() > preloadSize)) {
39 | PreloadLog.info("PreloadHelper::load() => The file is preloaded." + proxyUrl);
40 | return;
41 | }
42 |
43 | preloadThreadPool.execute(new PreloadTaskRunnable(proxyUrl, preloadSize));
44 | }
45 |
46 | public void stopAllPreload() {
47 | //没有加载的停止预加载
48 | preloadThreadPool.shutdown();
49 | }
50 |
51 | private static class PreloadHelperHolder {
52 | private static final PreloadHelper INSTANCE = new PreloadHelper();
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/preload/PreloadLog.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.preload;
2 |
3 | import android.util.Log;
4 |
5 | import com.danikula.videocache.BuildConfig;
6 |
7 | public class PreloadLog {
8 | private static final String TAG = "PreloadLog";
9 |
10 | public static void info(String s) {
11 | if (BuildConfig.DEBUG) {
12 | Log.i(TAG, s);
13 | }
14 | }
15 |
16 | public static void debug(String s) {
17 | if (BuildConfig.DEBUG) {
18 | Log.d(TAG, s);
19 | }
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/preload/PreloadTaskRunnable.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.preload;
2 |
3 | import com.danikula.videocache.HttpUrlSource;
4 | import com.danikula.videocache.ProxyCacheException;
5 |
6 | public class PreloadTaskRunnable implements Runnable {
7 |
8 | private final String proxyUrl;
9 | private final long preloadSize;
10 |
11 | public PreloadTaskRunnable(String proxyUrl, long preloadSize) {
12 | this.proxyUrl = proxyUrl;
13 | this.preloadSize = preloadSize;
14 | }
15 |
16 | @Override
17 | public void run() {
18 | PreloadLog.debug("PreloadTaskRunnable run():" + proxyUrl);
19 |
20 | HttpUrlSource newSourceNoCache = new HttpUrlSource(proxyUrl);
21 |
22 | try {
23 | newSourceNoCache.open(0);
24 | byte[] buffer = new byte[8 * 1024];//8K
25 | int bufferLen = buffer.length;
26 | int readBytes;
27 | int offset = 0;
28 |
29 | while ((offset + bufferLen <= preloadSize) && (readBytes = newSourceNoCache.read(buffer)) != -1) {
30 | //undo no need write.
31 | // out.write(buffer, 0, readBytes);
32 | offset += readBytes;
33 | }
34 | } catch (ProxyCacheException e) {
35 | e.printStackTrace();
36 | } finally {
37 | PreloadLog.debug("PreloadTaskRunnable is finished!!! ");
38 | try {
39 | newSourceNoCache.close();
40 | } catch (ProxyCacheException e) {
41 | e.printStackTrace();
42 | }
43 | }
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/sourcestorage/DatabaseSourceInfoStorage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.sourcestorage;
2 |
3 | import android.content.ContentValues;
4 | import android.content.Context;
5 | import android.database.Cursor;
6 | import android.database.sqlite.SQLiteDatabase;
7 | import android.database.sqlite.SQLiteOpenHelper;
8 |
9 | import com.danikula.videocache.SourceInfo;
10 |
11 | import static com.danikula.videocache.Preconditions.checkAllNotNull;
12 | import static com.danikula.videocache.Preconditions.checkNotNull;
13 |
14 | /**
15 | * Database based {@link SourceInfoStorage}.
16 | *
17 | * @author Alexey Danilov (danikula@gmail.com).
18 | */
19 | class DatabaseSourceInfoStorage extends SQLiteOpenHelper implements SourceInfoStorage {
20 |
21 | private static final String TABLE = "SourceInfo";
22 | private static final String COLUMN_ID = "_id";
23 | private static final String COLUMN_URL = "url";
24 | private static final String COLUMN_LENGTH = "length";
25 | private static final String COLUMN_MIME = "mime";
26 | private static final String[] ALL_COLUMNS = new String[]{COLUMN_ID, COLUMN_URL, COLUMN_LENGTH, COLUMN_MIME};
27 | private static final String CREATE_SQL =
28 | "CREATE TABLE " + TABLE + " (" +
29 | COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," +
30 | COLUMN_URL + " TEXT NOT NULL," +
31 | COLUMN_MIME + " TEXT," +
32 | COLUMN_LENGTH + " INTEGER" +
33 | ");";
34 |
35 | DatabaseSourceInfoStorage(Context context) {
36 | super(context, "AndroidVideoCache.db", null, 1);
37 | checkNotNull(context);
38 | }
39 |
40 | @Override
41 | public void onCreate(SQLiteDatabase db) {
42 | checkNotNull(db);
43 | db.execSQL(CREATE_SQL);
44 | }
45 |
46 | @Override
47 | public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
48 | throw new IllegalStateException("Should not be called. There is no any migration");
49 | }
50 |
51 | @Override
52 | public SourceInfo get(String url) {
53 | checkNotNull(url);
54 | Cursor cursor = null;
55 | try {
56 | cursor = getReadableDatabase().query(TABLE, ALL_COLUMNS, COLUMN_URL + "=?", new String[]{url}, null, null, null);
57 | return cursor == null || !cursor.moveToFirst() ? null : convert(cursor);
58 | } finally {
59 | if (cursor != null) {
60 | cursor.close();
61 | }
62 | }
63 | }
64 |
65 | @Override
66 | public void put(String url, SourceInfo sourceInfo) {
67 | checkAllNotNull(url, sourceInfo);
68 | SourceInfo sourceInfoFromDb = get(url);
69 | boolean exist = sourceInfoFromDb != null;
70 | ContentValues contentValues = convert(sourceInfo);
71 | if (exist) {
72 | getWritableDatabase().update(TABLE, contentValues, COLUMN_URL + "=?", new String[]{url});
73 | } else {
74 | getWritableDatabase().insert(TABLE, null, contentValues);
75 | }
76 | }
77 |
78 | @Override
79 | public void release() {
80 | close();
81 | }
82 |
83 | private SourceInfo convert(Cursor cursor) {
84 | return new SourceInfo(
85 | cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_URL)),
86 | cursor.getLong(cursor.getColumnIndexOrThrow(COLUMN_LENGTH)),
87 | cursor.getString(cursor.getColumnIndexOrThrow(COLUMN_MIME))
88 | );
89 | }
90 |
91 | private ContentValues convert(SourceInfo sourceInfo) {
92 | ContentValues values = new ContentValues();
93 | values.put(COLUMN_URL, sourceInfo.url);
94 | values.put(COLUMN_LENGTH, sourceInfo.length);
95 | values.put(COLUMN_MIME, sourceInfo.mime);
96 | return values;
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/sourcestorage/NoSourceInfoStorage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.sourcestorage;
2 |
3 | import com.danikula.videocache.SourceInfo;
4 |
5 | /**
6 | * {@link SourceInfoStorage} that does nothing.
7 | *
8 | * @author Alexey Danilov (danikula@gmail.com).
9 | */
10 | public class NoSourceInfoStorage implements SourceInfoStorage {
11 |
12 | @Override
13 | public SourceInfo get(String url) {
14 | return null;
15 | }
16 |
17 | @Override
18 | public void put(String url, SourceInfo sourceInfo) {
19 | }
20 |
21 | @Override
22 | public void release() {
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/sourcestorage/SourceInfoStorage.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.sourcestorage;
2 |
3 | import com.danikula.videocache.SourceInfo;
4 |
5 | /**
6 | * Storage for {@link SourceInfo}.
7 | *
8 | * @author Alexey Danilov (danikula@gmail.com).
9 | */
10 | public interface SourceInfoStorage {
11 |
12 | SourceInfo get(String url);
13 |
14 | void put(String url, SourceInfo sourceInfo);
15 |
16 | void release();
17 | }
18 |
--------------------------------------------------------------------------------
/library/src/main/java/com/danikula/videocache/sourcestorage/SourceInfoStorageFactory.java:
--------------------------------------------------------------------------------
1 | package com.danikula.videocache.sourcestorage;
2 |
3 | import android.content.Context;
4 |
5 | /**
6 | * Simple factory for {@link SourceInfoStorage}.
7 | *
8 | * @author Alexey Danilov (danikula@gmail.com).
9 | */
10 | public class SourceInfoStorageFactory {
11 |
12 | public static SourceInfoStorage newSourceInfoStorage(Context context) {
13 | return new DatabaseSourceInfoStorage(context);
14 | }
15 |
16 | public static SourceInfoStorage newEmptySourceInfoStorage() {
17 | return new NoSourceInfoStorage();
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | pluginManagement {
2 | repositories {
3 | gradlePluginPortal()
4 | google()
5 | mavenCentral()
6 | }
7 | }
8 | dependencyResolutionManagement {
9 | repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
10 | repositories {
11 | google()
12 | mavenCentral()
13 | }
14 | }
15 | rootProject.name = "VideoCache"
16 | include ':app'
17 | include ':library'
18 |
--------------------------------------------------------------------------------