From b2add1b84f24d317d26d54bf9843feb899ac4ac9 Mon Sep 17 00:00:00 2001 From: kunfei Date: Thu, 5 Sep 2019 20:46:42 +0800 Subject: [PATCH] up --- .../io/legado/app/data/entities/BookSource.kt | 20 +- .../main/java/io/legado/app/utils/ACache.java | 846 ++++++++++++++++++ 2 files changed, 859 insertions(+), 7 deletions(-) create mode 100644 app/src/main/java/io/legado/app/utils/ACache.java diff --git a/app/src/main/java/io/legado/app/data/entities/BookSource.kt b/app/src/main/java/io/legado/app/data/entities/BookSource.kt index 10c420ba0..a8a88e4cb 100644 --- a/app/src/main/java/io/legado/app/data/entities/BookSource.kt +++ b/app/src/main/java/io/legado/app/data/entities/BookSource.kt @@ -10,6 +10,7 @@ import io.legado.app.constant.AppConst import io.legado.app.constant.AppConst.userAgent import io.legado.app.data.entities.rule.* import io.legado.app.help.JsExtensions +import io.legado.app.utils.ACache import io.legado.app.utils.GSON import io.legado.app.utils.fromJsonObject import io.legado.app.utils.getPrefString @@ -124,13 +125,18 @@ data class BookSource( if (a.isNotBlank()) { try { if (it.startsWith("", false)) { - val bindings = SimpleBindings() - bindings["baseUrl"] = bookSourceUrl - bindings["java"] = JsExtensions() - a = AppConst.SCRIPT_ENGINE.eval( - a.substring(4, a.lastIndexOf("<")), - bindings - ).toString() + val aCache = ACache.get(App.INSTANCE, "explore") + a = aCache.getAsString(bookSourceUrl) ?: "" + if (a.isBlank()) { + val bindings = SimpleBindings() + bindings["baseUrl"] = bookSourceUrl + bindings["java"] = JsExtensions() + a = AppConst.SCRIPT_ENGINE.eval( + it.substring(4, it.lastIndexOf("<")), + bindings + ).toString() + aCache.put(bookSourceUrl, a) + } } val b = a.split("(&&|\n)+".toRegex()) b.map { c -> diff --git a/app/src/main/java/io/legado/app/utils/ACache.java b/app/src/main/java/io/legado/app/utils/ACache.java new file mode 100644 index 000000000..381c093b6 --- /dev/null +++ b/app/src/main/java/io/legado/app/utils/ACache.java @@ -0,0 +1,846 @@ +//Copyright (c) 2017. 章钦豪. All rights reserved. +package io.legado.app.utils; + +import android.content.Context; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.Canvas; +import android.graphics.PixelFormat; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.util.Log; + +import androidx.annotation.Nullable; + +import org.json.JSONArray; +import org.json.JSONObject; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.RandomAccessFile; +import java.io.Serializable; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; + + +/** + * 本地缓存 + */ +@SuppressWarnings({"unused", "ResultOfMethodCallIgnored", "WeakerAccess"}) +public class ACache { + public static final int TIME_HOUR = 60 * 60; + public static final int TIME_DAY = TIME_HOUR * 24; + private static final int MAX_SIZE = 1000 * 1000 * 50; // 50 mb + private static final int MAX_COUNT = Integer.MAX_VALUE; // 不限制存放数据的数量 + private static Map mInstanceMap = new HashMap<>(); + private ACacheManager mCache; + + private ACache(File cacheDir, long max_size, int max_count) { + try { + if (!cacheDir.exists() && !cacheDir.mkdirs()) { + Log.i("ACache", "can't make dirs in %s" + cacheDir.getAbsolutePath()); + } + mCache = new ACacheManager(cacheDir, max_size, max_count); + } catch (Exception ignored) { + } + } + + public static ACache get(Context ctx) { + return get(ctx, "ACache"); + } + + public static ACache get(Context ctx, String cacheName) { + File f = new File(ctx.getCacheDir(), cacheName); + return get(f, MAX_SIZE, MAX_COUNT); + } + + public static ACache get(File cacheDir) { + return get(cacheDir, MAX_SIZE, MAX_COUNT); + } + + public static ACache get(Context ctx, long max_zise, int max_count) { + try { + File f = new File(ctx.getCacheDir(), "ACache"); + return get(f, max_zise, max_count); + } catch (Exception ignored) { + } + + return null; + } + + public static ACache get(File cacheDir, long max_zise, int max_count) { + try { + ACache manager = mInstanceMap.get(cacheDir.getAbsoluteFile() + myPid()); + if (manager == null) { + manager = new ACache(cacheDir, max_zise, max_count); + mInstanceMap.put(cacheDir.getAbsolutePath() + myPid(), manager); + } + return manager; + } catch (Exception ignored) { + } + + return null; + } + + private static String myPid() { + return "_" + android.os.Process.myPid(); + } + + // ======================================= + // ============ String数据 读写 ============== + // ======================================= + + /** + * 保存 String数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的String数据 + */ + public void put(String key, String value) { + try { + File file = mCache.newFile(key); + BufferedWriter out = null; + try { + out = new BufferedWriter(new FileWriter(file), 1024); + out.write(value); + } catch (IOException ignored) { + } finally { + if (out != null) { + try { + out.flush(); + out.close(); + } catch (IOException ignored) { + } + } + mCache.put(file); + } + } catch (Exception ignored) { + } + + } + + /** + * 保存 String数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的String数据 + * @param saveTime 保存的时间，单位：秒 + */ + public void put(String key, String value, int saveTime) { + put(key, Utils.newStringWithDateInfo(saveTime, value)); + } + + /** + * 读取 String数据 + * + * @return String 数据 + */ + @Nullable + public String getAsString(String key) { + File file = mCache.get(key); + if (!file.exists()) + return null; + boolean removeFile = false; + try (BufferedReader in = new BufferedReader(new FileReader(file))) { + StringBuilder readString = new StringBuilder(); + String currentLine; + while ((currentLine = in.readLine()) != null) { + readString.append(currentLine); + } + if (!Utils.isDue(readString.toString())) { + return Utils.clearDateInfo(readString.toString()); + } else { + removeFile = true; + return null; + } + } catch (IOException e) { + return null; + } finally { + if (removeFile) + remove(key); + } + } + + // ======================================= + // ========== JSONObject 数据 读写 ========= + // ======================================= + + /** + * 保存 JSONObject数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的JSON数据 + */ + public void put(String key, JSONObject value) { + put(key, value.toString()); + } + + /** + * 保存 JSONObject数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的JSONObject数据 + * @param saveTime 保存的时间，单位：秒 + */ + public void put(String key, JSONObject value, int saveTime) { + put(key, value.toString(), saveTime); + } + + /** + * 读取JSONObject数据 + * + * @return JSONObject数据 + */ + public JSONObject getAsJSONObject(String key) { + String JSONString = getAsString(key); + try { + return new JSONObject(JSONString); + } catch (Exception e) { + return null; + } + } + + // ======================================= + // ============ JSONArray 数据 读写 ============= + // ======================================= + + /** + * 保存 JSONArray数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的JSONArray数据 + */ + public void put(String key, JSONArray value) { + put(key, value.toString()); + } + + /** + * 保存 JSONArray数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的JSONArray数据 + * @param saveTime 保存的时间，单位：秒 + */ + public void put(String key, JSONArray value, int saveTime) { + put(key, value.toString(), saveTime); + } + + /** + * 读取JSONArray数据 + * + * @return JSONArray数据 + */ + public JSONArray getAsJSONArray(String key) { + String JSONString = getAsString(key); + try { + return new JSONArray(JSONString); + } catch (Exception e) { + return null; + } + } + + // ======================================= + // ============== byte 数据 读写 ============= + // ======================================= + + /** + * 保存 byte数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的数据 + */ + public void put(String key, byte[] value) { + File file = mCache.newFile(key); + FileOutputStream out = null; + try { + out = new FileOutputStream(file); + out.write(value); + } catch (Exception ignored) { + } finally { + if (out != null) { + try { + out.flush(); + out.close(); + } catch (IOException ignored) { + } + } + mCache.put(file); + } + } + + /** + * 保存 byte数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的数据 + * @param saveTime 保存的时间，单位：秒 + */ + public void put(String key, byte[] value, int saveTime) { + put(key, Utils.newByteArrayWithDateInfo(saveTime, value)); + } + + /** + * 获取 byte 数据 + * + * @return byte 数据 + */ + public byte[] getAsBinary(String key) { + RandomAccessFile RAFile = null; + boolean removeFile = false; + try { + File file = mCache.get(key); + if (!file.exists()) + return null; + RAFile = new RandomAccessFile(file, "r"); + byte[] byteArray = new byte[(int) RAFile.length()]; + RAFile.read(byteArray); + if (!Utils.isDue(byteArray)) { + return Utils.clearDateInfo(byteArray); + } else { + removeFile = true; + return null; + } + } catch (Exception e) { + e.printStackTrace(); + return null; + } finally { + if (RAFile != null) { + try { + RAFile.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + if (removeFile) + remove(key); + } + } + + // ======================================= + // ============= 序列化 数据 读写 =============== + // ======================================= + + /** + * 保存 Serializable数据 到 缓存中 + * + * @param key 保存的key + * @param value 保存的value + */ + public void put(String key, Serializable value) { + put(key, value, -1); + } + + /** + * 保存 Serializable数据到 缓存中 + * + * @param key 保存的key + * @param value 保存的value + * @param saveTime 保存的时间，单位：秒 + */ + public void put(String key, Serializable value, int saveTime) { + ByteArrayOutputStream baos; + baos = new ByteArrayOutputStream(); + try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { + oos.writeObject(value); + byte[] data = baos.toByteArray(); + if (saveTime != -1) { + put(key, data, saveTime); + } else { + put(key, data); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + + /** + * 读取 Serializable数据 + * + * @return Serializable 数据 + */ + public Object getAsObject(String key) { + byte[] data = getAsBinary(key); + if (data != null) { + ByteArrayInputStream bais = null; + ObjectInputStream ois = null; + try { + bais = new ByteArrayInputStream(data); + ois = new ObjectInputStream(bais); + return ois.readObject(); + } catch (Exception e) { + e.printStackTrace(); + return null; + } finally { + try { + if (bais != null) + bais.close(); + } catch (IOException e) { + e.printStackTrace(); + } + try { + if (ois != null) + ois.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + return null; + + } + + // ======================================= + // ============== bitmap 数据 读写 ============= + // ======================================= + + /** + * 保存 bitmap 到 缓存中 + * + * @param key 保存的key + * @param value 保存的bitmap数据 + */ + public void put(String key, Bitmap value) { + put(key, Utils.Bitmap2Bytes(value)); + } + + /** + * 保存 bitmap 到 缓存中 + * + * @param key 保存的key + * @param value 保存的 bitmap 数据 + * @param saveTime 保存的时间，单位：秒 + */ + public void put(String key, Bitmap value, int saveTime) { + put(key, Utils.Bitmap2Bytes(value), saveTime); + } + + /** + * 读取 bitmap 数据 + * + * @return bitmap 数据 + */ + public Bitmap getAsBitmap(String key) { + if (getAsBinary(key) == null) { + return null; + } + return Utils.Bytes2Bimap(getAsBinary(key)); + } + + // ======================================= + // ============= drawable 数据 读写 ============= + // ======================================= + + /** + * 保存 drawable 到 缓存中 + * + * @param key 保存的key + * @param value 保存的drawable数据 + */ + public void put(String key, Drawable value) { + put(key, Utils.drawable2Bitmap(value)); + } + + /** + * 保存 drawable 到 缓存中 + * + * @param key 保存的key + * @param value 保存的 drawable 数据 + * @param saveTime 保存的时间，单位：秒 + */ + public void put(String key, Drawable value, int saveTime) { + put(key, Utils.drawable2Bitmap(value), saveTime); + } + + /** + * 读取 Drawable 数据 + * + * @return Drawable 数据 + */ + public Drawable getAsDrawable(String key) { + if (getAsBinary(key) == null) { + return null; + } + return Utils.bitmap2Drawable(Utils.Bytes2Bimap(getAsBinary(key))); + } + + /** + * 获取缓存文件 + * + * @return value 缓存的文件 + */ + public File file(String key) { + try { + File f = mCache.newFile(key); + if (f.exists()) { + return f; + } + } catch (Exception e) { + e.printStackTrace(); + } + + return null; + } + + /** + * 移除某个key + * + * @return 是否移除成功 + */ + public boolean remove(String key) { + return mCache.remove(key); + } + + /** + * 清除所有数据 + */ + public void clear() { + mCache.clear(); + } + + /** + * @author 杨福海（michael） www.yangfuhai.com + * @version 1.0 + * @title 时间计算工具类 + */ + private static class Utils { + + private static final char mSeparator = ' '; + + /** + * 判断缓存的String数据是否到期 + * + * @return true：到期了 false：还没有到期 + */ + private static boolean isDue(String str) { + return isDue(str.getBytes()); + } + + /** + * 判断缓存的byte数据是否到期 + * + * @return true：到期了 false：还没有到期 + */ + private static boolean isDue(byte[] data) { + try { + String[] strs = getDateInfoFromDate(data); + if (strs != null && strs.length == 2) { + String saveTimeStr = strs[0]; + while (saveTimeStr.startsWith("0")) { + saveTimeStr = saveTimeStr + .substring(1); + } + long saveTime = Long.valueOf(saveTimeStr); + long deleteAfter = Long.valueOf(strs[1]); + if (System.currentTimeMillis() > saveTime + deleteAfter * 1000) { + return true; + } + } + } catch (Exception e) { + e.printStackTrace(); + } + + return false; + } + + private static String newStringWithDateInfo(int second, String strInfo) { + return createDateInfo(second) + strInfo; + } + + private static byte[] newByteArrayWithDateInfo(int second, byte[] data2) { + byte[] data1 = createDateInfo(second).getBytes(); + byte[] retdata = new byte[data1.length + data2.length]; + System.arraycopy(data1, 0, retdata, 0, data1.length); + System.arraycopy(data2, 0, retdata, data1.length, data2.length); + return retdata; + } + + private static String clearDateInfo(String strInfo) { + if (strInfo != null && hasDateInfo(strInfo.getBytes())) { + strInfo = strInfo.substring(strInfo.indexOf(mSeparator) + 1); + } + return strInfo; + } + + private static byte[] clearDateInfo(byte[] data) { + if (hasDateInfo(data)) { + return copyOfRange(data, indexOf(data, mSeparator) + 1, + data.length); + } + return data; + } + + private static boolean hasDateInfo(byte[] data) { + return data != null && data.length > 15 && data[13] == '-' + && indexOf(data, mSeparator) > 14; + } + + private static String[] getDateInfoFromDate(byte[] data) { + if (hasDateInfo(data)) { + String saveDate = new String(copyOfRange(data, 0, 13)); + String deleteAfter = new String(copyOfRange(data, 14, + indexOf(data, mSeparator))); + return new String[]{saveDate, deleteAfter}; + } + return null; + } + + private static int indexOf(byte[] data, char c) { + for (int i = 0; i < data.length; i++) { + if (data[i] == c) { + return i; + } + } + return -1; + } + + private static byte[] copyOfRange(byte[] original, int from, int to) { + int newLength = to - from; + if (newLength < 0) + throw new IllegalArgumentException(from + " > " + to); + byte[] copy = new byte[newLength]; + System.arraycopy(original, from, copy, 0, + Math.min(original.length - from, newLength)); + return copy; + } + + private static String createDateInfo(int second) { + StringBuilder currentTime = new StringBuilder(System.currentTimeMillis() + ""); + while (currentTime.length() < 13) { + currentTime.insert(0, "0"); + } + return currentTime + "-" + second + mSeparator; + } + + /* + * Bitmap → byte[] + */ + private static byte[] Bitmap2Bytes(Bitmap bm) { + if (bm == null) { + return null; + } + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + bm.compress(Bitmap.CompressFormat.PNG, 100, baos); + return baos.toByteArray(); + } + + /* + * byte[] → Bitmap + */ + private static Bitmap Bytes2Bimap(byte[] b) { + if (b.length == 0) { + return null; + } + return BitmapFactory.decodeByteArray(b, 0, b.length); + } + + /* + * Drawable → Bitmap + */ + private static Bitmap drawable2Bitmap(Drawable drawable) { + if (drawable == null) { + return null; + } + // 取 drawable 的长宽 + int w = drawable.getIntrinsicWidth(); + int h = drawable.getIntrinsicHeight(); + // 取 drawable 的颜色格式 + Bitmap.Config config = drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888 + : Bitmap.Config.RGB_565; + // 建立对应 bitmap + Bitmap bitmap = Bitmap.createBitmap(w, h, config); + // 建立对应 bitmap 的画布 + Canvas canvas = new Canvas(bitmap); + drawable.setBounds(0, 0, w, h); + // 把 drawable 内容画到画布中 + drawable.draw(canvas); + return bitmap; + } + + /* + * Bitmap → Drawable + */ + @SuppressWarnings("deprecation") + private static Drawable bitmap2Drawable(Bitmap bm) { + if (bm == null) { + return null; + } + return new BitmapDrawable(bm); + } + } + + /** + * @author 杨福海（michael） www.yangfuhai.com + * @version 1.0 + * @title 缓存管理器 + */ + public class ACacheManager { + private final AtomicLong cacheSize; + private final AtomicInteger cacheCount; + private final long sizeLimit; + private final int countLimit; + private final Map lastUsageDates = Collections + .synchronizedMap(new HashMap<>()); + protected File cacheDir; + + private ACacheManager(File cacheDir, long sizeLimit, int countLimit) { + this.cacheDir = cacheDir; + this.sizeLimit = sizeLimit; + this.countLimit = countLimit; + cacheSize = new AtomicLong(); + cacheCount = new AtomicInteger(); + calculateCacheSizeAndCacheCount(); + } + + /** + * 计算 cacheSize和cacheCount + */ + private void calculateCacheSizeAndCacheCount() { + new Thread(() -> { + + try { + int size = 0; + int count = 0; + File[] cachedFiles = cacheDir.listFiles(); + if (cachedFiles != null) { + for (File cachedFile : cachedFiles) { + size += calculateSize(cachedFile); + count += 1; + lastUsageDates.put(cachedFile, + cachedFile.lastModified()); + } + cacheSize.set(size); + cacheCount.set(count); + } + } catch (Exception e) { + e.printStackTrace(); + } + + }).start(); + } + + private void put(File file) { + + try { + int curCacheCount = cacheCount.get(); + while (curCacheCount + 1 > countLimit) { + long freedSize = removeNext(); + cacheSize.addAndGet(-freedSize); + + curCacheCount = cacheCount.addAndGet(-1); + } + cacheCount.addAndGet(1); + + long valueSize = calculateSize(file); + long curCacheSize = cacheSize.get(); + while (curCacheSize + valueSize > sizeLimit) { + long freedSize = removeNext(); + curCacheSize = cacheSize.addAndGet(-freedSize); + } + cacheSize.addAndGet(valueSize); + + long currentTime = System.currentTimeMillis(); + file.setLastModified(currentTime); + lastUsageDates.put(file, currentTime); + } catch (Exception e) { + e.printStackTrace(); + } + + } + + private File get(String key) { + File file = newFile(key); + long currentTime = System.currentTimeMillis(); + file.setLastModified(currentTime); + lastUsageDates.put(file, currentTime); + + return file; + } + + private File newFile(String key) { + return new File(cacheDir, key.hashCode() + ""); + } + + private boolean remove(String key) { + File image = get(key); + return image.delete(); + } + + private void clear() { + try { + lastUsageDates.clear(); + cacheSize.set(0); + File[] files = cacheDir.listFiles(); + if (files != null) { + for (File f : files) { + f.delete(); + } + } + } catch (Exception e) { + e.printStackTrace(); + } + + } + + /** + * 移除旧的文件 + */ + private long removeNext() { + try { + if (lastUsageDates.isEmpty()) { + return 0; + } + + Long oldestUsage = null; + File mostLongUsedFile = null; + Set> entries = lastUsageDates.entrySet(); + synchronized (lastUsageDates) { + for (Entry entry : entries) { + if (mostLongUsedFile == null) { + mostLongUsedFile = entry.getKey(); + oldestUsage = entry.getValue(); + } else { + Long lastValueUsage = entry.getValue(); + if (lastValueUsage < oldestUsage) { + oldestUsage = lastValueUsage; + mostLongUsedFile = entry.getKey(); + } + } + } + } + + long fileSize = 0; + if (mostLongUsedFile != null) { + fileSize = calculateSize(mostLongUsedFile); + if (mostLongUsedFile.delete()) { + lastUsageDates.remove(mostLongUsedFile); + } + } + return fileSize; + } catch (Exception e) { + e.printStackTrace(); + return 0; + } + + + } + + private long calculateSize(File file) { + return file.length(); + } + } + +}