laoyuyu
6 years ago
parent
39a43c836d
commit
6550647a38
@ -1,81 +0,0 @@ |
||||
package com.arialyy.frame.cache; |
||||
|
||||
import android.text.TextUtils; |
||||
import com.arialyy.frame.util.show.L; |
||||
import java.util.Map; |
||||
import java.util.Set; |
||||
|
||||
/** |
||||
* Created by “AriaLyy@outlook.com” on 2015/4/9. |
||||
*/ |
||||
public class CacheHelp { |
||||
|
||||
/** |
||||
* 设置缓存有效时间 |
||||
*/ |
||||
public static void setCacheAvailableTime(long availableTime) { |
||||
CacheObj.CACHE_INTERVAL = availableTime; |
||||
} |
||||
|
||||
/** |
||||
* 储存缓存 |
||||
*/ |
||||
public static void saveCache(CacheUtil util, String key, String value) { |
||||
if (TextUtils.isEmpty(value)) { |
||||
L.e("缓存数据位null"); |
||||
return; |
||||
} |
||||
CacheObj cache = util.getObjectCache(CacheObj.class, key); |
||||
if (cache == null) { |
||||
cache = new CacheObj(); |
||||
} |
||||
cache.setCacheTime(System.currentTimeMillis()); |
||||
cache.setAvailableNum(cache.getAvailableNum() + 1); |
||||
cache.setData(value); |
||||
util.putObjectCache(CacheObj.class, key, cache); |
||||
} |
||||
|
||||
/** |
||||
* 获取有效的缓存 |
||||
*/ |
||||
public static CacheObj getAvailableCache(CacheUtil util, String url, Map<String, String> param) { |
||||
if (TextUtils.isEmpty(url)) { |
||||
return null; |
||||
} |
||||
String key = getKey(url, param); |
||||
CacheObj cache = util.getObjectCache(CacheObj.class, key); |
||||
if (cache == null) { |
||||
return null; |
||||
} |
||||
if (cache.isAvailable()) { |
||||
return cache; |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
/** |
||||
* 获取缓存，有效或无效 |
||||
*/ |
||||
public static CacheObj getCache(CacheUtil util, String url, Map<String, String> param) { |
||||
if (TextUtils.isEmpty(url)) { |
||||
return null; |
||||
} |
||||
String key = getKey(url, param); |
||||
return util.getObjectCache(CacheObj.class, key); |
||||
} |
||||
|
||||
/** |
||||
* 通过url和请求参数获取key |
||||
*/ |
||||
public static String getKey(String url, Map<String, String> param) { |
||||
if (param == null || param.size() == 0) { |
||||
return url; |
||||
} |
||||
String p = ""; |
||||
for (Map.Entry<String, String> entry : param.entrySet()) { |
||||
p += "[" + entry.getKey() + "," + entry.getValue() + "];"; |
||||
} |
||||
url += ";" + p; |
||||
return url; |
||||
} |
||||
} |
||||
@ -1,56 +0,0 @@ |
||||
package com.arialyy.frame.cache; |
||||
|
||||
/** |
||||
* Created by “AriaLyy@outlook.com” on 2015/4/9. |
||||
* 缓存对象 |
||||
*/ |
||||
class CacheObj { |
||||
/** |
||||
* 缓存有效请求时间 |
||||
*/ |
||||
public static long CACHE_INTERVAL = 120 * 1000; |
||||
/** |
||||
* 缓存有效请求次数 |
||||
*/ |
||||
public static final int CACHE_NUM_INTERVAL = 5; |
||||
private long cacheTime = 0; |
||||
private long availableNum = 0; |
||||
|
||||
private String data; |
||||
|
||||
/** |
||||
* 缓存是否有效 |
||||
*/ |
||||
public boolean isAvailable() { |
||||
if (System.currentTimeMillis() - cacheTime > CACHE_INTERVAL) { |
||||
return false; |
||||
} else if (availableNum >= CACHE_NUM_INTERVAL) { |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
public String getData() { |
||||
return data; |
||||
} |
||||
|
||||
public void setData(String data) { |
||||
this.data = data; |
||||
} |
||||
|
||||
public long getCacheTime() { |
||||
return cacheTime; |
||||
} |
||||
|
||||
public void setCacheTime(long cacheTime) { |
||||
this.cacheTime = cacheTime; |
||||
} |
||||
|
||||
public long getAvailableNum() { |
||||
return availableNum; |
||||
} |
||||
|
||||
public void setAvailableNum(long availableNum) { |
||||
this.availableNum = availableNum; |
||||
} |
||||
} |
||||
@ -1,951 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2011 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.arialyy.frame.cache.diskcache; |
||||
|
||||
import java.io.BufferedWriter; |
||||
import java.io.Closeable; |
||||
import java.io.EOFException; |
||||
import java.io.File; |
||||
import java.io.FileInputStream; |
||||
import java.io.FileNotFoundException; |
||||
import java.io.FileOutputStream; |
||||
import java.io.FilterOutputStream; |
||||
import java.io.IOException; |
||||
import java.io.InputStream; |
||||
import java.io.InputStreamReader; |
||||
import java.io.OutputStream; |
||||
import java.io.OutputStreamWriter; |
||||
import java.io.Writer; |
||||
import java.util.ArrayList; |
||||
import java.util.Iterator; |
||||
import java.util.LinkedHashMap; |
||||
import java.util.Map; |
||||
import java.util.concurrent.Callable; |
||||
import java.util.concurrent.LinkedBlockingQueue; |
||||
import java.util.concurrent.ThreadPoolExecutor; |
||||
import java.util.concurrent.TimeUnit; |
||||
import java.util.regex.Matcher; |
||||
import java.util.regex.Pattern; |
||||
|
||||
/** |
||||
* A cache that uses a bounded amount of space on a filesystem. Each cache |
||||
* entry has a string key and a fixed number of values. Each key must match |
||||
* the regex <strong>[a-z0-9_-]{1,120}</strong>. Values are byte sequences, |
||||
* accessible as streams or files. Each value must be between {@code 0} and |
||||
* {@code Integer.MAX_VALUE} bytes in length. |
||||
* |
||||
* <p>The cache stores its data in a directory on the filesystem. This |
||||
* directory must be exclusive to the cache; the cache may delete or overwrite |
||||
* files from its directory. It is an error for multiple processes to use the |
||||
* same cache directory at the same time. |
||||
* |
||||
* <p>This cache limits the number of bytes that it will store on the |
||||
* filesystem. When the number of stored bytes exceeds the limit, the cache will |
||||
* remove entries in the background until the limit is satisfied. The limit is |
||||
* not strict: the cache may temporarily exceed it while waiting for files to be |
||||
* deleted. The limit does not include filesystem overhead or the cache |
||||
* journal so space-sensitive applications should set a conservative limit. |
||||
* |
||||
* <p>Clients call {@link #edit} to create or update the values of an entry. An |
||||
* entry may have only one editor at one time; if a value is not available to be |
||||
* edited then {@link #edit} will return null. |
||||
* <ul> |
||||
* <li>When an entry is being <strong>created</strong> it is necessary to |
||||
* supply a full set of values; the empty value should be used as a |
||||
* placeholder if necessary. |
||||
* <li>When an entry is being <strong>edited</strong>, it is not necessary |
||||
* to supply data for every value; values default to their previous |
||||
* value. |
||||
* </ul> |
||||
* Every {@link #edit} call must be matched by a call to {@link Editor#commit} |
||||
* or {@link Editor#abort}. Committing is atomic: a read observes the full set |
||||
* of values as they were before or after the commit, but never a mix of values. |
||||
* |
||||
* <p>Clients call {@link #get} to read a snapshot of an entry. The read will |
||||
* observe the value at the time that {@link #get} was called. Updates and |
||||
* removals after the call do not impact ongoing reads. |
||||
* |
||||
* <p>This class is tolerant of some I/O errors. If files are missing from the |
||||
* filesystem, the corresponding entries will be dropped from the cache. If |
||||
* an error occurs while writing a cache value, the edit will fail silently. |
||||
* Callers should handle other problems by catching {@code IOException} and |
||||
* responding appropriately. |
||||
*/ |
||||
public final class DiskLruCache implements Closeable { |
||||
static final String JOURNAL_FILE = "journal"; |
||||
static final String JOURNAL_FILE_TEMP = "journal.tmp"; |
||||
static final String JOURNAL_FILE_BACKUP = "journal.bkp"; |
||||
static final String MAGIC = "libcore.io.DiskLruCache"; |
||||
static final String VERSION_1 = "1"; |
||||
static final long ANY_SEQUENCE_NUMBER = -1; |
||||
static final String STRING_KEY_PATTERN = "[a-z0-9_-]{1,120}"; |
||||
static final Pattern LEGAL_KEY_PATTERN = Pattern.compile(STRING_KEY_PATTERN); |
||||
private static final String CLEAN = "CLEAN"; |
||||
private static final String DIRTY = "DIRTY"; |
||||
private static final String REMOVE = "REMOVE"; |
||||
private static final String READ = "READ"; |
||||
|
||||
/* |
||||
* This cache uses a journal file named "journal". A typical journal file |
||||
* looks like this: |
||||
* libcore.io.DiskLruCache |
||||
* 1 |
||||
* 100 |
||||
* 2 |
||||
* |
||||
* CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054 |
||||
* DIRTY 335c4c6028171cfddfbaae1a9c313c52 |
||||
* CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342 |
||||
* REMOVE 335c4c6028171cfddfbaae1a9c313c52 |
||||
* DIRTY 1ab96a171faeeee38496d8b330771a7a |
||||
* CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234 |
||||
* READ 335c4c6028171cfddfbaae1a9c313c52 |
||||
* READ 3400330d1dfc7f3f7f4b8d4d803dfcf6 |
||||
* |
||||
* The first five lines of the journal form its header. They are the |
||||
* constant string "libcore.io.DiskLruCache", the disk cache's version, |
||||
* the application's version, the value count, and a blank line. |
||||
* |
||||
* Each of the subsequent lines in the file is a record of the state of a |
||||
* cache entry. Each line contains space-separated values: a state, a key, |
||||
* and optional state-specific values. |
||||
* o DIRTY lines track that an entry is actively being created or updated. |
||||
* Every successful DIRTY action should be followed by a CLEAN or REMOVE |
||||
* action. DIRTY lines without a matching CLEAN or REMOVE indicate that |
||||
* temporary files may need to be deleted. |
||||
* o CLEAN lines track a cache entry that has been successfully published |
||||
* and may be read. A publish line is followed by the lengths of each of |
||||
* its values. |
||||
* o READ lines track accesses for LRU. |
||||
* o REMOVE lines track entries that have been deleted. |
||||
* |
||||
* The journal file is appended to as cache operations occur. The journal may |
||||
* occasionally be compacted by dropping redundant lines. A temporary file named |
||||
* "journal.tmp" will be used during compaction; that file should be deleted if |
||||
* it exists when the cache is opened. |
||||
*/ |
||||
|
||||
private final File directory; |
||||
private final File journalFile; |
||||
private final File journalFileTmp; |
||||
private final File journalFileBackup; |
||||
private final int appVersion; |
||||
private long maxSize; |
||||
private final int valueCount; |
||||
private long size = 0; |
||||
private Writer journalWriter; |
||||
private final LinkedHashMap<String, Entry> lruEntries = |
||||
new LinkedHashMap<String, Entry>(0, 0.75f, true); |
||||
private int redundantOpCount; |
||||
|
||||
/** |
||||
* To differentiate between old and current snapshots, each entry is given |
||||
* a sequence number each time an edit is committed. A snapshot is stale if |
||||
* its sequence number is not equal to its entry's sequence number. |
||||
*/ |
||||
private long nextSequenceNumber = 0; |
||||
|
||||
/** This cache uses a single background thread to evict entries. */ |
||||
final ThreadPoolExecutor executorService = |
||||
new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); |
||||
private final Callable<Void> cleanupCallable = new Callable<Void>() { |
||||
public Void call() throws Exception { |
||||
synchronized (DiskLruCache.this) { |
||||
if (journalWriter == null) { |
||||
return null; // Closed.
|
||||
} |
||||
trimToSize(); |
||||
if (journalRebuildRequired()) { |
||||
rebuildJournal(); |
||||
redundantOpCount = 0; |
||||
} |
||||
} |
||||
return null; |
||||
} |
||||
}; |
||||
|
||||
private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) { |
||||
this.directory = directory; |
||||
this.appVersion = appVersion; |
||||
this.journalFile = new File(directory, JOURNAL_FILE); |
||||
this.journalFileTmp = new File(directory, JOURNAL_FILE_TEMP); |
||||
this.journalFileBackup = new File(directory, JOURNAL_FILE_BACKUP); |
||||
this.valueCount = valueCount; |
||||
this.maxSize = maxSize; |
||||
} |
||||
|
||||
/** |
||||
* Opens the cache in {@code directory}, creating a cache if none exists |
||||
* there. |
||||
* |
||||
* @param directory a writable directory |
||||
* @param valueCount the number of values per cache entry. Must be positive. |
||||
* @param maxSize the maximum number of bytes this cache should use to store |
||||
* @throws IOException if reading or writing the cache directory fails |
||||
*/ |
||||
public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize) |
||||
throws IOException { |
||||
if (maxSize <= 0) { |
||||
throw new IllegalArgumentException("maxSize <= 0"); |
||||
} |
||||
if (valueCount <= 0) { |
||||
throw new IllegalArgumentException("valueCount <= 0"); |
||||
} |
||||
|
||||
// If a bkp file exists, use it instead.
|
||||
File backupFile = new File(directory, JOURNAL_FILE_BACKUP); |
||||
if (backupFile.exists()) { |
||||
File journalFile = new File(directory, JOURNAL_FILE); |
||||
// If journal file also exists just delete backup file.
|
||||
if (journalFile.exists()) { |
||||
backupFile.delete(); |
||||
} else { |
||||
renameTo(backupFile, journalFile, false); |
||||
} |
||||
} |
||||
|
||||
// Prefer to pick up where we left off.
|
||||
DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize); |
||||
if (cache.journalFile.exists()) { |
||||
try { |
||||
cache.readJournal(); |
||||
cache.processJournal(); |
||||
return cache; |
||||
} catch (IOException journalIsCorrupt) { |
||||
System.out.println("DiskLruCache " |
||||
+ directory |
||||
+ " is corrupt: " |
||||
+ journalIsCorrupt.getMessage() |
||||
+ ", removing"); |
||||
cache.delete(); |
||||
} |
||||
} |
||||
|
||||
// Create a new empty cache.
|
||||
directory.mkdirs(); |
||||
cache = new DiskLruCache(directory, appVersion, valueCount, maxSize); |
||||
cache.rebuildJournal(); |
||||
return cache; |
||||
} |
||||
|
||||
private void readJournal() throws IOException { |
||||
StrictLineReader reader = |
||||
new StrictLineReader(new FileInputStream(journalFile), DiskLruCacheUtil.US_ASCII); |
||||
try { |
||||
String magic = reader.readLine(); |
||||
String version = reader.readLine(); |
||||
String appVersionString = reader.readLine(); |
||||
String valueCountString = reader.readLine(); |
||||
String blank = reader.readLine(); |
||||
if (!MAGIC.equals(magic) || !VERSION_1.equals(version) || !Integer.toString(appVersion) |
||||
.equals(appVersionString) || !Integer.toString(valueCount).equals(valueCountString) || !"" |
||||
.equals(blank)) { |
||||
throw new IOException("unexpected journal header: [" |
||||
+ magic |
||||
+ ", " |
||||
+ version |
||||
+ ", " |
||||
+ valueCountString |
||||
+ ", " |
||||
+ blank |
||||
+ "]"); |
||||
} |
||||
|
||||
int lineCount = 0; |
||||
while (true) { |
||||
try { |
||||
readJournalLine(reader.readLine()); |
||||
lineCount++; |
||||
} catch (EOFException endOfJournal) { |
||||
break; |
||||
} |
||||
} |
||||
redundantOpCount = lineCount - lruEntries.size(); |
||||
|
||||
// If we ended on a truncated line, rebuild the journal before appending to it.
|
||||
if (reader.hasUnterminatedLine()) { |
||||
rebuildJournal(); |
||||
} else { |
||||
journalWriter = new BufferedWriter( |
||||
new OutputStreamWriter(new FileOutputStream(journalFile, true), |
||||
DiskLruCacheUtil.US_ASCII)); |
||||
} |
||||
} finally { |
||||
DiskLruCacheUtil.closeQuietly(reader); |
||||
} |
||||
} |
||||
|
||||
private void readJournalLine(String line) throws IOException { |
||||
int firstSpace = line.indexOf(' '); |
||||
if (firstSpace == -1) { |
||||
throw new IOException("unexpected journal line: " + line); |
||||
} |
||||
|
||||
int keyBegin = firstSpace + 1; |
||||
int secondSpace = line.indexOf(' ', keyBegin); |
||||
final String key; |
||||
if (secondSpace == -1) { |
||||
key = line.substring(keyBegin); |
||||
if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) { |
||||
lruEntries.remove(key); |
||||
return; |
||||
} |
||||
} else { |
||||
key = line.substring(keyBegin, secondSpace); |
||||
} |
||||
|
||||
Entry entry = lruEntries.get(key); |
||||
if (entry == null) { |
||||
entry = new Entry(key); |
||||
lruEntries.put(key, entry); |
||||
} |
||||
|
||||
if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) { |
||||
String[] parts = line.substring(secondSpace + 1).split(" "); |
||||
entry.readable = true; |
||||
entry.currentEditor = null; |
||||
entry.setLengths(parts); |
||||
} else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) { |
||||
entry.currentEditor = new Editor(entry); |
||||
} else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) { |
||||
// This work was already done by calling lruEntries.get().
|
||||
} else { |
||||
throw new IOException("unexpected journal line: " + line); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Computes the initial size and collects garbage as a part of opening the |
||||
* cache. Dirty entries are assumed to be inconsistent and will be deleted. |
||||
*/ |
||||
private void processJournal() throws IOException { |
||||
deleteIfExists(journalFileTmp); |
||||
for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) { |
||||
Entry entry = i.next(); |
||||
if (entry.currentEditor == null) { |
||||
for (int t = 0; t < valueCount; t++) { |
||||
size += entry.lengths[t]; |
||||
} |
||||
} else { |
||||
entry.currentEditor = null; |
||||
for (int t = 0; t < valueCount; t++) { |
||||
deleteIfExists(entry.getCleanFile(t)); |
||||
deleteIfExists(entry.getDirtyFile(t)); |
||||
} |
||||
i.remove(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Creates a new journal that omits redundant information. This replaces the |
||||
* current journal if it exists. |
||||
*/ |
||||
private synchronized void rebuildJournal() throws IOException { |
||||
if (journalWriter != null) { |
||||
journalWriter.close(); |
||||
} |
||||
|
||||
Writer writer = new BufferedWriter( |
||||
new OutputStreamWriter(new FileOutputStream(journalFileTmp), DiskLruCacheUtil.US_ASCII)); |
||||
try { |
||||
writer.write(MAGIC); |
||||
writer.write("\n"); |
||||
writer.write(VERSION_1); |
||||
writer.write("\n"); |
||||
writer.write(Integer.toString(appVersion)); |
||||
writer.write("\n"); |
||||
writer.write(Integer.toString(valueCount)); |
||||
writer.write("\n"); |
||||
writer.write("\n"); |
||||
|
||||
for (Entry entry : lruEntries.values()) { |
||||
if (entry.currentEditor != null) { |
||||
writer.write(DIRTY + ' ' + entry.key + '\n'); |
||||
} else { |
||||
writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n'); |
||||
} |
||||
} |
||||
} finally { |
||||
writer.close(); |
||||
} |
||||
|
||||
if (journalFile.exists()) { |
||||
renameTo(journalFile, journalFileBackup, true); |
||||
} |
||||
renameTo(journalFileTmp, journalFile, false); |
||||
journalFileBackup.delete(); |
||||
|
||||
journalWriter = new BufferedWriter( |
||||
new OutputStreamWriter(new FileOutputStream(journalFile, true), DiskLruCacheUtil.US_ASCII)); |
||||
} |
||||
|
||||
private static void deleteIfExists(File file) throws IOException { |
||||
if (file.exists() && !file.delete()) { |
||||
throw new IOException(); |
||||
} |
||||
} |
||||
|
||||
private static void renameTo(File from, File to, boolean deleteDestination) throws IOException { |
||||
if (deleteDestination) { |
||||
deleteIfExists(to); |
||||
} |
||||
if (!from.renameTo(to)) { |
||||
throw new IOException(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Returns a snapshot of the entry named {@code key}, or null if it doesn't |
||||
* exist is not currently readable. If a value is returned, it is moved to |
||||
* the head of the LRU queue. |
||||
*/ |
||||
public synchronized Snapshot get(String key) throws IOException { |
||||
checkNotClosed(); |
||||
validateKey(key); |
||||
Entry entry = lruEntries.get(key); |
||||
if (entry == null) { |
||||
return null; |
||||
} |
||||
|
||||
if (!entry.readable) { |
||||
return null; |
||||
} |
||||
|
||||
// Open all streams eagerly to guarantee that we see a single published
|
||||
// snapshot. If we opened streams lazily then the streams could come
|
||||
// from different edits.
|
||||
InputStream[] ins = new InputStream[valueCount]; |
||||
try { |
||||
for (int i = 0; i < valueCount; i++) { |
||||
ins[i] = new FileInputStream(entry.getCleanFile(i)); |
||||
} |
||||
} catch (FileNotFoundException e) { |
||||
// A file must have been deleted manually!
|
||||
for (int i = 0; i < valueCount; i++) { |
||||
if (ins[i] != null) { |
||||
DiskLruCacheUtil.closeQuietly(ins[i]); |
||||
} else { |
||||
break; |
||||
} |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
redundantOpCount++; |
||||
journalWriter.append(READ + ' ' + key + '\n'); |
||||
if (journalRebuildRequired()) { |
||||
executorService.submit(cleanupCallable); |
||||
} |
||||
|
||||
return new Snapshot(key, entry.sequenceNumber, ins, entry.lengths); |
||||
} |
||||
|
||||
/** |
||||
* Returns an editor for the entry named {@code key}, or null if another |
||||
* edit is in progress. |
||||
*/ |
||||
public Editor edit(String key) throws IOException { |
||||
return edit(key, ANY_SEQUENCE_NUMBER); |
||||
} |
||||
|
||||
private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException { |
||||
checkNotClosed(); |
||||
validateKey(key); |
||||
Entry entry = lruEntries.get(key); |
||||
if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null |
||||
|| entry.sequenceNumber != expectedSequenceNumber)) { |
||||
return null; // Snapshot is stale.
|
||||
} |
||||
if (entry == null) { |
||||
entry = new Entry(key); |
||||
lruEntries.put(key, entry); |
||||
} else if (entry.currentEditor != null) { |
||||
return null; // Another edit is in progress.
|
||||
} |
||||
|
||||
Editor editor = new Editor(entry); |
||||
entry.currentEditor = editor; |
||||
|
||||
// Flush the journal before creating files to prevent file leaks.
|
||||
journalWriter.write(DIRTY + ' ' + key + '\n'); |
||||
journalWriter.flush(); |
||||
return editor; |
||||
} |
||||
|
||||
/** Returns the directory where this cache stores its data. */ |
||||
public File getDirectory() { |
||||
return directory; |
||||
} |
||||
|
||||
/** |
||||
* Returns the maximum number of bytes that this cache should use to store |
||||
* its data. |
||||
*/ |
||||
public synchronized long getMaxSize() { |
||||
return maxSize; |
||||
} |
||||
|
||||
/** |
||||
* Changes the maximum number of bytes the cache can store and queues a job |
||||
* to trim the existing store, if necessary. |
||||
*/ |
||||
public synchronized void setMaxSize(long maxSize) { |
||||
this.maxSize = maxSize; |
||||
executorService.submit(cleanupCallable); |
||||
} |
||||
|
||||
/** |
||||
* Returns the number of bytes currently being used to store the values in |
||||
* this cache. This may be greater than the max size if a background |
||||
* deletion is pending. |
||||
*/ |
||||
public synchronized long size() { |
||||
return size; |
||||
} |
||||
|
||||
private synchronized void completeEdit(Editor editor, boolean success) throws IOException { |
||||
Entry entry = editor.entry; |
||||
if (entry.currentEditor != editor) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
|
||||
// If this edit is creating the entry for the first time, every index must have a value.
|
||||
if (success && !entry.readable) { |
||||
for (int i = 0; i < valueCount; i++) { |
||||
if (!editor.written[i]) { |
||||
editor.abort(); |
||||
throw new IllegalStateException("Newly created entry didn't create value for index " + i); |
||||
} |
||||
if (!entry.getDirtyFile(i).exists()) { |
||||
editor.abort(); |
||||
return; |
||||
} |
||||
} |
||||
} |
||||
|
||||
for (int i = 0; i < valueCount; i++) { |
||||
File dirty = entry.getDirtyFile(i); |
||||
if (success) { |
||||
if (dirty.exists()) { |
||||
File clean = entry.getCleanFile(i); |
||||
dirty.renameTo(clean); |
||||
long oldLength = entry.lengths[i]; |
||||
long newLength = clean.length(); |
||||
entry.lengths[i] = newLength; |
||||
size = size - oldLength + newLength; |
||||
} |
||||
} else { |
||||
deleteIfExists(dirty); |
||||
} |
||||
} |
||||
|
||||
redundantOpCount++; |
||||
entry.currentEditor = null; |
||||
if (entry.readable | success) { |
||||
entry.readable = true; |
||||
journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n'); |
||||
if (success) { |
||||
entry.sequenceNumber = nextSequenceNumber++; |
||||
} |
||||
} else { |
||||
lruEntries.remove(entry.key); |
||||
journalWriter.write(REMOVE + ' ' + entry.key + '\n'); |
||||
} |
||||
journalWriter.flush(); |
||||
|
||||
if (size > maxSize || journalRebuildRequired()) { |
||||
executorService.submit(cleanupCallable); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* We only rebuild the journal when it will halve the size of the journal |
||||
* and eliminate at least 2000 ops. |
||||
*/ |
||||
private boolean journalRebuildRequired() { |
||||
final int redundantOpCompactThreshold = 2000; |
||||
return redundantOpCount >= redundantOpCompactThreshold //
|
||||
&& redundantOpCount >= lruEntries.size(); |
||||
} |
||||
|
||||
/** |
||||
* Drops the entry for {@code key} if it exists and can be removed. Entries |
||||
* actively being edited cannot be removed. |
||||
* |
||||
* @return true if an entry was removed. |
||||
*/ |
||||
public synchronized boolean remove(String key) throws IOException { |
||||
checkNotClosed(); |
||||
validateKey(key); |
||||
Entry entry = lruEntries.get(key); |
||||
if (entry == null || entry.currentEditor != null) { |
||||
return false; |
||||
} |
||||
|
||||
for (int i = 0; i < valueCount; i++) { |
||||
File file = entry.getCleanFile(i); |
||||
if (file.exists() && !file.delete()) { |
||||
throw new IOException("failed to delete " + file); |
||||
} |
||||
size -= entry.lengths[i]; |
||||
entry.lengths[i] = 0; |
||||
} |
||||
|
||||
redundantOpCount++; |
||||
journalWriter.append(REMOVE + ' ' + key + '\n'); |
||||
lruEntries.remove(key); |
||||
|
||||
if (journalRebuildRequired()) { |
||||
executorService.submit(cleanupCallable); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
/** Returns true if this cache has been closed. */ |
||||
public synchronized boolean isClosed() { |
||||
return journalWriter == null; |
||||
} |
||||
|
||||
private void checkNotClosed() { |
||||
if (journalWriter == null) { |
||||
throw new IllegalStateException("cache is closed"); |
||||
} |
||||
} |
||||
|
||||
/** Force buffered operations to the filesystem. */ |
||||
public synchronized void flush() throws IOException { |
||||
checkNotClosed(); |
||||
trimToSize(); |
||||
journalWriter.flush(); |
||||
} |
||||
|
||||
/** Closes this cache. Stored values will remain on the filesystem. */ |
||||
public synchronized void close() throws IOException { |
||||
if (journalWriter == null) { |
||||
return; // Already closed.
|
||||
} |
||||
for (Entry entry : new ArrayList<Entry>(lruEntries.values())) { |
||||
if (entry.currentEditor != null) { |
||||
entry.currentEditor.abort(); |
||||
} |
||||
} |
||||
trimToSize(); |
||||
journalWriter.close(); |
||||
journalWriter = null; |
||||
} |
||||
|
||||
private void trimToSize() throws IOException { |
||||
while (size > maxSize) { |
||||
Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next(); |
||||
remove(toEvict.getKey()); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Closes the cache and deletes all of its stored values. This will delete |
||||
* all files in the cache directory including files that weren't created by |
||||
* the cache. |
||||
*/ |
||||
public void delete() throws IOException { |
||||
close(); |
||||
DiskLruCacheUtil.deleteContents(directory); |
||||
} |
||||
|
||||
private void validateKey(String key) { |
||||
Matcher matcher = LEGAL_KEY_PATTERN.matcher(key); |
||||
if (!matcher.matches()) { |
||||
throw new IllegalArgumentException( |
||||
"keys must match regex " + STRING_KEY_PATTERN + ": \"" + key + "\""); |
||||
} |
||||
} |
||||
|
||||
private static String inputStreamToString(InputStream in) throws IOException { |
||||
return DiskLruCacheUtil.readFully(new InputStreamReader(in, DiskLruCacheUtil.UTF_8)); |
||||
} |
||||
|
||||
/** A snapshot of the values for an entry. */ |
||||
public final class Snapshot implements Closeable { |
||||
private final String key; |
||||
private final long sequenceNumber; |
||||
private final InputStream[] ins; |
||||
private final long[] lengths; |
||||
|
||||
private Snapshot(String key, long sequenceNumber, InputStream[] ins, long[] lengths) { |
||||
this.key = key; |
||||
this.sequenceNumber = sequenceNumber; |
||||
this.ins = ins; |
||||
this.lengths = lengths; |
||||
} |
||||
|
||||
/** |
||||
* Returns an editor for this snapshot's entry, or null if either the |
||||
* entry has changed since this snapshot was created or if another edit |
||||
* is in progress. |
||||
*/ |
||||
public Editor edit() throws IOException { |
||||
return DiskLruCache.this.edit(key, sequenceNumber); |
||||
} |
||||
|
||||
/** Returns the unbuffered stream with the value for {@code index}. */ |
||||
public InputStream getInputStream(int index) { |
||||
return ins[index]; |
||||
} |
||||
|
||||
/** Returns the string value for {@code index}. */ |
||||
public String getString(int index) throws IOException { |
||||
return inputStreamToString(getInputStream(index)); |
||||
} |
||||
|
||||
/** Returns the byte length of the value for {@code index}. */ |
||||
public long getLength(int index) { |
||||
return lengths[index]; |
||||
} |
||||
|
||||
public void close() { |
||||
for (InputStream in : ins) { |
||||
DiskLruCacheUtil.closeQuietly(in); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private static final OutputStream NULL_OUTPUT_STREAM = new OutputStream() { |
||||
@Override public void write(int b) throws IOException { |
||||
// Eat all writes silently. Nom nom.
|
||||
} |
||||
}; |
||||
|
||||
/** Edits the values for an entry. */ |
||||
public final class Editor { |
||||
private final Entry entry; |
||||
private final boolean[] written; |
||||
private boolean hasErrors; |
||||
private boolean committed; |
||||
|
||||
private Editor(Entry entry) { |
||||
this.entry = entry; |
||||
this.written = (entry.readable) ? null : new boolean[valueCount]; |
||||
} |
||||
|
||||
/** |
||||
* Returns an unbuffered input stream to read the last committed value, |
||||
* or null if no value has been committed. |
||||
*/ |
||||
public InputStream newInputStream(int index) throws IOException { |
||||
synchronized (DiskLruCache.this) { |
||||
if (entry.currentEditor != this) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
if (!entry.readable) { |
||||
return null; |
||||
} |
||||
try { |
||||
return new FileInputStream(entry.getCleanFile(index)); |
||||
} catch (FileNotFoundException e) { |
||||
return null; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Returns the last committed value as a string, or null if no value |
||||
* has been committed. |
||||
*/ |
||||
public String getString(int index) throws IOException { |
||||
InputStream in = newInputStream(index); |
||||
return in != null ? inputStreamToString(in) : null; |
||||
} |
||||
|
||||
/** |
||||
* Returns a new unbuffered output stream to write the value at |
||||
* {@code index}. If the underlying output stream encounters errors |
||||
* when writing to the filesystem, this edit will be aborted when |
||||
* {@link #commit} is called. The returned output stream does not throw |
||||
* IOExceptions. |
||||
*/ |
||||
public OutputStream newOutputStream(int index) throws IOException { |
||||
if (index < 0 || index >= valueCount) { |
||||
throw new IllegalArgumentException("Expected index " |
||||
+ index |
||||
+ " to " |
||||
+ "be greater than 0 and less than the maximum value count " |
||||
+ "of " |
||||
+ valueCount); |
||||
} |
||||
synchronized (DiskLruCache.this) { |
||||
if (entry.currentEditor != this) { |
||||
throw new IllegalStateException(); |
||||
} |
||||
if (!entry.readable) { |
||||
written[index] = true; |
||||
} |
||||
File dirtyFile = entry.getDirtyFile(index); |
||||
FileOutputStream outputStream; |
||||
try { |
||||
outputStream = new FileOutputStream(dirtyFile); |
||||
} catch (FileNotFoundException e) { |
||||
// Attempt to recreate the cache directory.
|
||||
directory.mkdirs(); |
||||
try { |
||||
outputStream = new FileOutputStream(dirtyFile); |
||||
} catch (FileNotFoundException e2) { |
||||
// We are unable to recover. Silently eat the writes.
|
||||
return NULL_OUTPUT_STREAM; |
||||
} |
||||
} |
||||
return new FaultHidingOutputStream(outputStream); |
||||
} |
||||
} |
||||
|
||||
/** Sets the value at {@code index} to {@code value}. */ |
||||
public void set(int index, String value) throws IOException { |
||||
Writer writer = null; |
||||
try { |
||||
writer = new OutputStreamWriter(newOutputStream(index), DiskLruCacheUtil.UTF_8); |
||||
writer.write(value); |
||||
} finally { |
||||
DiskLruCacheUtil.closeQuietly(writer); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Commits this edit so it is visible to readers. This releases the |
||||
* edit lock so another edit may be started on the same key. |
||||
*/ |
||||
public void commit() throws IOException { |
||||
if (hasErrors) { |
||||
completeEdit(this, false); |
||||
remove(entry.key); // The previous entry is stale.
|
||||
} else { |
||||
completeEdit(this, true); |
||||
} |
||||
committed = true; |
||||
} |
||||
|
||||
/** |
||||
* Aborts this edit. This releases the edit lock so another edit may be |
||||
* started on the same key. |
||||
*/ |
||||
public void abort() throws IOException { |
||||
completeEdit(this, false); |
||||
} |
||||
|
||||
public void abortUnlessCommitted() { |
||||
if (!committed) { |
||||
try { |
||||
abort(); |
||||
} catch (IOException ignored) { |
||||
} |
||||
} |
||||
} |
||||
|
||||
private class FaultHidingOutputStream extends FilterOutputStream { |
||||
private FaultHidingOutputStream(OutputStream out) { |
||||
super(out); |
||||
} |
||||
|
||||
@Override public void write(int oneByte) { |
||||
try { |
||||
out.write(oneByte); |
||||
} catch (IOException e) { |
||||
hasErrors = true; |
||||
} |
||||
} |
||||
|
||||
@Override public void write(byte[] buffer, int offset, int length) { |
||||
try { |
||||
out.write(buffer, offset, length); |
||||
} catch (IOException e) { |
||||
hasErrors = true; |
||||
} |
||||
} |
||||
|
||||
@Override public void close() { |
||||
try { |
||||
out.close(); |
||||
} catch (IOException e) { |
||||
hasErrors = true; |
||||
} |
||||
} |
||||
|
||||
@Override public void flush() { |
||||
try { |
||||
out.flush(); |
||||
} catch (IOException e) { |
||||
hasErrors = true; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
private final class Entry { |
||||
private final String key; |
||||
|
||||
/** Lengths of this entry's files. */ |
||||
private final long[] lengths; |
||||
|
||||
/** True if this entry has ever been published. */ |
||||
private boolean readable; |
||||
|
||||
/** The ongoing edit or null if this entry is not being edited. */ |
||||
private Editor currentEditor; |
||||
|
||||
/** The sequence number of the most recently committed edit to this entry. */ |
||||
private long sequenceNumber; |
||||
|
||||
private Entry(String key) { |
||||
this.key = key; |
||||
this.lengths = new long[valueCount]; |
||||
} |
||||
|
||||
public String getLengths() throws IOException { |
||||
StringBuilder result = new StringBuilder(); |
||||
for (long size : lengths) { |
||||
result.append(' ').append(size); |
||||
} |
||||
return result.toString(); |
||||
} |
||||
|
||||
/** Set lengths using decimal numbers like "10123". */ |
||||
private void setLengths(String[] strings) throws IOException { |
||||
if (strings.length != valueCount) { |
||||
throw invalidLengths(strings); |
||||
} |
||||
|
||||
try { |
||||
for (int i = 0; i < strings.length; i++) { |
||||
lengths[i] = Long.parseLong(strings[i]); |
||||
} |
||||
} catch (NumberFormatException e) { |
||||
throw invalidLengths(strings); |
||||
} |
||||
} |
||||
|
||||
private IOException invalidLengths(String[] strings) throws IOException { |
||||
throw new IOException("unexpected journal line: " + java.util.Arrays.toString(strings)); |
||||
} |
||||
|
||||
public File getCleanFile(int i) { |
||||
return new File(directory, key + "." + i); |
||||
} |
||||
|
||||
public File getDirtyFile(int i) { |
||||
return new File(directory, key + "." + i + ".tmp"); |
||||
} |
||||
} |
||||
} |
||||
@ -1,77 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2010 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.arialyy.frame.cache.diskcache; |
||||
|
||||
import java.io.Closeable; |
||||
import java.io.File; |
||||
import java.io.IOException; |
||||
import java.io.Reader; |
||||
import java.io.StringWriter; |
||||
import java.nio.charset.Charset; |
||||
|
||||
/** Junk drawer of utility methods. */ |
||||
final class DiskLruCacheUtil { |
||||
static final Charset US_ASCII = Charset.forName("US-ASCII"); |
||||
static final Charset UTF_8 = Charset.forName("UTF-8"); |
||||
|
||||
private DiskLruCacheUtil() { |
||||
} |
||||
|
||||
static String readFully(Reader reader) throws IOException { |
||||
try { |
||||
StringWriter writer = new StringWriter(); |
||||
char[] buffer = new char[1024]; |
||||
int count; |
||||
while ((count = reader.read(buffer)) != -1) { |
||||
writer.write(buffer, 0, count); |
||||
} |
||||
return writer.toString(); |
||||
} finally { |
||||
reader.close(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Deletes the contents of {@code dir}. Throws an IOException if any file |
||||
* could not be deleted, or if {@code dir} is not a readable directory. |
||||
*/ |
||||
static void deleteContents(File dir) throws IOException { |
||||
File[] files = dir.listFiles(); |
||||
if (files == null) { |
||||
throw new IOException("not a readable directory: " + dir); |
||||
} |
||||
for (File file : files) { |
||||
if (file.isDirectory()) { |
||||
deleteContents(file); |
||||
} |
||||
if (!file.delete()) { |
||||
throw new IOException("failed to delete file: " + file); |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void closeQuietly(/*Auto*/Closeable closeable) { |
||||
if (closeable != null) { |
||||
try { |
||||
closeable.close(); |
||||
} catch (RuntimeException rethrown) { |
||||
throw rethrown; |
||||
} catch (Exception ignored) { |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -1,194 +0,0 @@ |
||||
/* |
||||
* 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.arialyy.frame.cache.diskcache; |
||||
|
||||
import java.io.ByteArrayOutputStream; |
||||
import java.io.Closeable; |
||||
import java.io.EOFException; |
||||
import java.io.IOException; |
||||
import java.io.InputStream; |
||||
import java.io.UnsupportedEncodingException; |
||||
import java.nio.charset.Charset; |
||||
|
||||
/** |
||||
* Buffers input from an {@link InputStream} for reading lines. |
||||
* |
||||
* <p>This class is used for buffered reading of lines. For purposes of this class, a line ends |
||||
* with "\n" or "\r\n". End of input is reported by throwing {@code EOFException}. Unterminated |
||||
* line at end of input is invalid and will be ignored, the caller may use {@code |
||||
* hasUnterminatedLine()} to detect it after catching the {@code EOFException}. |
||||
* |
||||
* <p>This class is intended for reading input that strictly consists of lines, such as line-based |
||||
* cache entries or cache journal. Unlike the {@link java.io.BufferedReader} which in conjunction |
||||
* with {@link java.io.InputStreamReader} provides similar functionality, this class uses different |
||||
* end-of-input reporting and a more restrictive definition of a line. |
||||
* |
||||
* <p>This class supports only charsets that encode '\r' and '\n' as a single byte with value 13 |
||||
* and 10, respectively, and the representation of no other character contains these values. |
||||
* We currently check in constructor that the charset is one of US-ASCII, UTF-8 and ISO-8859-1. |
||||
* The default charset is US_ASCII. |
||||
*/ |
||||
class StrictLineReader implements Closeable { |
||||
private static final byte CR = (byte) '\r'; |
||||
private static final byte LF = (byte) '\n'; |
||||
|
||||
private final InputStream in; |
||||
private final Charset charset; |
||||
|
||||
/* |
||||
* Buffered data is stored in {@code buf}. As long as no exception occurs, 0 <= pos <= end |
||||
* and the data in the range [pos, end) is buffered for reading. At end of input, if there is |
||||
* an unterminated line, we set end == -1, otherwise end == pos. If the underlying |
||||
* {@code InputStream} throws an {@code IOException}, end may remain as either pos or -1. |
||||
*/ |
||||
private byte[] buf; |
||||
private int pos; |
||||
private int end; |
||||
|
||||
/** |
||||
* Constructs a new {@code LineReader} with the specified charset and the default capacity. |
||||
* |
||||
* @param in the {@code InputStream} to read data from. |
||||
* @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are |
||||
* supported. |
||||
* @throws NullPointerException if {@code in} or {@code charset} is null. |
||||
* @throws IllegalArgumentException if the specified charset is not supported. |
||||
*/ |
||||
public StrictLineReader(InputStream in, Charset charset) { |
||||
this(in, 8192, charset); |
||||
} |
||||
|
||||
/** |
||||
* Constructs a new {@code LineReader} with the specified capacity and charset. |
||||
* |
||||
* @param in the {@code InputStream} to read data from. |
||||
* @param capacity the capacity of the buffer. |
||||
* @param charset the charset used to decode data. Only US-ASCII, UTF-8 and ISO-8859-1 are |
||||
* supported. |
||||
* @throws NullPointerException if {@code in} or {@code charset} is null. |
||||
* @throws IllegalArgumentException if {@code capacity} is negative or zero |
||||
* or the specified charset is not supported. |
||||
*/ |
||||
public StrictLineReader(InputStream in, int capacity, Charset charset) { |
||||
if (in == null || charset == null) { |
||||
throw new NullPointerException(); |
||||
} |
||||
if (capacity < 0) { |
||||
throw new IllegalArgumentException("capacity <= 0"); |
||||
} |
||||
if (!(charset.equals(DiskLruCacheUtil.US_ASCII))) { |
||||
throw new IllegalArgumentException("Unsupported encoding"); |
||||
} |
||||
|
||||
this.in = in; |
||||
this.charset = charset; |
||||
buf = new byte[capacity]; |
||||
} |
||||
|
||||
/** |
||||
* Closes the reader by closing the underlying {@code InputStream} and |
||||
* marking this reader as closed. |
||||
* |
||||
* @throws IOException for errors when closing the underlying {@code InputStream}. |
||||
*/ |
||||
public void close() throws IOException { |
||||
synchronized (in) { |
||||
if (buf != null) { |
||||
buf = null; |
||||
in.close(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"}, |
||||
* this end of line marker is not included in the result. |
||||
* |
||||
* @return the next line from the input. |
||||
* @throws IOException for underlying {@code InputStream} errors. |
||||
* @throws EOFException for the end of source stream. |
||||
*/ |
||||
public String readLine() throws IOException { |
||||
synchronized (in) { |
||||
if (buf == null) { |
||||
throw new IOException("LineReader is closed"); |
||||
} |
||||
|
||||
// Read more data if we are at the end of the buffered data.
|
||||
// Though it's an error to read after an exception, we will let {@code fillBuf()}
|
||||
// throw again if that happens; thus we need to handle end == -1 as well as end == pos.
|
||||
if (pos >= end) { |
||||
fillBuf(); |
||||
} |
||||
// Try to find LF in the buffered data and return the line if successful.
|
||||
for (int i = pos; i != end; ++i) { |
||||
if (buf[i] == LF) { |
||||
int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i; |
||||
String res = new String(buf, pos, lineEnd - pos, charset.name()); |
||||
pos = i + 1; |
||||
return res; |
||||
} |
||||
} |
||||
|
||||
// Let's anticipate up to 80 characters on top of those already read.
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) { |
||||
@Override public String toString() { |
||||
int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count; |
||||
try { |
||||
return new String(buf, 0, length, charset.name()); |
||||
} catch (UnsupportedEncodingException e) { |
||||
throw new AssertionError(e); // Since we control the charset this will never happen.
|
||||
} |
||||
} |
||||
}; |
||||
|
||||
while (true) { |
||||
out.write(buf, pos, end - pos); |
||||
// Mark unterminated line in case fillBuf throws EOFException or IOException.
|
||||
end = -1; |
||||
fillBuf(); |
||||
// Try to find LF in the buffered data and return the line if successful.
|
||||
for (int i = pos; i != end; ++i) { |
||||
if (buf[i] == LF) { |
||||
if (i != pos) { |
||||
out.write(buf, pos, i - pos); |
||||
} |
||||
pos = i + 1; |
||||
return out.toString(); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
public boolean hasUnterminatedLine() { |
||||
return end == -1; |
||||
} |
||||
|
||||
/** |
||||
* Reads new input data into the buffer. Call only with pos == end or end == -1, |
||||
* depending on the desired outcome if the function throws. |
||||
*/ |
||||
private void fillBuf() throws IOException { |
||||
int result = in.read(buf, 0, buf.length); |
||||
if (result == -1) { |
||||
throw new EOFException(); |
||||
} |
||||
pos = 0; |
||||
end = result; |
||||
} |
||||
} |
||||
@ -0,0 +1,361 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.common; |
||||
|
||||
import com.arialyy.aria.core.config.Configuration; |
||||
import com.arialyy.aria.core.download.DownloadEntity; |
||||
import com.arialyy.aria.core.inf.AbsNormalEntity; |
||||
import com.arialyy.aria.core.inf.AbsTaskWrapper; |
||||
import com.arialyy.aria.core.upload.UploadEntity; |
||||
import com.arialyy.aria.orm.DbEntity; |
||||
import com.arialyy.aria.util.ALog; |
||||
import com.arialyy.aria.util.CommonUtil; |
||||
import com.arialyy.aria.util.DbDataHelper; |
||||
import java.io.File; |
||||
import java.util.ArrayList; |
||||
import java.util.HashSet; |
||||
import java.util.List; |
||||
import java.util.Properties; |
||||
import java.util.Set; |
||||
|
||||
/** |
||||
* 处理任务记录，分配线程区间 |
||||
*/ |
||||
public class RecordHandler { |
||||
|
||||
public static final int TYPE_DOWNLOAD = 1; |
||||
public static final int TYPE_UPLOAD = 2; |
||||
private final String TAG = "RecordHandler"; |
||||
|
||||
private static final String STATE = "_state_"; |
||||
private static final String RECORD = "_record_"; |
||||
/** |
||||
* 小于1m的文件不启用多线程 |
||||
*/ |
||||
private static final long SUB_LEN = 1024 * 1024; |
||||
|
||||
/** |
||||
* 分块文件路径 |
||||
*/ |
||||
public static final String SUB_PATH = "%s.%s.part"; |
||||
|
||||
@Deprecated private File mConfigFile; |
||||
private TaskRecord mRecord; |
||||
private AbsTaskWrapper mTaskWrapper; |
||||
private AbsNormalEntity mEntity; |
||||
|
||||
RecordHandler(AbsTaskWrapper wrapper) { |
||||
mTaskWrapper = wrapper; |
||||
mEntity = (AbsNormalEntity) mTaskWrapper.getEntity(); |
||||
} |
||||
|
||||
/** |
||||
* 获取任务记录，如果任务记录存在，检查任务记录 |
||||
* 检查记录 对于分块任务： 子分块不存在或被删除，子线程将重新下载 |
||||
* 对于普通任务： 预下载文件不存在，则任务任务呗删除 |
||||
* 如果任务记录不存在或线程记录不存在，初始化记录 |
||||
* |
||||
* @return 任务记录 |
||||
*/ |
||||
TaskRecord getRecord() { |
||||
mConfigFile = new File(CommonUtil.getFileConfigPath(false, mEntity.getFileName())); |
||||
if (mConfigFile.exists()) { |
||||
convertDb(); |
||||
} else { |
||||
mRecord = DbDataHelper.getTaskRecord(getFilePath()); |
||||
if (mRecord == null) { |
||||
initRecord(true); |
||||
} else { |
||||
if (mRecord.threadRecords == null || mRecord.threadRecords.isEmpty()) { |
||||
initRecord(false); |
||||
} else if (mRecord.isBlock) { |
||||
handleBlockRecord(); |
||||
} else if (!mTaskWrapper.isSupportBP()) { |
||||
handleNoSupportBPRecord(); |
||||
} else { |
||||
handleSingleThreadRecord(); |
||||
} |
||||
} |
||||
} |
||||
saveRecord(); |
||||
return mRecord; |
||||
} |
||||
|
||||
/** |
||||
* 处理不支持断点的记录 |
||||
*/ |
||||
private void handleNoSupportBPRecord() { |
||||
ThreadRecord tr = mRecord.threadRecords.get(0); |
||||
tr.startLocation = 0; |
||||
tr.endLocation = mEntity.getFileSize(); |
||||
tr.key = mRecord.filePath; |
||||
tr.blockLen = tr.endLocation; |
||||
tr.isComplete = false; |
||||
} |
||||
|
||||
/** |
||||
* 处理单线程的任务的记录 |
||||
*/ |
||||
private void handleSingleThreadRecord() { |
||||
File file = new File(mRecord.filePath); |
||||
ThreadRecord tr = mRecord.threadRecords.get(0); |
||||
if (!file.exists()) { |
||||
ALog.w(TAG, String.format("文件【%s】不存在，任务将重新开始", file.getPath())); |
||||
tr.startLocation = 0; |
||||
tr.isComplete = false; |
||||
tr.endLocation = mEntity.getFileSize(); |
||||
} else if (mRecord.isOpenDynamicFile) { |
||||
if (file.length() > mEntity.getFileSize()) { |
||||
ALog.i(TAG, String.format("文件【%s】错误，任务重新开始", file.getPath())); |
||||
file.delete(); |
||||
tr.startLocation = 0; |
||||
tr.isComplete = false; |
||||
tr.endLocation = mEntity.getFileSize(); |
||||
} else if (file.length() == mEntity.getFileSize()) { |
||||
tr.isComplete = true; |
||||
} else { |
||||
if (file.length() != tr.startLocation) { |
||||
ALog.i(TAG, String.format("修正【%s】的进度记录为：%s", file.getPath(), file.length())); |
||||
tr.startLocation = file.length(); |
||||
tr.isComplete = false; |
||||
} |
||||
} |
||||
} |
||||
mTaskWrapper.setNewTask(false); |
||||
} |
||||
|
||||
/** |
||||
* 处理分块任务的记录，分块文件（blockFileLen）长度必须需要小于等于线程区间（threadRectLen）的长度 |
||||
*/ |
||||
private void handleBlockRecord() { |
||||
// 默认线程分块长度
|
||||
long normalRectLen = mEntity.getFileSize() / mRecord.threadRecords.size(); |
||||
for (ThreadRecord tr : mRecord.threadRecords) { |
||||
long threadRect = tr.blockLen; |
||||
|
||||
File temp = new File(String.format(SUB_PATH, mRecord.filePath, tr.threadId)); |
||||
if (!temp.exists()) { |
||||
ALog.i(TAG, String.format("分块文件【%s】不存在，该分块将重新开始", temp.getPath())); |
||||
tr.isComplete = false; |
||||
tr.startLocation = tr.threadId * normalRectLen; |
||||
} else { |
||||
if (!tr.isComplete) { |
||||
ALog.i(TAG, String.format( |
||||
"startLocation = %s; endLocation = %s; block = %s; tempLen = %s; threadId = %s", |
||||
tr.startLocation, tr.endLocation, threadRect, temp.length(), tr.threadId)); |
||||
|
||||
long blockFileLen = temp.length(); // 磁盘中的分块文件长度
|
||||
/* |
||||
* 检查磁盘中的分块文件 |
||||
*/ |
||||
if (blockFileLen > threadRect) { |
||||
ALog.i(TAG, String.format("分块【%s】错误，分块长度【%s】 > 线程区间长度【%s】，将重新开始该分块", |
||||
tr.threadId, blockFileLen, threadRect)); |
||||
temp.delete(); |
||||
tr.startLocation = tr.threadId * threadRect; |
||||
continue; |
||||
} |
||||
|
||||
long realLocation = |
||||
tr.threadId * normalRectLen + blockFileLen; //正常情况下，该线程的startLocation的位置
|
||||
/* |
||||
* 检查记录文件 |
||||
*/ |
||||
if (blockFileLen == threadRect) { |
||||
ALog.i(TAG, String.format("分块【%s】已完成，更新记录", temp.getPath())); |
||||
tr.startLocation = blockFileLen; |
||||
tr.isComplete = true; |
||||
} else if (tr.startLocation != realLocation) { // 处理记录小于分块文件长度的情况
|
||||
ALog.i(TAG, String.format("修正分块【%s】的进度记录为：%s", temp.getPath(), realLocation)); |
||||
tr.startLocation = realLocation; |
||||
} |
||||
} else { |
||||
ALog.i(TAG, String.format("分块【%s】已完成", temp.getPath())); |
||||
} |
||||
} |
||||
} |
||||
mTaskWrapper.setNewTask(false); |
||||
} |
||||
|
||||
/** |
||||
* convertDb 是兼容性代码 从3.4.1开始，线程配置信息将存储在数据库中。 将配置文件的内容复制到数据库中，并将配置文件删除 |
||||
*/ |
||||
private void convertDb() { |
||||
List<RecordWrapper> records = |
||||
DbEntity.findRelationData(RecordWrapper.class, "TaskRecord.filePath=?", |
||||
getFilePath()); |
||||
if (records == null || records.size() == 0) { |
||||
Properties pro = CommonUtil.loadConfig(mConfigFile); |
||||
if (pro.isEmpty()) { |
||||
ALog.d(TAG, "老版本的线程记录为空，任务为新任务"); |
||||
initRecord(true); |
||||
return; |
||||
} |
||||
|
||||
Set<Object> keys = pro.keySet(); |
||||
// 老版本记录是5s存一次，但是5s中内，如果线程执行完成，record记录是没有的，只有state记录...
|
||||
// 第一步应该是record 和 state去重取正确的线程数
|
||||
Set<Integer> set = new HashSet<>(); |
||||
for (Object key : keys) { |
||||
String str = String.valueOf(key); |
||||
int i = Integer.parseInt(str.substring(str.length() - 1)); |
||||
set.add(i); |
||||
} |
||||
int threadNum = set.size(); |
||||
if (threadNum == 0) { |
||||
ALog.d(TAG, "线程数为空，任务为新任务"); |
||||
initRecord(true); |
||||
return; |
||||
} |
||||
mTaskWrapper.setNewTask(false); |
||||
mRecord = createTaskRecord(threadNum); |
||||
mRecord.isOpenDynamicFile = false; |
||||
mRecord.isBlock = false; |
||||
File tempFile = new File(getFilePath()); |
||||
for (int i = 0; i < threadNum; i++) { |
||||
ThreadRecord tRecord = new ThreadRecord(); |
||||
tRecord.key = mRecord.filePath; |
||||
Object state = pro.getProperty(tempFile.getName() + STATE + i); |
||||
Object record = pro.getProperty(tempFile.getName() + RECORD + i); |
||||
if (state != null && Integer.parseInt(String.valueOf(state)) == 1) { |
||||
tRecord.isComplete = true; |
||||
continue; |
||||
} |
||||
if (record != null) { |
||||
long temp = Long.parseLong(String.valueOf(record)); |
||||
tRecord.startLocation = temp > 0 ? temp : 0; |
||||
} else { |
||||
tRecord.startLocation = 0; |
||||
} |
||||
mRecord.threadRecords.add(tRecord); |
||||
} |
||||
mConfigFile.delete(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* 初始化任务记录，分配线程区间 |
||||
* |
||||
* @param newRecord {@code true} 需要创建新{@link TaskRecord} |
||||
*/ |
||||
private void initRecord(boolean newRecord) { |
||||
if (newRecord) { |
||||
mRecord = createTaskRecord(getNewTaskThreadNum()); |
||||
} |
||||
mTaskWrapper.setNewTask(true); |
||||
// 处理线程区间记录
|
||||
long blockSize = mEntity.getFileSize() / mRecord.threadNum; |
||||
for (int i = 0; i < mRecord.threadNum; i++) { |
||||
long startL = i * blockSize, endL = (i + 1) * blockSize; |
||||
ThreadRecord tr; |
||||
tr = new ThreadRecord(); |
||||
tr.key = mRecord.filePath; |
||||
tr.threadId = i; |
||||
tr.startLocation = startL; |
||||
//最后一个线程的结束位置即为文件的总长度
|
||||
if (i == (mRecord.threadNum - 1)) { |
||||
endL = mEntity.getFileSize(); |
||||
} |
||||
tr.endLocation = endL; |
||||
tr.blockLen = CommonUtil.getBlockLen(mEntity.getFileSize(), i, mRecord.threadNum); |
||||
mRecord.threadRecords.add(tr); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* 创建任务记录 |
||||
* |
||||
* @param threadNum 线程总数 |
||||
*/ |
||||
private TaskRecord createTaskRecord(int threadNum) { |
||||
TaskRecord record = new TaskRecord(); |
||||
record.fileName = mEntity.getFileName(); |
||||
record.filePath = getFilePath(); |
||||
record.threadRecords = new ArrayList<>(); |
||||
record.threadNum = threadNum; |
||||
// 处理分块和动态文件参数
|
||||
if (getRecordType() == TYPE_DOWNLOAD) { |
||||
record.isBlock = threadNum > 1 && Configuration.getInstance().downloadCfg.isUseBlock(); |
||||
// 线程数为1，或者使用了分块，则认为是使用动态长度文件
|
||||
record.isOpenDynamicFile = threadNum == 1 || record.isBlock; |
||||
} else { |
||||
record.isBlock = false; |
||||
} |
||||
record.isGroupRecord = mEntity.isGroupChild(); |
||||
if (record.isGroupRecord) { |
||||
if (mEntity instanceof DownloadEntity) { |
||||
record.dGroupHash = ((DownloadEntity) mEntity).getGroupHash(); |
||||
} |
||||
} |
||||
return record; |
||||
} |
||||
|
||||
/** |
||||
* 保存任务记录 |
||||
*/ |
||||
private void saveRecord() { |
||||
mRecord.threadNum = mRecord.threadRecords.size(); |
||||
mRecord.save(); |
||||
DbEntity.saveAll(mRecord.threadRecords); |
||||
ALog.d(TAG, String.format("保存记录，线程记录数：%s", mRecord.threadRecords.size())); |
||||
} |
||||
|
||||
/** |
||||
* 获取记录类型 |
||||
* |
||||
* @return {@link #TYPE_DOWNLOAD}、{@link #TYPE_UPLOAD} |
||||
*/ |
||||
private int getRecordType() { |
||||
if (mEntity instanceof DownloadEntity) { |
||||
return TYPE_DOWNLOAD; |
||||
} else { |
||||
return TYPE_UPLOAD; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* 获取任务路径 |
||||
* |
||||
* @return 任务文件路径 |
||||
*/ |
||||
private String getFilePath() { |
||||
if (mEntity instanceof DownloadEntity) { |
||||
return ((DownloadEntity) mTaskWrapper.getEntity()).getFilePath(); |
||||
} else { |
||||
return ((UploadEntity) mTaskWrapper.getEntity()).getFilePath(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* 小于1m的文件或是任务组的子任务、线程数强制为1 |
||||
* 不支持断点或chunked模式的线程数都为，线程数强制为1 |
||||
*/ |
||||
private int getNewTaskThreadNum() { |
||||
if (getRecordType() == TYPE_DOWNLOAD) { |
||||
if (!mTaskWrapper.isSupportBP() || mTaskWrapper.asHttp().isChunked()) { |
||||
return 1; |
||||
} |
||||
int threadNum = Configuration.getInstance().downloadCfg.getThreadNum(); |
||||
return mEntity.getFileSize() <= SUB_LEN |
||||
|| mEntity.isGroupChild() |
||||
|| threadNum == 1 |
||||
? 1 |
||||
: threadNum; |
||||
} else { |
||||
return 1; |
||||
} |
||||
} |
||||
} |
||||
@ -1,82 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.common; |
||||
|
||||
import com.arialyy.aria.util.ALog; |
||||
|
||||
/** |
||||
* Created by lyy on 2017/1/18. |
||||
* 状态常量 |
||||
*/ |
||||
public class StateConstance { |
||||
private static final String TAG = "StateConstance"; |
||||
public int CANCEL_NUM = 0; |
||||
public int STOP_NUM = 0; |
||||
public int FAIL_NUM = 0; |
||||
public int COMPLETE_THREAD_NUM = 0; |
||||
public int START_THREAD_NUM; //启动的线程数
|
||||
public long CURRENT_LOCATION = 0; //当前下载进度
|
||||
public boolean isCancel = false; |
||||
public boolean isStop = false; |
||||
public TaskRecord TASK_RECORD; |
||||
|
||||
StateConstance() { |
||||
} |
||||
|
||||
public void resetState() { |
||||
isCancel = false; |
||||
isStop = false; |
||||
CANCEL_NUM = 0; |
||||
STOP_NUM = 0; |
||||
FAIL_NUM = 0; |
||||
COMPLETE_THREAD_NUM = 0; |
||||
START_THREAD_NUM = 0; |
||||
CURRENT_LOCATION = 0; |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经停止 |
||||
*/ |
||||
public boolean isStop() { |
||||
//ALog.d(TAG, String.format("stop_thread_num=%s; start_thread_num=%s; complete_thread_num=%s",
|
||||
// STOP_NUM, START_THREAD_NUM, COMPLETE_THREAD_NUM));
|
||||
return STOP_NUM == START_THREAD_NUM || STOP_NUM + COMPLETE_THREAD_NUM == START_THREAD_NUM; |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经失败 |
||||
*/ |
||||
public boolean isFail() { |
||||
//ALog.d(TAG, String.format("fail_thread_num=%s; start_thread_num=%s; complete_thread_num=%s",
|
||||
// FAIL_NUM, START_THREAD_NUM, COMPLETE_THREAD_NUM));
|
||||
return COMPLETE_THREAD_NUM != START_THREAD_NUM |
||||
&& (FAIL_NUM == START_THREAD_NUM || FAIL_NUM + COMPLETE_THREAD_NUM == START_THREAD_NUM); |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经完成 |
||||
*/ |
||||
public boolean isComplete() { |
||||
return COMPLETE_THREAD_NUM == START_THREAD_NUM; |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经取消 |
||||
*/ |
||||
public boolean isCancel() { |
||||
return CANCEL_NUM == START_THREAD_NUM; |
||||
} |
||||
} |
||||
@ -0,0 +1,226 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.common; |
||||
|
||||
import android.os.Bundle; |
||||
import android.os.Handler; |
||||
import android.os.Looper; |
||||
import android.os.Message; |
||||
import com.arialyy.aria.core.inf.IEventListener; |
||||
import com.arialyy.aria.exception.BaseException; |
||||
import com.arialyy.aria.util.ALog; |
||||
import com.arialyy.aria.util.FileUtil; |
||||
import java.io.File; |
||||
import java.util.ArrayList; |
||||
import java.util.List; |
||||
|
||||
/** |
||||
* 线程任务管理器，用于处理多线程下载时任务的状态回调 |
||||
*/ |
||||
public class ThreadStateManager implements Handler.Callback { |
||||
private final String TAG = "ThreadTaskStateManager"; |
||||
public static final int STATE_STOP = 0x01; |
||||
public static final int STATE_FAIL = 0x02; |
||||
public static final int STATE_CANCEL = 0x03; |
||||
public static final int STATE_COMPLETE = 0x04; |
||||
public static final int STATE_RUNNING = 0x05; |
||||
public static final int STATE_UPDATE_PROGRESS = 0x06; |
||||
public static final String KEY_RETRY = "KEY_RETRY"; |
||||
public static final String KEY_ERROR_INFO = "KEY_ERROR_INFO"; |
||||
|
||||
/** |
||||
* 任务状态回调 |
||||
*/ |
||||
private IEventListener mListener; |
||||
private int mThreadNum; // 启动的线程总数
|
||||
private int mCancelNum = 0; // 已经取消的线程的数
|
||||
private int mStopNum = 0; // 已经停止的线程数
|
||||
private int mFailNum = 0; // 失败的线程数
|
||||
private int mCompleteNum = 0; // 完成的线程数
|
||||
private long mProgress; //当前总进度
|
||||
private TaskRecord mTaskRecord; // 任务记录
|
||||
private Looper mLooper; |
||||
|
||||
/** |
||||
* @param taskRecord 任务记录 |
||||
* @param listener 任务事件 |
||||
*/ |
||||
ThreadStateManager(Looper looper, TaskRecord taskRecord, IEventListener listener) { |
||||
mLooper = looper; |
||||
mTaskRecord = taskRecord; |
||||
mThreadNum = mTaskRecord.threadNum; |
||||
mListener = listener; |
||||
} |
||||
|
||||
@Override public boolean handleMessage(Message msg) { |
||||
switch (msg.what) { |
||||
case STATE_STOP: |
||||
mStopNum++; |
||||
if (isStop()) { |
||||
mListener.onStop(mProgress); |
||||
quitLooper(); |
||||
} |
||||
break; |
||||
case STATE_CANCEL: |
||||
mCancelNum++; |
||||
if (isCancel()) { |
||||
ALog.d(TAG, "icCancel"); |
||||
mListener.onCancel(); |
||||
quitLooper(); |
||||
} |
||||
break; |
||||
case STATE_FAIL: |
||||
mFailNum++; |
||||
if (isFail()) { |
||||
Bundle b = msg.getData(); |
||||
mListener.onFail(b.getBoolean(KEY_RETRY, true), |
||||
(BaseException) b.getSerializable(KEY_ERROR_INFO)); |
||||
quitLooper(); |
||||
} |
||||
break; |
||||
case STATE_COMPLETE: |
||||
mCompleteNum++; |
||||
if (isComplete()) { |
||||
ALog.d(TAG, "isComplete, completeNum = " + mCompleteNum); |
||||
if (mTaskRecord.isBlock) { |
||||
if (mergeFile()) { |
||||
mListener.onComplete(); |
||||
} else { |
||||
mListener.onFail(false, null); |
||||
} |
||||
} else { |
||||
mListener.onComplete(); |
||||
} |
||||
quitLooper(); |
||||
} |
||||
break; |
||||
case STATE_RUNNING: |
||||
mProgress += (long) msg.obj; |
||||
break; |
||||
case STATE_UPDATE_PROGRESS: |
||||
if (msg.obj == null) { |
||||
mProgress = updateBlockProgress(); |
||||
} else { |
||||
mProgress = (long) msg.obj; |
||||
} |
||||
break; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/** |
||||
* 退出looper循环 |
||||
*/ |
||||
private void quitLooper() { |
||||
mLooper.quit(); |
||||
} |
||||
|
||||
/** |
||||
* 获取当前任务下载进度 |
||||
* |
||||
* @return 当前任务下载进度 |
||||
*/ |
||||
public long getCurrentProgress() { |
||||
return mProgress; |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经停止 |
||||
*/ |
||||
public boolean isStop() { |
||||
//ALog.d(TAG,
|
||||
// String.format("isStop; stopNum: %s, cancelNum: %s, failNum: %s, completeNum: %s", mStopNum,
|
||||
// mCancelNum, mFailNum, mCompleteNum));
|
||||
return mStopNum == mThreadNum || mStopNum + mCompleteNum == mThreadNum; |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经失败 |
||||
*/ |
||||
public boolean isFail() { |
||||
//ALog.d(TAG,
|
||||
// String.format("isFail; stopNum: %s, cancelNum: %s, failNum: %s, completeNum: %s", mStopNum,
|
||||
// mCancelNum, mFailNum, mCompleteNum));
|
||||
return mCompleteNum != mThreadNum |
||||
&& (mFailNum == mThreadNum || mFailNum + mCompleteNum == mThreadNum); |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经完成 |
||||
*/ |
||||
public boolean isComplete() { |
||||
//ALog.d(TAG,
|
||||
// String.format("isComplete; stopNum: %s, cancelNum: %s, failNum: %s, completeNum: %s",
|
||||
// mStopNum,
|
||||
// mCancelNum, mFailNum, mCompleteNum));
|
||||
return mCompleteNum == mThreadNum; |
||||
} |
||||
|
||||
/** |
||||
* 所有子线程是否都已经取消 |
||||
*/ |
||||
public boolean isCancel() { |
||||
//ALog.d(TAG, String.format("isCancel; stopNum: %s, cancelNum: %s, failNum: %s, completeNum: %s",
|
||||
// mStopNum,
|
||||
// mCancelNum, mFailNum, mCompleteNum));
|
||||
return mCancelNum == mThreadNum; |
||||
} |
||||
|
||||
/** |
||||
* 更新分块任务s的真实进度 |
||||
*/ |
||||
private long updateBlockProgress() { |
||||
long size = 0; |
||||
for (int i = 0, len = mTaskRecord.threadRecords.size(); i < len; i++) { |
||||
File temp = new File(String.format(RecordHandler.SUB_PATH, mTaskRecord.filePath, i)); |
||||
if (temp.exists()) { |
||||
size += temp.length(); |
||||
} |
||||
} |
||||
return size; |
||||
} |
||||
|
||||
/** |
||||
* 合并文件 |
||||
* |
||||
* @return {@code true} 合并成功，{@code false}合并失败 |
||||
*/ |
||||
private boolean mergeFile() { |
||||
List<String> partPath = new ArrayList<>(); |
||||
for (int i = 0, len = mTaskRecord.threadNum; i < len; i++) { |
||||
partPath.add(String.format(RecordHandler.SUB_PATH, mTaskRecord.filePath, i)); |
||||
} |
||||
boolean isSuccess = FileUtil.mergeFile(mTaskRecord.filePath, partPath); |
||||
if (isSuccess) { |
||||
for (String pp : partPath) { |
||||
File f = new File(pp); |
||||
if (f.exists()) { |
||||
f.delete(); |
||||
} |
||||
} |
||||
File targetFile = new File(mTaskRecord.filePath); |
||||
if (targetFile.exists() && targetFile.length() > mTaskRecord.fileLength) { |
||||
ALog.e(TAG, String.format("任务【%s】分块文件合并失败，下载长度超出文件真实长度，downloadLen: %s，fileSize: %s", |
||||
targetFile.getName(), targetFile.length(), mTaskRecord.fileLength)); |
||||
return false; |
||||
} |
||||
return true; |
||||
} else { |
||||
ALog.e(TAG, "合并失败"); |
||||
return false; |
||||
} |
||||
} |
||||
} |
||||
@ -1,88 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.common.ftp; |
||||
|
||||
import com.arialyy.aria.core.FtpUrlEntity; |
||||
import com.arialyy.aria.core.inf.ITargetHeadDelegate; |
||||
import java.net.Proxy; |
||||
|
||||
/** |
||||
* fTP任务设置的信息，如：用户名、密码、端口等信息 |
||||
*/ |
||||
public class FtpTaskDelegate implements ITargetHeadDelegate { |
||||
|
||||
/** |
||||
* 账号和密码 |
||||
*/ |
||||
private FtpUrlEntity urlEntity; |
||||
|
||||
private Proxy proxy; |
||||
|
||||
/** |
||||
* 字符编码，默认为"utf-8" |
||||
*/ |
||||
private String charSet = "utf-8"; |
||||
|
||||
/** |
||||
* 上传拦截器 |
||||
*/ |
||||
private IFtpUploadInterceptor uploadInterceptor; |
||||
|
||||
/** |
||||
* 上传到服务器文件的新文件名{@link FtpInterceptHandler#getNewFileName()} |
||||
*/ |
||||
private String newFileName; |
||||
|
||||
public String getNewFileName() { |
||||
return newFileName; |
||||
} |
||||
|
||||
public void setNewFileName(String newFileName) { |
||||
this.newFileName = newFileName; |
||||
} |
||||
|
||||
public IFtpUploadInterceptor getUploadInterceptor() { |
||||
return uploadInterceptor; |
||||
} |
||||
|
||||
public void setUploadInterceptor(IFtpUploadInterceptor uploadInterceptor) { |
||||
this.uploadInterceptor = uploadInterceptor; |
||||
} |
||||
|
||||
public FtpUrlEntity getUrlEntity() { |
||||
return urlEntity; |
||||
} |
||||
|
||||
public void setUrlEntity(FtpUrlEntity urlEntity) { |
||||
this.urlEntity = urlEntity; |
||||
} |
||||
|
||||
public void setProxy(Proxy proxy) { |
||||
this.proxy = proxy; |
||||
} |
||||
|
||||
public Proxy getProxy() { |
||||
return proxy; |
||||
} |
||||
|
||||
public String getCharSet() { |
||||
return charSet; |
||||
} |
||||
|
||||
public void setCharSet(String charSet) { |
||||
this.charSet = charSet; |
||||
} |
||||
} |
||||
@ -1,144 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.common.http; |
||||
|
||||
import android.support.annotation.NonNull; |
||||
import android.text.TextUtils; |
||||
import com.arialyy.aria.core.inf.AbsTarget; |
||||
import com.arialyy.aria.core.inf.AbsTaskWrapper; |
||||
import com.arialyy.aria.core.inf.IHttpFileLenAdapter; |
||||
import com.arialyy.aria.core.inf.IHttpHeaderDelegate; |
||||
import com.arialyy.aria.util.ALog; |
||||
import java.net.Proxy; |
||||
import java.util.Collection; |
||||
import java.util.Map; |
||||
import java.util.Set; |
||||
|
||||
/** |
||||
* Created by laoyuyu on 2018/3/9. |
||||
* D_HTTP header参数设置委托类 |
||||
*/ |
||||
public class HttpHeaderDelegate<TARGET extends AbsTarget> |
||||
implements IHttpHeaderDelegate<TARGET> { |
||||
private static final String TAG = "HttpHeaderDelegate"; |
||||
private TARGET mTarget; |
||||
|
||||
public HttpHeaderDelegate(TARGET target) { |
||||
mTarget = target; |
||||
} |
||||
|
||||
/** |
||||
* 给url请求添加Header数据 |
||||
* 如果新的header数据和数据保存的不一致，则更新数据库中对应的header数据 |
||||
* |
||||
* @param key header对应的key |
||||
* @param value header对应的value |
||||
*/ |
||||
@Override |
||||
public TARGET addHeader(@NonNull String key, @NonNull String value) { |
||||
if (TextUtils.isEmpty(key)) { |
||||
ALog.w(TAG, "设置header失败，header对应的key不能为null"); |
||||
return mTarget; |
||||
} else if (TextUtils.isEmpty(value)) { |
||||
ALog.w(TAG, "设置header失败，header对应的value不能为null"); |
||||
return mTarget; |
||||
} |
||||
addHeader(mTarget.getTaskWrapper(), key, value); |
||||
return mTarget; |
||||
} |
||||
|
||||
/** |
||||
* 给url请求添加一组header数据 |
||||
* 如果新的header数据和数据保存的不一致，则更新数据库中对应的header数据 |
||||
* |
||||
* @param headers 一组http header数据 |
||||
*/ |
||||
@Override |
||||
public TARGET addHeaders(@NonNull Map<String, String> headers) { |
||||
if (headers.size() == 0) { |
||||
ALog.w(TAG, "设置header失败，map没有header数据"); |
||||
return mTarget; |
||||
} |
||||
addHeaders(mTarget.getTaskWrapper(), headers); |
||||
return mTarget; |
||||
} |
||||
|
||||
@Override public TARGET setUrlProxy(Proxy proxy) { |
||||
mTarget.getTaskWrapper().asHttp().setProxy(proxy); |
||||
return mTarget; |
||||
} |
||||
|
||||
public TARGET setFileLenAdapter(IHttpFileLenAdapter adapter) { |
||||
if (adapter == null) { |
||||
throw new IllegalArgumentException("adapter为空"); |
||||
} |
||||
mTarget.getTaskWrapper().asHttp().setFileLenAdapter(adapter); |
||||
return mTarget; |
||||
} |
||||
|
||||
private void addHeader(AbsTaskWrapper taskWrapper, String key, String value) { |
||||
HttpTaskDelegate taskDelegate = taskWrapper.asHttp(); |
||||
if (taskDelegate.getHeaders().get(key) == null) { |
||||
taskDelegate.getHeaders().put(key, value); |
||||
} else if (!taskDelegate.getHeaders().get(key).equals(value)) { |
||||
taskDelegate.getHeaders().put(key, value); |
||||
} |
||||
} |
||||
|
||||
private void addHeaders(AbsTaskWrapper taskWrapper, Map<String, String> headers) { |
||||
HttpTaskDelegate taskDelegate = taskWrapper.asHttp(); |
||||
/* |
||||
两个map比较逻辑 |
||||
1、比对key是否相同 |
||||
2、如果key相同，比对value是否相同 |
||||
3、只有当上面两个步骤中key 和 value都相同时才能任务两个map数据一致 |
||||
*/ |
||||
boolean mapEquals = false; |
||||
if (taskDelegate.getHeaders().size() == headers.size()) { |
||||
int i = 0; |
||||
Set<String> keys = taskDelegate.getHeaders().keySet(); |
||||
for (String key : keys) { |
||||
if (headers.containsKey(key)) { |
||||
i++; |
||||
} else { |
||||
break; |
||||
} |
||||
} |
||||
if (i == taskDelegate.getHeaders().size()) { |
||||
int j = 0; |
||||
Collection<String> values = taskDelegate.getHeaders().values(); |
||||
for (String value : values) { |
||||
if (headers.containsValue(value)) { |
||||
j++; |
||||
} else { |
||||
break; |
||||
} |
||||
} |
||||
if (j == taskDelegate.getHeaders().size()) { |
||||
mapEquals = true; |
||||
} |
||||
} |
||||
} |
||||
|
||||
if (!mapEquals) { |
||||
taskDelegate.getHeaders().clear(); |
||||
Set<String> keys = headers.keySet(); |
||||
for (String key : keys) { |
||||
taskDelegate.getHeaders().put(key, headers.get(key)); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -1,199 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.common.http; |
||||
|
||||
import com.arialyy.aria.core.common.RequestEnum; |
||||
import com.arialyy.aria.core.inf.IHttpFileLenAdapter; |
||||
import com.arialyy.aria.core.inf.ITargetHeadDelegate; |
||||
import java.lang.ref.WeakReference; |
||||
import java.net.CookieManager; |
||||
import java.net.Proxy; |
||||
import java.util.HashMap; |
||||
import java.util.Map; |
||||
|
||||
/** |
||||
* Http任务设置的信息，如：cookie、请求参数 |
||||
*/ |
||||
public class HttpTaskDelegate implements ITargetHeadDelegate { |
||||
|
||||
private CookieManager cookieManager; |
||||
|
||||
/** |
||||
* 请求参数 |
||||
*/ |
||||
private Map<String, String> params; |
||||
|
||||
/** |
||||
* http 请求头 |
||||
*/ |
||||
private Map<String, String> headers = new HashMap<>(); |
||||
|
||||
/** |
||||
* 字符编码，默认为"utf-8" |
||||
*/ |
||||
private String charSet = "utf-8"; |
||||
|
||||
/** |
||||
* 网络请求类型 |
||||
*/ |
||||
private RequestEnum requestEnum = RequestEnum.GET; |
||||
|
||||
/** |
||||
* 是否使用服务器通过content-disposition传递的文件名，内容格式{@code attachment; filename="filename.jpg"} {@code true} |
||||
* 使用 |
||||
*/ |
||||
private boolean useServerFileName = false; |
||||
|
||||
/** |
||||
* 重定向链接 |
||||
*/ |
||||
private String redirectUrl = ""; |
||||
|
||||
/** |
||||
* 是否是chunk模式 |
||||
*/ |
||||
private boolean isChunked = false; |
||||
/** |
||||
* 文件上传需要的key |
||||
*/ |
||||
private String attachment; |
||||
/** |
||||
* 上传的文件类型 |
||||
*/ |
||||
private String contentType = "multipart/form-data"; |
||||
private String userAgent = "Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.6)"; |
||||
|
||||
private Proxy proxy; |
||||
/** |
||||
* 文件上传表单 |
||||
*/ |
||||
private Map<String, String> formFields = new HashMap<>(); |
||||
|
||||
private IHttpFileLenAdapter fileLenAdapter; |
||||
|
||||
public IHttpFileLenAdapter getFileLenAdapter() { |
||||
return fileLenAdapter; |
||||
} |
||||
|
||||
public void setFileLenAdapter(IHttpFileLenAdapter fileLenAdapter) { |
||||
this.fileLenAdapter = fileLenAdapter; |
||||
} |
||||
|
||||
public Map<String, String> getFormFields() { |
||||
return formFields; |
||||
} |
||||
|
||||
public void setFormFields(Map<String, String> formFields) { |
||||
this.formFields = formFields; |
||||
} |
||||
|
||||
public String getAttachment() { |
||||
return attachment; |
||||
} |
||||
|
||||
public void setAttachment(String attachment) { |
||||
this.attachment = attachment; |
||||
} |
||||
|
||||
public String getContentType() { |
||||
return contentType; |
||||
} |
||||
|
||||
public void setContentType(String contentType) { |
||||
this.contentType = contentType; |
||||
} |
||||
|
||||
public String getUserAgent() { |
||||
return userAgent; |
||||
} |
||||
|
||||
public void setUserAgent(String userAgent) { |
||||
this.userAgent = userAgent; |
||||
} |
||||
|
||||
public boolean isChunked() { |
||||
return isChunked; |
||||
} |
||||
|
||||
public void setChunked(boolean chunked) { |
||||
isChunked = chunked; |
||||
} |
||||
|
||||
public CookieManager getCookieManager() { |
||||
return cookieManager; |
||||
} |
||||
|
||||
public void setCookieManager(CookieManager cookieManager) { |
||||
this.cookieManager = cookieManager; |
||||
} |
||||
|
||||
public Proxy getProxy() { |
||||
return proxy; |
||||
} |
||||
|
||||
public void setProxy(Proxy proxy) { |
||||
this.proxy = proxy; |
||||
} |
||||
|
||||
public Map<String, String> getHeaders() { |
||||
return headers; |
||||
} |
||||
|
||||
public void setHeaders(Map<String, String> headers) { |
||||
this.headers = headers; |
||||
} |
||||
|
||||
public String getCharSet() { |
||||
return charSet; |
||||
} |
||||
|
||||
public void setCharSet(String charSet) { |
||||
this.charSet = charSet; |
||||
} |
||||
|
||||
public RequestEnum getRequestEnum() { |
||||
return requestEnum; |
||||
} |
||||
|
||||
public void setRequestEnum(RequestEnum requestEnum) { |
||||
this.requestEnum = requestEnum; |
||||
} |
||||
|
||||
public boolean isUseServerFileName() { |
||||
return useServerFileName; |
||||
} |
||||
|
||||
public void setUseServerFileName(boolean useServerFileName) { |
||||
this.useServerFileName = useServerFileName; |
||||
} |
||||
|
||||
public String getRedirectUrl() { |
||||
return redirectUrl; |
||||
} |
||||
|
||||
public void setRedirectUrl(String redirectUrl) { |
||||
this.redirectUrl = redirectUrl; |
||||
} |
||||
|
||||
public Map<String, String> getParams() { |
||||
return params; |
||||
} |
||||
|
||||
public void setParams(Map<String, String> params) { |
||||
this.params = params; |
||||
} |
||||
} |
||||
@ -1,159 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.download; |
||||
|
||||
import android.support.annotation.CheckResult; |
||||
import android.text.TextUtils; |
||||
import com.arialyy.aria.core.inf.AbsEntity; |
||||
import com.arialyy.aria.core.inf.IGroupTarget; |
||||
import com.arialyy.aria.core.queue.DownloadGroupTaskQueue; |
||||
import com.arialyy.aria.orm.DbEntity; |
||||
import com.arialyy.aria.util.ALog; |
||||
import com.arialyy.aria.util.CommonUtil; |
||||
import java.io.File; |
||||
import java.util.ArrayList; |
||||
import java.util.List; |
||||
|
||||
/** |
||||
* Created by lyy on 2019/4/9. |
||||
* 下载组合任务功能 |
||||
*/ |
||||
abstract class AbsGroupDelegate<TARGET extends AbsDGTarget> implements IGroupTarget { |
||||
protected String TAG; |
||||
private TARGET mTarget; |
||||
private DGTaskWrapper mWrapper; |
||||
/** |
||||
* 组任务名 |
||||
*/ |
||||
private String mGroupHash; |
||||
/** |
||||
* 文件夹临时路径 |
||||
*/ |
||||
private String mDirPathTemp; |
||||
/** |
||||
* 是否需要修改路径 |
||||
*/ |
||||
private boolean needModifyPath = false; |
||||
|
||||
AbsGroupDelegate(TARGET target, DGTaskWrapper wrapper) { |
||||
TAG = CommonUtil.getClassName(getClass()); |
||||
mTarget = target; |
||||
mWrapper = wrapper; |
||||
setGroupHash(wrapper.getKey()); |
||||
mTarget.setTaskWrapper(wrapper); |
||||
if (getEntity() != null) { |
||||
mDirPathTemp = getEntity().getDirPath(); |
||||
} |
||||
} |
||||
|
||||
@Override public boolean isRunning() { |
||||
DownloadGroupTask task = DownloadGroupTaskQueue.getInstance().getTask(getEntity().getKey()); |
||||
return task != null && task.isRunning(); |
||||
} |
||||
|
||||
@CheckResult |
||||
TARGET setDirPath(String dirPath) { |
||||
mDirPathTemp = dirPath; |
||||
return mTarget; |
||||
} |
||||
|
||||
/** |
||||
* 改变任务组文件夹路径，修改文件夹路径会将子任务所有路径更换 |
||||
* |
||||
* @param newDirPath 新的文件夹路径 |
||||
*/ |
||||
void reChangeDirPath(String newDirPath) { |
||||
ALog.d(TAG, String.format("修改新路径为：%s", newDirPath)); |
||||
List<DTaskWrapper> subTasks = mWrapper.getSubTaskWrapper(); |
||||
if (subTasks != null && !subTasks.isEmpty()) { |
||||
List<DownloadEntity> des = new ArrayList<>(); |
||||
for (DTaskWrapper dte : subTasks) { |
||||
DownloadEntity de = dte.getEntity(); |
||||
String oldPath = de.getDownloadPath(); |
||||
String newPath = newDirPath + "/" + de.getFileName(); |
||||
File file = new File(oldPath); |
||||
if (file.exists()) { |
||||
file.renameTo(new File(newPath)); |
||||
} |
||||
de.setDownloadPath(newPath); |
||||
des.add(de); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* 检查并设置文件夹路径 |
||||
* |
||||
* @return {@code true} 合法 |
||||
*/ |
||||
@Override public boolean checkDirPath() { |
||||
if (TextUtils.isEmpty(mDirPathTemp)) { |
||||
ALog.e(TAG, "文件夹路径不能为null"); |
||||
return false; |
||||
} else if (!mDirPathTemp.startsWith("/")) { |
||||
ALog.e(TAG, "文件夹路径【" + mDirPathTemp + "】错误"); |
||||
return false; |
||||
} |
||||
File file = new File(mDirPathTemp); |
||||
if (file.isFile()) { |
||||
ALog.e(TAG, "路径【" + mDirPathTemp + "】是文件，请设置文件夹路径"); |
||||
return false; |
||||
} |
||||
|
||||
if (TextUtils.isEmpty(getEntity().getDirPath()) || !getEntity().getDirPath() |
||||
.equals(mDirPathTemp)) { |
||||
if (!file.exists()) { |
||||
file.mkdirs(); |
||||
} |
||||
needModifyPath = true; |
||||
getEntity().setDirPath(mDirPathTemp); |
||||
ALog.i(TAG, String.format("文件夹路径改变，将更新文件夹路径为：%s", mDirPathTemp)); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
@Override public DownloadGroupEntity getEntity() { |
||||
return mWrapper.getEntity(); |
||||
} |
||||
|
||||
@Override public boolean taskExists() { |
||||
return DbEntity.checkDataExist(DownloadGroupEntity.class, "groupHash=?", mWrapper.getKey()); |
||||
} |
||||
|
||||
DGTaskWrapper getTaskWrapper() { |
||||
return mWrapper; |
||||
} |
||||
|
||||
boolean isNeedModifyPath() { |
||||
return needModifyPath; |
||||
} |
||||
|
||||
String getDirPathTemp() { |
||||
return mDirPathTemp; |
||||
} |
||||
|
||||
TARGET getTarget() { |
||||
return mTarget; |
||||
} |
||||
|
||||
public String getGroupHash() { |
||||
return mGroupHash; |
||||
} |
||||
|
||||
public void setGroupHash(String groupHash) { |
||||
this.mGroupHash = groupHash; |
||||
} |
||||
} |
||||
@ -1,201 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.download; |
||||
|
||||
import android.text.TextUtils; |
||||
import com.arialyy.aria.core.inf.ITargetHandler; |
||||
import com.arialyy.aria.core.inf.INormalTarget; |
||||
import com.arialyy.aria.core.manager.TaskWrapperManager; |
||||
import com.arialyy.aria.core.queue.DownloadTaskQueue; |
||||
import com.arialyy.aria.orm.DbEntity; |
||||
import com.arialyy.aria.util.ALog; |
||||
import com.arialyy.aria.util.CheckUtil; |
||||
import com.arialyy.aria.util.CommonUtil; |
||||
import java.io.File; |
||||
|
||||
/** |
||||
* Created by AriaL on 2019/4/5. |
||||
* 普通下载任务通用功能处理 |
||||
*/ |
||||
class DNormalDelegate<TARGET extends AbsDTarget> implements INormalTarget { |
||||
private final String TAG = "DNormalDelegate"; |
||||
private DownloadEntity mEntity; |
||||
|
||||
private TARGET mTarget; |
||||
private String mNewUrl; |
||||
/** |
||||
* 设置的文件保存路径的临时变量 |
||||
*/ |
||||
private String mTempFilePath; |
||||
|
||||
/** |
||||
* {@code true}强制下载，不考虑文件路径是否被占用 |
||||
*/ |
||||
private boolean forceDownload = false; |
||||
/** |
||||
* 资源地址 |
||||
*/ |
||||
private String mUrl; |
||||
|
||||
DNormalDelegate(TARGET target, String url, String targetName) { |
||||
this.mTarget = target; |
||||
initTarget(url, targetName); |
||||
} |
||||
|
||||
private void initTarget(String url, String targetName) { |
||||
DTaskWrapper taskWrapper = |
||||
TaskWrapperManager.getInstance().getHttpTaskWrapper(DTaskWrapper.class, url); |
||||
mEntity = taskWrapper.getEntity(); |
||||
|
||||
mUrl = url; |
||||
mTarget.setTargetName(targetName); |
||||
mTarget.setTaskWrapper(taskWrapper); |
||||
if (mEntity != null) { |
||||
mTempFilePath = mEntity.getDownloadPath(); |
||||
} |
||||
} |
||||
|
||||
TARGET updateUrl(String newUrl) { |
||||
if (TextUtils.isEmpty(newUrl)) { |
||||
ALog.e(TAG, "url更新失败，newUrl为null"); |
||||
return mTarget; |
||||
} |
||||
if (mUrl.equals(newUrl)) { |
||||
ALog.e(TAG, "url更新失败，新的下载url和旧的url一致"); |
||||
return mTarget; |
||||
} |
||||
mNewUrl = newUrl; |
||||
mTarget.getTaskWrapper().setRefreshInfo(true); |
||||
return mTarget; |
||||
} |
||||
|
||||
@Override public DownloadEntity getEntity() { |
||||
return mTarget.getEntity(); |
||||
} |
||||
|
||||
@Override public boolean taskExists() { |
||||
return DbEntity.checkDataExist(DownloadEntity.class, "url=?", mUrl); |
||||
} |
||||
|
||||
@Override public boolean isRunning() { |
||||
DownloadTask task = DownloadTaskQueue.getInstance().getTask(mEntity.getKey()); |
||||
return task != null && task.isRunning(); |
||||
} |
||||
|
||||
@Override public boolean checkEntity() { |
||||
boolean b = checkUrl() && checkFilePath(); |
||||
if (b) { |
||||
mEntity.save(); |
||||
} |
||||
return b; |
||||
} |
||||
|
||||
@Override public boolean checkFilePath() { |
||||
String filePath = mTempFilePath; |
||||
if (TextUtils.isEmpty(filePath)) { |
||||
ALog.e(TAG, "下载失败，文件保存路径为null"); |
||||
return false; |
||||
} else if (!filePath.startsWith("/")) { |
||||
ALog.e(TAG, "下载失败，文件保存路径【" + filePath + "】错误"); |
||||
return false; |
||||
} |
||||
File file = new File(filePath); |
||||
if (file.isDirectory()) { |
||||
if (mTarget.getTargetType() == ITargetHandler.D_HTTP) { |
||||
ALog.e(TAG, "下载失败，保存路径【" + filePath + "】不能为文件夹，路径需要是完整的文件路径，如：/mnt/sdcard/game.zip"); |
||||
return false; |
||||
} else if (mTarget.getTargetType() == ITargetHandler.D_FTP) { |
||||
filePath += mEntity.getFileName(); |
||||
} |
||||
} else { |
||||
// http文件名设置
|
||||
if (TextUtils.isEmpty(mEntity.getFileName())) { |
||||
mEntity.setFileName(file.getName()); |
||||
} |
||||
} |
||||
|
||||
//设置文件保存路径，如果新文件路径和旧文件路径不同，则修改路径
|
||||
if (!filePath.equals(mEntity.getFilePath())) { |
||||
// 检查路径冲突
|
||||
if (DbEntity.checkDataExist(DownloadEntity.class, "downloadPath=?", filePath)) { |
||||
if (!forceDownload) { |
||||
ALog.e(TAG, "下载失败，保存路径【" + filePath + "】已经被其它任务占用，请设置其它保存路径"); |
||||
return false; |
||||
} else { |
||||
ALog.w(TAG, "保存路径【" + filePath + "】已经被其它任务占用，当前任务将覆盖该路径的文件"); |
||||
CommonUtil.delTaskRecord(filePath, 1); |
||||
mTarget.setTaskWrapper( |
||||
TaskWrapperManager.getInstance() |
||||
.getHttpTaskWrapper(DTaskWrapper.class, mUrl)); |
||||
} |
||||
} |
||||
File oldFile = new File(mEntity.getDownloadPath()); |
||||
File newFile = new File(filePath); |
||||
mEntity.setDownloadPath(filePath); |
||||
mEntity.setFileName(newFile.getName()); |
||||
// 如过使用Content-Disposition中的文件名，将不会执行重命名工作
|
||||
if (mTarget.getTaskWrapper().asHttp().isUseServerFileName()) { |
||||
return true; |
||||
} |
||||
if (oldFile.exists()) { |
||||
// 处理普通任务的重命名
|
||||
CommonUtil.modifyTaskRecord(oldFile.getPath(), newFile.getPath()); |
||||
ALog.i(TAG, String.format("将任务重命名为：%s", newFile.getName())); |
||||
} else if (CommonUtil.blockTaskExists(oldFile.getPath())) { |
||||
// 处理分块任务的重命名
|
||||
CommonUtil.modifyTaskRecord(oldFile.getPath(), newFile.getPath()); |
||||
ALog.i(TAG, String.format("将分块任务重命名为：%s", newFile.getName())); |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
@Override public boolean checkUrl() { |
||||
final String url = mEntity.getUrl(); |
||||
if (TextUtils.isEmpty(url)) { |
||||
ALog.e(TAG, "下载失败，url为null"); |
||||
return false; |
||||
} else if (!CheckUtil.checkUrlNotThrow(url)) { |
||||
ALog.e(TAG, "下载失败，url【" + url + "】错误"); |
||||
return false; |
||||
} |
||||
int index = url.indexOf("://"); |
||||
if (index == -1) { |
||||
ALog.e(TAG, "下载失败，url【" + url + "】不合法"); |
||||
return false; |
||||
} |
||||
if (!TextUtils.isEmpty(mNewUrl)) { |
||||
mEntity.setUrl(mNewUrl); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
void setForceDownload(boolean forceDownload) { |
||||
this.forceDownload = forceDownload; |
||||
} |
||||
|
||||
void setUrl(String url) { |
||||
this.mUrl = url; |
||||
} |
||||
|
||||
String getUrl() { |
||||
return mUrl; |
||||
} |
||||
|
||||
void setTempFilePath(String mTempFilePath) { |
||||
this.mTempFilePath = mTempFilePath; |
||||
} |
||||
} |
||||
@ -1,91 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.download; |
||||
|
||||
import android.text.TextUtils; |
||||
import com.arialyy.aria.core.FtpUrlEntity; |
||||
import com.arialyy.aria.core.inf.AbsTaskWrapper; |
||||
import com.arialyy.aria.util.ALog; |
||||
|
||||
/** |
||||
* Created by lyy on 2017/4/9. |
||||
* ftp文件夹下载功能代理 |
||||
*/ |
||||
class FtpDirDelegate extends AbsGroupDelegate<FtpDirDownloadTarget> { |
||||
FtpDirDelegate(FtpDirDownloadTarget target, DGTaskWrapper wrapper) { |
||||
super(target, wrapper); |
||||
wrapper.setRequestType(AbsTaskWrapper.D_FTP_DIR); |
||||
} |
||||
|
||||
@Override public boolean checkEntity() { |
||||
boolean b = checkDirPath() && checkUrl(); |
||||
if (b) { |
||||
getEntity().save(); |
||||
if (getTaskWrapper().getSubTaskWrapper() != null) { |
||||
//初始化子项的登录信息
|
||||
FtpUrlEntity tUrlEntity = getTaskWrapper().asFtp().getUrlEntity(); |
||||
for (DTaskWrapper wrapper : getTaskWrapper().getSubTaskWrapper()) { |
||||
FtpUrlEntity urlEntity = wrapper.asFtp().getUrlEntity(); |
||||
urlEntity.needLogin = tUrlEntity.needLogin; |
||||
urlEntity.account = tUrlEntity.account; |
||||
urlEntity.user = tUrlEntity.user; |
||||
urlEntity.password = tUrlEntity.password; |
||||
// 处理ftps详细
|
||||
if (tUrlEntity.isFtps) { |
||||
urlEntity.isFtps = true; |
||||
urlEntity.protocol = tUrlEntity.protocol; |
||||
urlEntity.storePath = tUrlEntity.storePath; |
||||
urlEntity.storePass = tUrlEntity.storePass; |
||||
urlEntity.keyAlias = tUrlEntity.keyAlias; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
if (getTaskWrapper().asFtp().getUrlEntity().isFtps) { |
||||
if (TextUtils.isEmpty(getTaskWrapper().asFtp().getUrlEntity().storePath)) { |
||||
ALog.e(TAG, "证书路径为空"); |
||||
return false; |
||||
} |
||||
if (TextUtils.isEmpty(getTaskWrapper().asFtp().getUrlEntity().keyAlias)) { |
||||
ALog.e(TAG, "证书别名为空"); |
||||
return false; |
||||
} |
||||
} |
||||
return b; |
||||
} |
||||
|
||||
/** |
||||
* 检查普通任务的下载地址 |
||||
* |
||||
* @return {@code true}地址合法 |
||||
*/ |
||||
private boolean checkUrl() { |
||||
final String url = getGroupHash(); |
||||
if (TextUtils.isEmpty(url)) { |
||||
ALog.e(TAG, "下载失败，url为null"); |
||||
return false; |
||||
} else if (!url.startsWith("ftp")) { |
||||
ALog.e(TAG, "下载失败，url【" + url + "】错误"); |
||||
return false; |
||||
} |
||||
int index = url.indexOf("://"); |
||||
if (index == -1) { |
||||
ALog.e(TAG, "下载失败，url【" + url + "】不合法"); |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
} |
||||
@ -1,247 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.download; |
||||
|
||||
import android.support.annotation.CheckResult; |
||||
import android.text.TextUtils; |
||||
import com.arialyy.aria.core.common.RequestEnum; |
||||
import com.arialyy.aria.orm.DbEntity; |
||||
import com.arialyy.aria.util.ALog; |
||||
import com.arialyy.aria.util.CommonUtil; |
||||
import java.util.ArrayList; |
||||
import java.util.Arrays; |
||||
import java.util.HashSet; |
||||
import java.util.List; |
||||
import java.util.Set; |
||||
|
||||
/** |
||||
* Created by lyy on 2019/4/9. |
||||
* |
||||
* http组合任务功能代理 |
||||
*/ |
||||
class HttpGroupDelegate extends AbsGroupDelegate<DownloadGroupTarget> { |
||||
|
||||
/** |
||||
* 子任务下载地址， |
||||
*/ |
||||
private List<String> mUrls = new ArrayList<>(); |
||||
|
||||
/** |
||||
* 子任务文件名 |
||||
*/ |
||||
private List<String> mSubNameTemp = new ArrayList<>(); |
||||
|
||||
HttpGroupDelegate(DownloadGroupTarget target, DGTaskWrapper wrapper) { |
||||
super(target, wrapper); |
||||
mUrls.addAll(wrapper.getEntity().getUrls()); |
||||
} |
||||
|
||||
@CheckResult |
||||
DownloadGroupTarget setGroupUrl(List<String> urls) { |
||||
mUrls.clear(); |
||||
mUrls.addAll(urls); |
||||
return getTarget(); |
||||
} |
||||
|
||||
/** |
||||
* 设置子任务文件名，该方法必须在{@link #setDirPath(String)}之后调用，否则不生效 |
||||
*/ |
||||
@CheckResult |
||||
DownloadGroupTarget setSubFileName(List<String> subTaskFileName) { |
||||
if (subTaskFileName == null || subTaskFileName.isEmpty()) { |
||||
ALog.w(TAG, "修改子任务的文件名失败：列表为null"); |
||||
return getTarget(); |
||||
} |
||||
if (subTaskFileName.size() != getTaskWrapper().getSubTaskWrapper().size()) { |
||||
ALog.w(TAG, "修改子任务的文件名失败：子任务文件名列表数量和子任务的数量不匹配"); |
||||
return getTarget(); |
||||
} |
||||
mSubNameTemp.clear(); |
||||
mSubNameTemp.addAll(subTaskFileName); |
||||
return getTarget(); |
||||
} |
||||
|
||||
/** |
||||
* 更新组合任务下载地址 |
||||
* |
||||
* @param urls 新的组合任务下载地址列表 |
||||
*/ |
||||
@CheckResult |
||||
DownloadGroupTarget updateUrls(List<String> urls) { |
||||
if (urls == null || urls.isEmpty()) { |
||||
throw new NullPointerException("下载地址列表为空"); |
||||
} |
||||
if (urls.size() != mUrls.size()) { |
||||
throw new IllegalArgumentException("新下载地址数量和旧下载地址数量不一致"); |
||||
} |
||||
mUrls.clear(); |
||||
mUrls.addAll(urls); |
||||
String newHash = CommonUtil.getMd5Code(urls); |
||||
setGroupHash(newHash); |
||||
getEntity().setGroupHash(newHash); |
||||
getEntity().update(); |
||||
if (getEntity().getSubEntities() != null && !getEntity().getSubEntities().isEmpty()) { |
||||
for (DownloadEntity de : getEntity().getSubEntities()) { |
||||
de.setGroupHash(newHash); |
||||
de.update(); |
||||
} |
||||
} |
||||
return getTarget(); |
||||
} |
||||
|
||||
@Override public boolean checkEntity() { |
||||
if (!checkDirPath()) { |
||||
return false; |
||||
} |
||||
|
||||
if (!checkSubName()) { |
||||
return false; |
||||
} |
||||
|
||||
if (!checkUrls()) { |
||||
return false; |
||||
} |
||||
|
||||
if (!getTaskWrapper().isUnknownSize() && getTaskWrapper().getEntity().getFileSize() == 0) { |
||||
ALog.e(TAG, "组合任务必须设置文件文件大小，默认需要强制设置文件大小。如果无法获取到总长度，请调用#unknownSize()来标志该组合任务"); |
||||
return false; |
||||
} |
||||
|
||||
if (getTaskWrapper().asHttp().getRequestEnum() == RequestEnum.POST) { |
||||
for (DTaskWrapper subTask : getTaskWrapper().getSubTaskWrapper()) { |
||||
subTask.asHttp().setRequestEnum(RequestEnum.POST); |
||||
} |
||||
} |
||||
|
||||
if (isNeedModifyPath()) { |
||||
reChangeDirPath(getDirPathTemp()); |
||||
} |
||||
|
||||
if (!mSubNameTemp.isEmpty()) { |
||||
updateSingleSubFileName(); |
||||
} |
||||
saveEntity(); |
||||
return true; |
||||
} |
||||
|
||||
private void saveEntity() { |
||||
getEntity().save(); |
||||
DbEntity.saveAll(getEntity().getSubEntities()); |
||||
} |
||||
|
||||
/** |
||||
* 更新所有改动的子任务文件名 |
||||
*/ |
||||
private void updateSingleSubFileName() { |
||||
List<DTaskWrapper> entities = getTaskWrapper().getSubTaskWrapper(); |
||||
int i = 0; |
||||
for (DTaskWrapper taskWrapper : entities) { |
||||
if (i < mSubNameTemp.size()) { |
||||
String newName = mSubNameTemp.get(i); |
||||
DownloadEntity entity = taskWrapper.getEntity(); |
||||
if (!newName.equals(entity.getFileName())) { |
||||
String oldPath = getEntity().getDirPath() + "/" + entity.getFileName(); |
||||
String newPath = getEntity().getDirPath() + "/" + newName; |
||||
if (DbEntity.checkDataExist(DownloadEntity.class, "downloadPath=? or isComplete='true'", |
||||
newPath)) { |
||||
ALog.w(TAG, String.format("更新文件名失败，路径【%s】已存在或文件已下载", newPath)); |
||||
return; |
||||
} |
||||
|
||||
CommonUtil.modifyTaskRecord(oldPath, newPath); |
||||
entity.setDownloadPath(newPath); |
||||
entity.setFileName(newName); |
||||
} |
||||
} |
||||
i++; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* 检查urls是否合法，并删除不合法的子任务 |
||||
* |
||||
* @return {@code true} 合法 |
||||
*/ |
||||
private boolean checkUrls() { |
||||
if (mUrls.isEmpty()) { |
||||
ALog.e(TAG, "下载失败，子任务下载列表为null"); |
||||
return false; |
||||
} |
||||
|
||||
Set<String> repeated = new HashSet<>(); |
||||
List<String> results = new ArrayList<>(); |
||||
for (String url : mUrls) { |
||||
if (!repeated.add(url)) { |
||||
results.add(url); |
||||
} |
||||
} |
||||
if (!results.isEmpty()) { |
||||
ALog.e(TAG, String.format("组合任务中有url重复，重复的url：%s", Arrays.toString(results.toArray()))); |
||||
return false; |
||||
} |
||||
|
||||
Set<Integer> delItem = new HashSet<>(); |
||||
|
||||
int i = 0; |
||||
for (String url : mUrls) { |
||||
if (TextUtils.isEmpty(url)) { |
||||
ALog.e(TAG, "子任务url为null，即将删除该子任务。"); |
||||
delItem.add(i); |
||||
continue; |
||||
} else if (!url.startsWith("http")) { |
||||
ALog.e(TAG, "子任务url【" + url + "】错误，即将删除该子任务。"); |
||||
delItem.add(i); |
||||
continue; |
||||
} |
||||
int index = url.indexOf("://"); |
||||
if (index == -1) { |
||||
ALog.e(TAG, "子任务url【" + url + "】不合法，即将删除该子任务。"); |
||||
delItem.add(i); |
||||
continue; |
||||
} |
||||
|
||||
i++; |
||||
} |
||||
|
||||
for (int index : delItem) { |
||||
mUrls.remove(index); |
||||
if (mSubNameTemp != null && !mSubNameTemp.isEmpty()) { |
||||
mSubNameTemp.remove(index); |
||||
} |
||||
} |
||||
|
||||
getEntity().setGroupHash(CommonUtil.getMd5Code(mUrls)); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
/** |
||||
* 如果用户设置了子任务文件名，检查子任务文件名 |
||||
* |
||||
* @return {@code true} 合法 |
||||
*/ |
||||
private boolean checkSubName() { |
||||
if (mSubNameTemp == null || mSubNameTemp.isEmpty()) { |
||||
return true; |
||||
} |
||||
if (mUrls.size() != mSubNameTemp.size()) { |
||||
ALog.e(TAG, "子任务文件名必须和子任务数量一致"); |
||||
return false; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
} |
||||
@ -1,24 +1,31 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.inf; |
||||
|
||||
/** |
||||
* Created by AriaL on 2017/6/29. |
||||
* 处理任务头部信息等设置等接口 |
||||
*/ |
||||
public interface ITargetHeadDelegate { |
||||
|
||||
} |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.download.m3u8; |
||||
|
||||
import android.support.annotation.IntDef; |
||||
import java.lang.annotation.Retention; |
||||
import java.lang.annotation.RetentionPolicy; |
||||
|
||||
/** |
||||
* 直播协议 |
||||
*/ |
||||
@IntDef({ |
||||
LiveProtocol.HLS |
||||
}) |
||||
@Retention(RetentionPolicy.SOURCE) |
||||
public @interface LiveProtocol { |
||||
int HLS = 1; |
||||
} |
||||
@ -0,0 +1,48 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.download.m3u8; |
||||
|
||||
import com.arialyy.aria.core.AriaManager; |
||||
import com.arialyy.aria.core.common.OnFileInfoCallback; |
||||
import com.arialyy.aria.core.common.http.HttpTaskConfig; |
||||
import com.arialyy.aria.core.download.DTaskWrapper; |
||||
import com.arialyy.aria.core.download.DownloadEntity; |
||||
|
||||
/** |
||||
* 解析url中获取到到m3u信息 |
||||
* https://www.cnblogs.com/renhui/p/10351870.html
|
||||
*/ |
||||
public class M3U8FileInfothread implements Runnable { |
||||
private final String TAG = "HttpFileInfoThread"; |
||||
private DownloadEntity mEntity; |
||||
private DTaskWrapper mTaskWrapper; |
||||
private int mConnectTimeOut; |
||||
private OnFileInfoCallback onFileInfoCallback; |
||||
private HttpTaskConfig mTaskDelegate; |
||||
|
||||
public M3U8FileInfothread(DTaskWrapper taskWrapper, OnFileInfoCallback callback) { |
||||
this.mTaskWrapper = taskWrapper; |
||||
mEntity = taskWrapper.getEntity(); |
||||
mConnectTimeOut = |
||||
AriaManager.getInstance(AriaManager.APP).getDownloadConfig().getConnectTimeOut(); |
||||
onFileInfoCallback = callback; |
||||
mTaskDelegate = taskWrapper.asHttp(); |
||||
} |
||||
|
||||
@Override public void run() { |
||||
|
||||
} |
||||
} |
||||
@ -1,58 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.inf; |
||||
|
||||
/** |
||||
* Created by lyy on 2019/4/5. |
||||
* 组合任务接收器功能接口 |
||||
*/ |
||||
public interface IGroupTarget { |
||||
|
||||
/** |
||||
* 获取实体 |
||||
*/ |
||||
AbsEntity getEntity(); |
||||
|
||||
/** |
||||
* 任务是否存在 |
||||
* |
||||
* @return {@code true}任务存在，{@code false} 任务不存在 |
||||
*/ |
||||
boolean taskExists(); |
||||
|
||||
/** |
||||
* 任务是否在执行 |
||||
* |
||||
* @return {@code true} 任务正在执行，{@code false} 任务没有执行 |
||||
*/ |
||||
boolean isRunning(); |
||||
|
||||
/** |
||||
* 检查实体是否合法 |
||||
* |
||||
* @return {@code true}合法 |
||||
*/ |
||||
boolean checkEntity(); |
||||
|
||||
/** |
||||
* 检查文件夹路径 |
||||
* 1、文件夹路径不能为空 |
||||
* 2、文件夹路径不能是文件 |
||||
* |
||||
* @return {@code true} 合法 |
||||
*/ |
||||
boolean checkDirPath(); |
||||
} |
||||
@ -1,66 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.inf; |
||||
|
||||
/** |
||||
* Created by lyy on 2019/4/5. |
||||
* 普通任务接收器功能接口 |
||||
*/ |
||||
public interface INormalTarget { |
||||
|
||||
/** |
||||
* 获取实体 |
||||
*/ |
||||
AbsEntity getEntity(); |
||||
|
||||
/** |
||||
* 任务是否存在 |
||||
* |
||||
* @return {@code true}任务存在，{@code false} 任务不存在 |
||||
*/ |
||||
boolean taskExists(); |
||||
|
||||
/** |
||||
* 任务是否在执行 |
||||
* |
||||
* @return {@code true} 任务正在执行，{@code false} 任务没有执行 |
||||
*/ |
||||
boolean isRunning(); |
||||
|
||||
/** |
||||
* 检查下载实体，判断实体是否合法 合法标准为： |
||||
* 1、下载路径不为null，并且下载路径是正常的http或ftp路径 |
||||
* 2、保存路径不为null，并且保存路径是android文件系统路径 |
||||
* 3、保存路径不能重复 |
||||
* |
||||
* @return {@code true}合法 |
||||
*/ |
||||
boolean checkEntity(); |
||||
|
||||
/** |
||||
* 检查并设置普通任务的文件保存路径 |
||||
* |
||||
* @return {@code true}保存路径合法 |
||||
*/ |
||||
boolean checkFilePath(); |
||||
|
||||
/** |
||||
* 检查普通任务的下载地址 |
||||
* |
||||
* @return {@code true}地址合法 |
||||
*/ |
||||
boolean checkUrl(); |
||||
} |
||||
@ -1,155 +0,0 @@ |
||||
/* |
||||
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
|
||||
* |
||||
* 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.arialyy.aria.core.upload; |
||||
|
||||
import android.text.TextUtils; |
||||
import com.arialyy.aria.core.inf.AbsEntity; |
||||
import com.arialyy.aria.core.common.ftp.IFtpUploadInterceptor; |
||||
import com.arialyy.aria.core.inf.INormalTarget; |
||||
import com.arialyy.aria.core.manager.TaskWrapperManager; |
||||
import com.arialyy.aria.core.queue.UploadTaskQueue; |
||||
import com.arialyy.aria.orm.DbEntity; |
||||
import com.arialyy.aria.util.ALog; |
||||
import com.arialyy.aria.util.CheckUtil; |
||||
import com.arialyy.aria.util.CommonUtil; |
||||
import java.io.File; |
||||
|
||||
/** |
||||
* Created by Aria.Lao on 2019/4/5. |
||||
* 普通上传任务通用功能处理 |
||||
*/ |
||||
class UNormalDelegate<TARGET extends AbsUploadTarget> implements INormalTarget { |
||||
private String TAG = "UNormalDelegate"; |
||||
private UploadEntity mEntity; |
||||
private TARGET mTarget; |
||||
/** |
||||
* 上传路径 |
||||
*/ |
||||
private String mTempUrl; |
||||
|
||||
UNormalDelegate(TARGET target, String filePath, String targetName) { |
||||
mTarget = target; |
||||
initTarget(filePath, targetName); |
||||
} |
||||
|
||||
private void initTarget(String filePath, String targetName) { |
||||
UTaskWrapper taskWrapper = |
||||
TaskWrapperManager.getInstance().getHttpTaskWrapper(UTaskWrapper.class, filePath); |
||||
mEntity = taskWrapper.getEntity(); |
||||
File file = new File(filePath); |
||||
mEntity.setFileName(file.getName()); |
||||
mEntity.setFileSize(file.length()); |
||||
mTarget.setTargetName(targetName); |
||||
mTarget.setTaskWrapper(taskWrapper); |
||||
mTempUrl = mEntity.getUrl(); |
||||
} |
||||
|
||||
TARGET updateUrl(String newUrl) { |
||||
mTempUrl = newUrl; |
||||
return mTarget; |
||||
} |
||||
|
||||
TARGET setUploadInterceptor(IFtpUploadInterceptor uploadInterceptor) { |
||||
if (uploadInterceptor == null) { |
||||
throw new NullPointerException("ftp拦截器为空"); |
||||
} |
||||
mTarget.getTaskWrapper().asFtp().setUploadInterceptor(uploadInterceptor); |
||||
return mTarget; |
||||
} |
||||
|
||||
@Override public AbsEntity getEntity() { |
||||
return mEntity; |
||||
} |
||||
|
||||
@Override public boolean taskExists() { |
||||
return DbEntity.checkDataExist(UploadEntity.class, "key=?", mEntity.getFilePath()); |
||||
} |
||||
|
||||
@Override public boolean isRunning() { |
||||
UploadTask task = UploadTaskQueue.getInstance().getTask(mEntity.getKey()); |
||||
return task != null && task.isRunning(); |
||||
} |
||||
|
||||
@Override public boolean checkEntity() { |
||||
boolean b = checkUrl() && checkFilePath(); |
||||
if (b) { |
||||
mEntity.save(); |
||||
} |
||||
if (mTarget.getTaskWrapper().asFtp().getUrlEntity() != null && mTarget.getTaskWrapper() |
||||
.asFtp() |
||||
.getUrlEntity().isFtps) { |
||||
if (TextUtils.isEmpty(mTarget.getTaskWrapper().asFtp().getUrlEntity().storePath)) { |
||||
ALog.e(TAG, "证书路径为空"); |
||||
return false; |
||||
} |
||||
if (TextUtils.isEmpty(mTarget.getTaskWrapper().asFtp().getUrlEntity().keyAlias)) { |
||||
ALog.e(TAG, "证书别名为空"); |
||||
return false; |
||||
} |
||||
} |
||||
return b; |
||||
} |
||||
|
||||
@Override public boolean checkFilePath() { |
||||
String filePath = mEntity.getFilePath(); |
||||
if (TextUtils.isEmpty(filePath)) { |
||||
ALog.e(TAG, "上传失败，文件路径为null"); |
||||
return false; |
||||
} else if (!filePath.startsWith("/")) { |
||||
ALog.e(TAG, "上传失败，文件路径【" + filePath + "】不合法"); |
||||
return false; |
||||
} |
||||
|
||||
File file = new File(mEntity.getFilePath()); |
||||
if (!file.exists()) { |
||||
ALog.e(TAG, "上传失败，文件【" + filePath + "】不存在"); |
||||
return false; |
||||
} |
||||
if (file.isDirectory()) { |
||||
ALog.e(TAG, "上传失败，文件【" + filePath + "】不能是文件夹"); |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
@Override public boolean checkUrl() { |
||||
|
||||
final String url = mTempUrl; |
||||
if (TextUtils.isEmpty(url)) { |
||||
ALog.e(TAG, "上传失败，url为null"); |
||||
return false; |
||||
} else if (!CheckUtil.checkUrlNotThrow(url)) { |
||||
ALog.e(TAG, "上传失败，url【" + url + "】错误"); |
||||
return false; |
||||
} |
||||
int index = url.indexOf("://"); |
||||
if (index == -1) { |
||||
ALog.e(TAG, "上传失败，url【" + url + "】不合法"); |
||||
return false; |
||||
} |
||||
mEntity.setUrl(url); |
||||
return true; |
||||
} |
||||
|
||||
void setTempUrl(String tempUrl) { |
||||
this.mTempUrl = tempUrl; |
||||
mTarget.getTaskWrapper().asFtp().setUrlEntity(CommonUtil.getFtpUrlInfo(tempUrl)); |
||||
} |
||||
|
||||
public String getTempUrl() { |
||||
return mTempUrl; |
||||
} |
||||
} |
||||
Loading…
Reference in new issue