Initial commit

sources/com/ubt/jimu/base/http/cache/CacheKey.java

@@ -0,0 +1,17 @@
+package com.ubt.jimu.base.http.cache;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes.dex */
+public @interface CacheKey {
+    String Key() default "";
+
+    long Time() default 0;
+}

sources/com/ubt/jimu/base/http/cache/CacheManager.java

@@ -0,0 +1,293 @@
+package com.ubt.jimu.base.http.cache;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.os.Environment;
+import android.text.TextUtils;
+import android.util.Base64;
+import com.ubt.jimu.JimuApplication;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.StreamCorruptedException;
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import okhttp3.internal.cache.DiskLruCache;
+import okhttp3.internal.io.FileSystem;
+
+/* loaded from: classes.dex */
+public final class CacheManager<T> {
+    private static final String CACHE_DIR = "jimuCacheDir";
+    private static final int DISK_CACHE_INDEX = 0;
+    private static final long DISK_CACHE_SIZE = 10485760;
+    public static final String TAG = "CacheManager";
+    private static CacheManager mCacheManager;
+    private Context context;
+    private DiskLruCache mDiskLruCache;
+
+    public CacheManager() {
+        File diskCacheDir = getDiskCacheDir(JimuApplication.l(), CACHE_DIR);
+        if (!diskCacheDir.exists()) {
+            diskCacheDir.mkdirs();
+        }
+        if (diskCacheDir.getUsableSpace() > DISK_CACHE_SIZE) {
+            try {
+                this.mDiskLruCache = DiskLruCache.create(FileSystem.SYSTEM, diskCacheDir, 3960075, 10, DISK_CACHE_SIZE);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private String encryptMD5(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return "";
+        }
+        try {
+            byte[] digest = MessageDigest.getInstance("MD5").digest(str.getBytes("UTF-8"));
+            StringBuilder sb = new StringBuilder(digest.length * 2);
+            for (byte b : digest) {
+                int i = b & 255;
+                if (i < 16) {
+                    sb.append("0");
+                }
+                sb.append(Integer.toHexString(i));
+            }
+            return sb.toString();
+        } catch (UnsupportedEncodingException | NoSuchAlgorithmException e) {
+            e.printStackTrace();
+            return str;
+        }
+    }
+
+    private int getAppVersion(Context context) {
+        try {
+            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+            if (packageInfo == null) {
+                return 0;
+            }
+            return packageInfo.versionCode;
+        } catch (PackageManager.NameNotFoundException e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    private Bitmap getBitmapCache(String str) {
+        return null;
+    }
+
+    private File getDiskCacheDir(Context context, String str) {
+        String absolutePath;
+        if ("mounted".equals(Environment.getExternalStorageState()) || !Environment.isExternalStorageRemovable()) {
+            File externalCacheDir = context.getExternalCacheDir();
+            absolutePath = externalCacheDir != null ? externalCacheDir.getAbsolutePath() : context.getCacheDir().getPath();
+        } else {
+            absolutePath = context.getCacheDir().getPath();
+        }
+        return new File(absolutePath + File.separator + str);
+    }
+
+    public static synchronized CacheManager getInstance(Context context) {
+        CacheManager cacheManager;
+        synchronized (CacheManager.class) {
+            if (mCacheManager == null) {
+                mCacheManager = new CacheManager();
+            }
+            cacheManager = mCacheManager;
+        }
+        return cacheManager;
+    }
+
+    private void putBitmapCache(Bitmap bitmap) {
+    }
+
+    public void closeDiskLruCache() {
+        DiskLruCache diskLruCache = this.mDiskLruCache;
+        if (diskLruCache == null) {
+            return;
+        }
+        try {
+            diskLruCache.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public T getObjectCache(String str, long j) {
+        String stringCache = getStringCache(str);
+        if (TextUtils.isEmpty(stringCache)) {
+            return null;
+        }
+        String[] split = stringCache.split("@");
+        if (System.currentTimeMillis() - Long.parseLong(split[0]) > j) {
+            return null;
+        }
+        try {
+            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(Base64.decode(split[1].getBytes(), 0));
+            try {
+                ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
+                try {
+                    try {
+                        T t = (T) objectInputStream.readObject();
+                        objectInputStream.close();
+                        byteArrayInputStream.close();
+                        return t;
+                    } catch (ClassNotFoundException e) {
+                        e.printStackTrace();
+                        objectInputStream.close();
+                        byteArrayInputStream.close();
+                        return null;
+                    }
+                } finally {
+                }
+            } finally {
+            }
+        } catch (StreamCorruptedException e2) {
+            e2.printStackTrace();
+            return null;
+        } catch (IOException e3) {
+            e3.printStackTrace();
+            return null;
+        }
+    }
+
+    public String getStringCache(String str) {
+        if (this.mDiskLruCache == null) {
+        }
+        return "";
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:38:0x0079 A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:45:? A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:46:0x006f A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:55:0x0067 -> B:12:0x006a). Please report as a decompilation issue!!! */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public void putObjectCache(java.lang.String r6, java.lang.Object r7) {
+        /*
+            r5 = this;
+            r0 = 0
+            java.io.ByteArrayOutputStream r1 = new java.io.ByteArrayOutputStream     // Catch: java.lang.Throwable -> L4d java.io.IOException -> L51
+            r1.<init>()     // Catch: java.lang.Throwable -> L4d java.io.IOException -> L51
+            java.io.ObjectOutputStream r2 = new java.io.ObjectOutputStream     // Catch: java.lang.Throwable -> L46 java.io.IOException -> L49
+            r2.<init>(r1)     // Catch: java.lang.Throwable -> L46 java.io.IOException -> L49
+            r2.writeObject(r7)     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            byte[] r7 = r1.toByteArray()     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            r0 = 0
+            java.lang.String r7 = android.util.Base64.encodeToString(r7, r0)     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            long r3 = java.lang.System.currentTimeMillis()     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            java.lang.Long r0 = java.lang.Long.valueOf(r3)     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            java.lang.StringBuilder r3 = new java.lang.StringBuilder     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            r3.<init>()     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            r3.append(r0)     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            java.lang.String r0 = "@"
+            r3.append(r0)     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            r3.append(r7)     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            java.lang.String r7 = r3.toString()     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            r5.putStringCache(r6, r7)     // Catch: java.lang.Throwable -> L42 java.io.IOException -> L44
+            r1.close()     // Catch: java.io.IOException -> L3a
+            goto L3e
+        L3a:
+            r6 = move-exception
+            r6.printStackTrace()
+        L3e:
+            r2.close()     // Catch: java.io.IOException -> L66
+            goto L6a
+        L42:
+            r6 = move-exception
+            goto L6d
+        L44:
+            r6 = move-exception
+            goto L4b
+        L46:
+            r6 = move-exception
+            r2 = r0
+            goto L6d
+        L49:
+            r6 = move-exception
+            r2 = r0
+        L4b:
+            r0 = r1
+            goto L53
+        L4d:
+            r6 = move-exception
+            r1 = r0
+            r2 = r1
+            goto L6d
+        L51:
+            r6 = move-exception
+            r2 = r0
+        L53:
+            r6.printStackTrace()     // Catch: java.lang.Throwable -> L6b
+            if (r0 == 0) goto L60
+            r0.close()     // Catch: java.io.IOException -> L5c
+            goto L60
+        L5c:
+            r6 = move-exception
+            r6.printStackTrace()
+        L60:
+            if (r2 == 0) goto L6a
+            r2.close()     // Catch: java.io.IOException -> L66
+            goto L6a
+        L66:
+            r6 = move-exception
+            r6.printStackTrace()
+        L6a:
+            return
+        L6b:
+            r6 = move-exception
+            r1 = r0
+        L6d:
+            if (r1 == 0) goto L77
+            r1.close()     // Catch: java.io.IOException -> L73
+            goto L77
+        L73:
+            r7 = move-exception
+            r7.printStackTrace()
+        L77:
+            if (r2 == 0) goto L81
+            r2.close()     // Catch: java.io.IOException -> L7d
+            goto L81
+        L7d:
+            r7 = move-exception
+            r7.printStackTrace()
+        L81:
+            throw r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.ubt.jimu.base.http.cache.CacheManager.putObjectCache(java.lang.String, java.lang.Object):void");
+    }
+
+    public void putStringCache(String str, String str2) {
+        if (this.mDiskLruCache == null) {
+        }
+    }
+
+    public boolean removeCache(String str) {
+        DiskLruCache diskLruCache = this.mDiskLruCache;
+        if (diskLruCache == null) {
+            return false;
+        }
+        try {
+            return diskLruCache.remove(encryptMD5(str));
+        } catch (IOException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    public void setCache(final String str, final String str2) {
+        new Thread() { // from class: com.ubt.jimu.base.http.cache.CacheManager.1
+            @Override // java.lang.Thread, java.lang.Runnable
+            public void run() {
+                CacheManager.this.putStringCache(str, str2);
+            }
+        }.start();
+    }
+}

sources/com/ubt/jimu/base/http/cache/CacheSubscriber.java

@@ -0,0 +1,93 @@
+package com.ubt.jimu.base.http.cache;
+
+import android.support.v4.media.MediaDescriptionCompat;
+import android.text.TextUtils;
+import com.ubt.jimu.utils.LogUtils;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import java.lang.reflect.Method;
+
+/* loaded from: classes.dex */
+public abstract class CacheSubscriber<T> implements Observer<T> {
+    private String key;
+    private final CacheManager<T> mCacheManager = new CacheManager<>();
+
+    private void getCacheConfiguration() {
+        CacheKey cacheKey;
+        if (!TextUtils.isEmpty(setCacheKey())) {
+            T objectCache = this.mCacheManager.getObjectCache(this.key, 3600000L);
+            if (objectCache != null) {
+                LogUtils.c("调用缓存显示方法");
+                showCacheData(objectCache);
+                return;
+            }
+            return;
+        }
+        for (Method method : getClass().getDeclaredMethods()) {
+            if (method.getName().equals("showCacheData") && (cacheKey = (CacheKey) method.getAnnotation(CacheKey.class)) != null) {
+                String Key = cacheKey.Key();
+                LogUtils.c("缓存Key:" + Key);
+                long Time = cacheKey.Time();
+                if (!TextUtils.isEmpty(Key)) {
+                    this.key = Key;
+                    T objectCache2 = this.mCacheManager.getObjectCache(Key, Time);
+                    LogUtils.c("缓存中的T:" + objectCache2);
+                    if (objectCache2 != null) {
+                        LogUtils.c("调用缓存显示方法");
+                        showCacheData(objectCache2);
+                    }
+                }
+            }
+        }
+    }
+
+    public void complete() {
+    }
+
+    @Override // io.reactivex.Observer
+    public void onComplete() {
+        complete();
+        CacheManager<T> cacheManager = this.mCacheManager;
+        if (cacheManager != null) {
+            cacheManager.closeDiskLruCache();
+        }
+    }
+
+    @Override // io.reactivex.Observer
+    public void onError(Throwable th) {
+        CacheManager<T> cacheManager = this.mCacheManager;
+        if (cacheManager != null) {
+            cacheManager.closeDiskLruCache();
+        }
+        onFailure(th);
+    }
+
+    public abstract void onFailure(Throwable th);
+
+    @Override // io.reactivex.Observer
+    public void onNext(T t) {
+        this.mCacheManager.putObjectCache(this.key, t);
+        onSucceed(t);
+        CacheManager<T> cacheManager = this.mCacheManager;
+        if (cacheManager != null) {
+            cacheManager.closeDiskLruCache();
+        }
+    }
+
+    public abstract void onStart(Disposable disposable);
+
+    @Override // io.reactivex.Observer
+    public void onSubscribe(Disposable disposable) {
+        getCacheConfiguration();
+        onStart(disposable);
+    }
+
+    public abstract void onSucceed(T t);
+
+    public String setCacheKey() {
+        return null;
+    }
+
+    @CacheKey(Key = "KEY", Time = MediaDescriptionCompat.BT_FOLDER_TYPE_MIXED)
+    public abstract void showCacheData(T t);
+}