Skip to content

Instantly share code, notes, and snippets.

@guffyWave

guffyWave/gist:5f36094fe852cfccf368fd56e1088f2d

Created December 24, 2018 12:47
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save guffyWave/5f36094fe852cfccf368fd56e1088f2d to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save guffyWave/5f36094fe852cfccf368fd56e1088f2d to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. guffyWave created this gist Dec 24, 2018.
    562 changes: 562 additions & 0 deletions gistfile1.txt
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,562 @@
    Taken from
    https://www.programcreek.com/java-api-examples/?code=lujianzhao/AndroidBase/AndroidBase-master/AndroidBase/src/main/java/com/ljz/base/common/diskcache/DiskLruCacheHelper.java#

    import android.content.Context;
    import android.graphics.Bitmap;
    import android.graphics.drawable.Drawable;
    import android.os.Environment;
    import android.util.Log;

    import com.jakewharton.disklrucache.DiskLruCache;

    import org.json.JSONArray;
    import org.json.JSONException;
    import org.json.JSONObject;

    import java.io.BufferedWriter;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.Serializable;

    /**
    * Created by zhy on 15/7/28.
    */
    public class DiskLruCacheHelper {
    private static final String DIR_NAME = "diskCache";
    private static final int MAX_COUNT = 5 * 1024 * 1024;
    private static final int DEFAULT_APP_VERSION = 1;

    /**
    * The default valueCount when open DiskLruCache.
    */
    private static final int DEFAULT_VALUE_COUNT = 1;

    private static final String TAG = "DiskLruCacheHelper";

    private DiskLruCache mDiskLruCache;

    public DiskLruCacheHelper(Context context) throws IOException {
    mDiskLruCache = generateCache(context, DIR_NAME, MAX_COUNT);
    }

    public DiskLruCacheHelper(Context context, String dirName) throws IOException {
    mDiskLruCache = generateCache(context, dirName, MAX_COUNT);
    }

    public DiskLruCacheHelper(Context context, String dirName, int maxCount) throws IOException {
    mDiskLruCache = generateCache(context, dirName, maxCount);
    }

    //custom cache dir
    public DiskLruCacheHelper(File dir) throws IOException {
    mDiskLruCache = generateCache(null, dir, MAX_COUNT);
    }

    public DiskLruCacheHelper(Context context, File dir) throws IOException {
    mDiskLruCache = generateCache(context, dir, MAX_COUNT);
    }

    public DiskLruCacheHelper(Context context, File dir, int maxCount) throws IOException {
    mDiskLruCache = generateCache(context, dir, maxCount);
    }

    private DiskLruCache generateCache(Context context, File dir, int maxCount) throws IOException {
    if (!dir.exists() || !dir.isDirectory()) {
    throw new IllegalArgumentException(
    dir + " is not a directory or does not exists. ");
    }

    int appVersion = context == null ? DEFAULT_APP_VERSION : Utils.getAppVersion(context);

    DiskLruCache diskLruCache = DiskLruCache.open(
    dir,
    appVersion,
    DEFAULT_VALUE_COUNT,
    maxCount);

    return diskLruCache;
    }

    private DiskLruCache generateCache(Context context, String dirName, int maxCount) throws IOException {
    DiskLruCache diskLruCache = DiskLruCache.open(
    getDiskCacheDir(context, dirName),
    Utils.getAppVersion(context),
    DEFAULT_VALUE_COUNT,
    maxCount);
    return diskLruCache;
    }
    // =======================================
    // ============== String 数据 读写 =============
    // =======================================

    public void put(String key, String value) {
    DiskLruCache.Editor edit = null;
    BufferedWriter bw = null;
    try {
    edit = editor(key);
    if (edit == null) return;
    OutputStream os = edit.newOutputStream(0);
    bw = new BufferedWriter(new OutputStreamWriter(os));
    bw.write(value);
    edit.commit();//write CLEAN
    } catch (IOException e) {
    e.printStackTrace();
    try {
    //s
    edit.abort();//write REMOVE
    } catch (IOException e1) {
    e1.printStackTrace();
    }
    } finally {
    try {
    if (bw != null)
    bw.close();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

    public String getAsString(String key) {
    InputStream inputStream = null;
    inputStream = get(key);
    if (inputStream == null) return null;
    String str = null;
    try {
    str = Utils.readFully(new InputStreamReader(inputStream, Utils.UTF_8));
    } catch (IOException e) {
    e.printStackTrace();
    try {
    inputStream.close();
    } catch (IOException e1) {
    e1.printStackTrace();
    }
    }
    return str;
    }

    public void put(String key, JSONObject jsonObject) {
    put(key, jsonObject.toString());
    }

    public JSONObject getAsJson(String key) {
    String val = getAsString(key);
    try {
    if (val != null)
    return new JSONObject(val);
    } catch (JSONException e) {
    e.printStackTrace();
    }
    return null;
    }

    // =======================================
    // ============ JSONArray 数据 读写 =============
    // =======================================

    public void put(String key, JSONArray jsonArray) {
    put(key, jsonArray.toString());
    }

    public JSONArray getAsJSONArray(String key) {
    String JSONString = getAsString(key);
    try {
    JSONArray obj = new JSONArray(JSONString);
    return obj;
    } catch (Exception e) {
    e.printStackTrace();
    return null;
    }
    }

    // =======================================
    // ============== byte 数据 读写 =============
    // =======================================

    /**
    * 保存 byte数据 到 缓存中
    *
    * @param key 保存的key
    * @param value 保存的数据
    */
    public void put(String key, byte[] value) {
    OutputStream out = null;
    DiskLruCache.Editor editor = null;
    try {
    editor = editor(key);
    if (editor == null) {
    return;
    }
    out = editor.newOutputStream(0);
    out.write(value);
    out.flush();
    editor.commit();//write CLEAN
    } catch (Exception e) {
    e.printStackTrace();
    try {
    editor.abort();//write REMOVE
    } catch (IOException e1) {
    e1.printStackTrace();
    }

    } finally {
    if (out != null) {
    try {
    out.close();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }
    }


    public byte[] getAsBytes(String key) {
    byte[] res = null;
    InputStream is = get(key);
    if (is == null) return null;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try {
    byte[] buf = new byte[256];
    int len = 0;
    while ((len = is.read(buf)) != -1) {
    baos.write(buf, 0, len);
    }
    res = baos.toByteArray();
    } catch (IOException e) {
    e.printStackTrace();
    }
    return res;
    }


    // =======================================
    // ============== 序列化 数据 读写 =============
    // =======================================
    public void put(String key, Serializable value) {
    DiskLruCache.Editor editor = editor(key);
    ObjectOutputStream oos = null;
    if (editor == null) return;
    try {
    OutputStream os = editor.newOutputStream(0);
    oos = new ObjectOutputStream(os);
    oos.writeObject(value);
    oos.flush();
    editor.commit();
    } catch (IOException e) {
    e.printStackTrace();
    try {
    editor.abort();
    } catch (IOException e1) {
    e1.printStackTrace();
    }
    } finally {
    try {
    if (oos != null)
    oos.close();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

    public <T> T getAsSerializable(String key) {
    T t = null;
    InputStream is = get(key);
    ObjectInputStream ois = null;
    if (is == null) return null;
    try {
    ois = new ObjectInputStream(is);
    t = (T) ois.readObject();
    } catch (ClassNotFoundException | IOException e) {
    e.printStackTrace();
    } finally {
    try {
    if (ois != null)
    ois.close();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    return t;
    }

    // =======================================
    // ============== bitmap 数据 读写 =============
    // =======================================
    public void put(String key, Bitmap bitmap) {
    put(key, Utils.bitmap2Bytes(bitmap));
    }

    public Bitmap getAsBitmap(String key) {
    byte[] bytes = getAsBytes(key);
    if (bytes == null) return null;
    return Utils.bytes2Bitmap(bytes);
    }

    // =======================================
    // ============= drawable 数据 读写 =============
    // =======================================
    public void put(String key, Drawable value) {
    put(key, Utils.drawable2Bitmap(value));
    }

    public Drawable getAsDrawable(String key) {
    byte[] bytes = getAsBytes(key);
    if (bytes == null) {
    return null;
    }
    return Utils.bitmap2Drawable(Utils.bytes2Bitmap(bytes));
    }

    // =======================================
    // ============= other methods =============
    // =======================================
    public boolean remove(String key) {
    try {
    key = Utils.hashKeyForDisk(key);
    return mDiskLruCache.remove(key);
    } catch (IOException e) {
    e.printStackTrace();
    }
    return false;
    }

    public void close() throws IOException {
    mDiskLruCache.close();
    }

    public void delete() throws IOException {
    mDiskLruCache.delete();
    }

    public void flush() throws IOException {
    mDiskLruCache.flush();
    }

    public boolean isClosed() {
    return mDiskLruCache.isClosed();
    }

    public long size() {
    return mDiskLruCache.size();
    }

    public void setMaxSize(long maxSize) {
    mDiskLruCache.setMaxSize(maxSize);
    }

    public File getDirectory() {
    return mDiskLruCache.getDirectory();
    }

    public long getMaxSize() {
    return mDiskLruCache.getMaxSize();
    }


    // =======================================
    // ===遇到文件比较大的，可以直接通过流读写 =====
    // =======================================
    //basic editor
    public DiskLruCache.Editor editor(String key) {
    try {
    key = Utils.hashKeyForDisk(key);
    //wirte DIRTY
    DiskLruCache.Editor edit = mDiskLruCache.edit(key);
    //edit maybe null :the entry is editing
    if (edit == null) {
    Log.w(TAG, "the entry spcified key:" + key + " is editing by other . ");
    }
    return edit;
    } catch (IOException e) {
    e.printStackTrace();
    }

    return null;
    }


    //basic get
    public InputStream get(String key) {
    try {
    DiskLruCache.Snapshot snapshot = mDiskLruCache.get(Utils.hashKeyForDisk(key));
    if (snapshot == null) //not find entry , or entry.readable = false
    {
    Log.e(TAG, "not find entry , or entry.readable = false");
    return null;
    }
    //write READ
    return snapshot.getInputStream(0);

    } catch (IOException e) {
    e.printStackTrace();
    return null;
    }

    }


    // =======================================
    // ============== 序列化 数据 读写 =============
    // =======================================

    private File getDiskCacheDir(Context context, String uniqueName) {
    String cachePath;
    if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
    || !Environment.isExternalStorageRemovable()) {
    cachePath = context.getExternalCacheDir().getPath();
    } else {
    cachePath = context.getCacheDir().getPath();
    }
    return new File(cachePath + File.separator + uniqueName);
    }

    }

    package com.magicpin.local.utils.images;

    public class DiskLruCacheUtil {
    static final Charset US_ASCII = Charset.forName("US-ASCII");
    static final Charset UTF_8 = Charset.forName("UTF-8");

    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) {
    }
    }
    }


    public static int getAppVersion(Context context) {
    try {
    PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
    return info.versionCode;
    } catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
    }
    return 1;
    }


    public static String hashKeyForDisk(String key) {
    String cacheKey;
    try {
    final MessageDigest mDigest = MessageDigest.getInstance("MD5");
    mDigest.update(key.getBytes());
    cacheKey = bytesToHexString(mDigest.digest());
    } catch (NoSuchAlgorithmException e) {
    cacheKey = String.valueOf(key.hashCode());
    }
    return cacheKey;
    }

    public static String bytesToHexString(byte[] bytes) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < bytes.length; i++) {
    String hex = Integer.toHexString(0xFF & bytes[i]);
    if (hex.length() == 1) {
    sb.append('0');
    }
    sb.append(hex);
    }
    return sb.toString();
    }

    public static byte[] bitmap2Bytes(Bitmap bm) {
    if (bm == null) {
    return null;
    }
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
    return baos.toByteArray();
    }

    public static Bitmap bytes2Bitmap(byte[] bytes) {
    return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
    }


    /**
    * Drawable → Bitmap
    */
    public 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")
    public static Drawable bitmap2Drawable(Bitmap bm) {
    if (bm == null) {
    return null;
    }
    BitmapDrawable bd = new BitmapDrawable(bm);
    bd.setTargetDensity(bm.getDensity());
    return new BitmapDrawable(bm);
    }
    }