正在查看： Cashalo v2.25.0.0 应用的 LockCache.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
Cashalo v2.25.0.0 - LockCache.java 源代码
package com.oriente.locklibrary.utils;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Process;
import com.facebook.appevents.AppEventsConstants;
import com.fullstory.FS;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
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;
import java.nio.charset.Charset;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.json.JSONArray;
import org.json.JSONObject;
public class LockCache {
private static final int MAX_COUNT = Integer.MAX_VALUE;
private static final int MAX_SIZE = 50000000;
public static final int TIME_DAY = 86400;
public static final int TIME_HOUR = 3600;
private LockCacheManager mCache;
private static Map<String, LockCache> mInstanceMap = new HashMap();
private static final String TAG = "LockCache";
public static LockCache get(Context context) {
return get(context, "LockCache");
}
public static LockCache get(Context context, String str) {
return get(new File(context.getCacheDir(), str), 50000000L, Integer.MAX_VALUE);
}
public static LockCache get(File file) {
return get(file, 50000000L, Integer.MAX_VALUE);
}
public static LockCache get(Context context, long j, int i) {
return get(new File(context.getCacheDir(), "ACache"), j, i);
}
public static LockCache get(File file, long j, int i) {
LockCache lockCache = mInstanceMap.get(file.getAbsoluteFile() + myPid());
if (lockCache != null) {
return lockCache;
}
LockCache lockCache2 = new LockCache(file, j, i);
mInstanceMap.put(file.getAbsolutePath() + myPid(), lockCache2);
return lockCache2;
}
private static String myPid() {
return "_" + Process.myPid();
}
private LockCache(File file, long j, int i) {
if (!file.exists() && !file.mkdirs()) {
throw new RuntimeException("can't make dirs in " + file.getAbsolutePath());
}
this.mCache = new LockCacheManager(file, j, i);
}
class XFileOutputStream extends FileOutputStream {
File file;
XFileOutputStream(File file) throws FileNotFoundException {
super(file);
this.file = file;
}
@Override
public void close() throws IOException {
super.close();
LockCache.this.mCache.put(this.file);
}
}
public void put(String str, String str2) {
BufferedWriter bufferedWriter;
File newFile = this.mCache.newFile(str);
BufferedWriter bufferedWriter2 = null;
try {
try {
bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(newFile), "UTF-8"), 1024);
} catch (Throwable th) {
th = th;
}
} catch (IOException e) {
e = e;
}
try {
bufferedWriter.write(str2);
try {
bufferedWriter.flush();
bufferedWriter.close();
} catch (IOException e2) {
e = e2;
FS.log_e(TAG, e.getMessage(), e);
this.mCache.put(newFile);
}
} catch (IOException e3) {
e = e3;
bufferedWriter2 = bufferedWriter;
FS.log_e(TAG, e.getMessage(), e);
if (bufferedWriter2 != null) {
try {
bufferedWriter2.flush();
bufferedWriter2.close();
} catch (IOException e4) {
e = e4;
FS.log_e(TAG, e.getMessage(), e);
this.mCache.put(newFile);
}
}
this.mCache.put(newFile);
} catch (Throwable th2) {
th = th2;
bufferedWriter2 = bufferedWriter;
if (bufferedWriter2 != null) {
try {
bufferedWriter2.flush();
bufferedWriter2.close();
} catch (IOException e5) {
FS.log_e(TAG, e5.getMessage(), e5);
}
}
this.mCache.put(newFile);
throw th;
}
this.mCache.put(newFile);
}
public void put(String str, String str2, int i) {
put(str, Utils.newStringWithDateInfo(i, str2));
}
public String getAsString(String str) {
BufferedReader bufferedReader;
File file = this.mCache.get(str);
?? exists = file.exists();
BufferedReader bufferedReader2 = null;
try {
if (exists == 0) {
return null;
}
try {
bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));
String str2 = "";
while (true) {
try {
String readLine = bufferedReader.readLine();
if (readLine == null) {
break;
}
str2 = str2 + readLine;
} catch (IOException e) {
e = e;
FS.log_e(TAG, e.getMessage(), e);
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (IOException e2) {
FS.log_e(TAG, e2.getMessage(), e2);
}
}
return null;
}
}
if (Utils.isDue(str2)) {
try {
bufferedReader.close();
} catch (IOException e3) {
FS.log_e(TAG, e3.getMessage(), e3);
}
remove(str);
return null;
}
String clearDateInfo = Utils.clearDateInfo(str2);
try {
bufferedReader.close();
} catch (IOException e4) {
FS.log_e(TAG, e4.getMessage(), e4);
}
return clearDateInfo;
} catch (IOException e5) {
e = e5;
bufferedReader = null;
} catch (Throwable th) {
th = th;
if (bufferedReader2 != null) {
try {
bufferedReader2.close();
} catch (IOException e6) {
FS.log_e(TAG, e6.getMessage(), e6);
}
}
throw th;
}
} catch (Throwable th2) {
th = th2;
bufferedReader2 = exists;
}
}
public void put(String str, JSONObject jSONObject) {
put(str, jSONObject.toString());
}
public void put(String str, JSONObject jSONObject, int i) {
put(str, jSONObject.toString(), i);
}
public JSONObject getAsJSONObject(String str) {
try {
return new JSONObject(getAsString(str));
} catch (Exception e) {
FS.log_e(TAG, e.getMessage(), e);
return null;
}
}
public void put(String str, JSONArray jSONArray) {
put(str, jSONArray.toString());
}
public void put(String str, JSONArray jSONArray, int i) {
put(str, jSONArray.toString(), i);
}
public JSONArray getAsJSONArray(String str) {
try {
return new JSONArray(getAsString(str));
} catch (Exception e) {
FS.log_e(TAG, e.getMessage(), e);
return null;
}
}
public void put(String str, byte[] bArr) {
FileOutputStream fileOutputStream;
File newFile = this.mCache.newFile(str);
FileOutputStream fileOutputStream2 = null;
try {
try {
fileOutputStream = new FileOutputStream(newFile);
} catch (Exception e) {
e = e;
}
} catch (Throwable th) {
th = th;
}
try {
fileOutputStream.write(bArr);
try {
fileOutputStream.flush();
fileOutputStream.close();
} catch (IOException e2) {
e = e2;
FS.log_e(TAG, e.getMessage(), e);
this.mCache.put(newFile);
}
} catch (Exception e3) {
e = e3;
fileOutputStream2 = fileOutputStream;
FS.log_e(TAG, e.getMessage(), e);
if (fileOutputStream2 != null) {
try {
fileOutputStream2.flush();
fileOutputStream2.close();
} catch (IOException e4) {
e = e4;
FS.log_e(TAG, e.getMessage(), e);
this.mCache.put(newFile);
}
}
this.mCache.put(newFile);
} catch (Throwable th2) {
th = th2;
fileOutputStream2 = fileOutputStream;
if (fileOutputStream2 != null) {
try {
fileOutputStream2.flush();
fileOutputStream2.close();
} catch (IOException e5) {
FS.log_e(TAG, e5.getMessage(), e5);
}
}
this.mCache.put(newFile);
throw th;
}
this.mCache.put(newFile);
}
public OutputStream put(String str) throws FileNotFoundException {
return new XFileOutputStream(this.mCache.newFile(str));
}
public InputStream get(String str) throws FileNotFoundException {
File file = this.mCache.get(str);
if (file.exists()) {
return new FileInputStream(file);
}
return null;
}
public void put(String str, byte[] bArr, int i) {
put(str, Utils.newByteArrayWithDateInfo(i, bArr));
}
public byte[] getAsBinary(java.lang.String r6) {
throw new UnsupportedOperationException("Method not decompiled: com.oriente.locklibrary.utils.LockCache.getAsBinary(java.lang.String):byte[]");
}
public void put(String str, Serializable serializable) {
put(str, serializable, -1);
}
public void put(String str, Serializable serializable, int i) {
ByteArrayOutputStream byteArrayOutputStream;
ObjectOutputStream objectOutputStream;
?? r0 = 0;
ObjectOutputStream objectOutputStream2 = null;
try {
try {
try {
byteArrayOutputStream = new ByteArrayOutputStream();
objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
} catch (IOException unused) {
return;
}
} catch (Exception e) {
e = e;
}
} catch (Throwable th) {
th = th;
}
try {
objectOutputStream.writeObject(serializable);
byte[] byteArray = byteArrayOutputStream.toByteArray();
r0 = -1;
if (i != -1) {
put(str, byteArray, i);
} else {
put(str, byteArray);
}
objectOutputStream.close();
} catch (Exception e2) {
e = e2;
objectOutputStream2 = objectOutputStream;
FS.log_e(TAG, e.getMessage(), e);
objectOutputStream2.close();
r0 = objectOutputStream2;
} catch (Throwable th2) {
th = th2;
r0 = objectOutputStream;
try {
r0.close();
} catch (IOException unused2) {
}
throw th;
}
}
public Object getAsObject(String str) {
ByteArrayInputStream byteArrayInputStream;
ObjectInputStream objectInputStream;
?? asBinary = getAsBinary(str);
try {
if (asBinary == 0) {
return null;
}
try {
byteArrayInputStream = new ByteArrayInputStream(asBinary);
try {
objectInputStream = new ObjectInputStream(byteArrayInputStream);
try {
Object readObject = objectInputStream.readObject();
try {
byteArrayInputStream.close();
} catch (IOException e) {
FS.log_e(TAG, e.getMessage(), e);
}
try {
objectInputStream.close();
} catch (IOException e2) {
FS.log_e(TAG, e2.getMessage(), e2);
}
return readObject;
} catch (Exception e3) {
e = e3;
FS.log_e(TAG, e.getMessage(), e);
if (byteArrayInputStream != null) {
try {
byteArrayInputStream.close();
} catch (IOException e4) {
FS.log_e(TAG, e4.getMessage(), e4);
}
}
if (objectInputStream != null) {
try {
objectInputStream.close();
} catch (IOException e5) {
FS.log_e(TAG, e5.getMessage(), e5);
}
}
return null;
}
} catch (Exception e6) {
e = e6;
objectInputStream = null;
} catch (Throwable th) {
th = th;
asBinary = 0;
if (byteArrayInputStream != null) {
try {
byteArrayInputStream.close();
} catch (IOException e7) {
FS.log_e(TAG, e7.getMessage(), e7);
}
}
if (asBinary != 0) {
try {
asBinary.close();
throw th;
} catch (IOException e8) {
FS.log_e(TAG, e8.getMessage(), e8);
throw th;
}
}
throw th;
}
} catch (Exception e9) {
e = e9;
objectInputStream = null;
byteArrayInputStream = null;
} catch (Throwable th2) {
byteArrayInputStream = null;
th = th2;
asBinary = 0;
}
} catch (Throwable th3) {
th = th3;
}
}
public void put(String str, Bitmap bitmap) {
put(str, Utils.bitmap2Bytes(bitmap));
}
public void put(String str, Bitmap bitmap, int i) {
put(str, Utils.bitmap2Bytes(bitmap), i);
}
public Bitmap getAsBitmap(String str) {
if (getAsBinary(str) == null) {
return null;
}
return Utils.bytes2Bimap(getAsBinary(str));
}
public void put(String str, Drawable drawable) {
put(str, Utils.drawable2Bitmap(drawable));
}
public void put(String str, Drawable drawable, int i) {
put(str, Utils.drawable2Bitmap(drawable), i);
}
public Drawable getAsDrawable(String str) {
if (getAsBinary(str) == null) {
return null;
}
return Utils.bitmap2Drawable(Utils.bytes2Bimap(getAsBinary(str)));
}
public File file(String str) {
File newFile = this.mCache.newFile(str);
if (newFile.exists()) {
return newFile;
}
return null;
}
public boolean remove(String str) {
return this.mCache.remove(str);
}
public void clear() {
this.mCache.clear();
}
public class LockCacheManager {
private final AtomicInteger cacheCount;
protected File cacheDir;
private final AtomicLong cacheSize;
private final int countLimit;
private final Map<File, Long> lastUsageDates;
private final long sizeLimit;
private LockCacheManager(File file, long j, int i) {
this.lastUsageDates = Collections.synchronizedMap(new HashMap());
this.cacheDir = file;
this.sizeLimit = j;
this.countLimit = i;
this.cacheSize = new AtomicLong();
this.cacheCount = new AtomicInteger();
calculateCacheSizeAndCacheCount();
}
private void calculateCacheSizeAndCacheCount() {
new Thread(new Runnable() {
@Override
public void run() {
File[] listFiles = LockCacheManager.this.cacheDir.listFiles();
if (listFiles != null) {
int i = 0;
int i2 = 0;
for (File file : listFiles) {
i = (int) (i + LockCacheManager.this.calculateSize(file));
i2++;
LockCacheManager.this.lastUsageDates.put(file, Long.valueOf(file.lastModified()));
}
LockCacheManager.this.cacheSize.set(i);
LockCacheManager.this.cacheCount.set(i2);
}
}
}).start();
}
public void put(File file) {
int i = this.cacheCount.get();
while (i + 1 > this.countLimit) {
this.cacheSize.addAndGet(-removeNext());
i = this.cacheCount.addAndGet(-1);
}
this.cacheCount.addAndGet(1);
long calculateSize = calculateSize(file);
long j = this.cacheSize.get();
while (j + calculateSize > this.sizeLimit) {
j = this.cacheSize.addAndGet(-removeNext());
}
this.cacheSize.addAndGet(calculateSize);
long currentTimeMillis = System.currentTimeMillis();
Long valueOf = Long.valueOf(currentTimeMillis);
valueOf.getClass();
file.setLastModified(currentTimeMillis);
this.lastUsageDates.put(file, valueOf);
}
public File get(String str) {
File newFile = newFile(str);
long currentTimeMillis = System.currentTimeMillis();
Long valueOf = Long.valueOf(currentTimeMillis);
valueOf.getClass();
newFile.setLastModified(currentTimeMillis);
this.lastUsageDates.put(newFile, valueOf);
return newFile;
}
public File newFile(String str) {
return new File(this.cacheDir, str.hashCode() + "");
}
public boolean remove(String str) {
return get(str).delete();
}
public void clear() {
this.lastUsageDates.clear();
this.cacheSize.set(0L);
File[] listFiles = this.cacheDir.listFiles();
if (listFiles != null) {
for (File file : listFiles) {
file.delete();
}
}
}
private long removeNext() {
File file;
if (this.lastUsageDates.isEmpty()) {
return 0L;
}
Set<Map.Entry<File, Long>> entrySet = this.lastUsageDates.entrySet();
synchronized (this.lastUsageDates) {
file = null;
Long l = null;
for (Map.Entry<File, Long> entry : entrySet) {
if (file == null) {
file = entry.getKey();
l = entry.getValue();
} else {
Long value = entry.getValue();
if (value.longValue() < l.longValue()) {
file = entry.getKey();
l = value;
}
}
}
}
long calculateSize = calculateSize(file);
if (file.delete()) {
this.lastUsageDates.remove(file);
}
return calculateSize;
}
public long calculateSize(File file) {
return file.length();
}
}
private static class Utils {
private static final char mSeparator = ' ';
private Utils() {
}
public static boolean isDue(String str) {
return isDue(str.getBytes(Charset.forName("UTF-8")));
}
public static boolean isDue(byte[] bArr) {
String[] dateInfoFromDate = getDateInfoFromDate(bArr);
if (dateInfoFromDate != null && dateInfoFromDate.length == 2) {
String str = dateInfoFromDate[0];
while (str.startsWith(AppEventsConstants.EVENT_PARAM_VALUE_NO)) {
str = str.substring(1, str.length());
}
if (System.currentTimeMillis() > Long.parseLong(str) + (Long.parseLong(dateInfoFromDate[1]) * 1000)) {
return true;
}
}
return false;
}
public static String newStringWithDateInfo(int i, String str) {
return createDateInfo(i) + str;
}
public static byte[] newByteArrayWithDateInfo(int i, byte[] bArr) {
byte[] bytes = createDateInfo(i).getBytes(Charset.forName("UTF-8"));
byte[] bArr2 = new byte[bytes.length + bArr.length];
System.arraycopy(bytes, 0, bArr2, 0, bytes.length);
System.arraycopy(bArr, 0, bArr2, bytes.length, bArr.length);
return bArr2;
}
public static String clearDateInfo(String str) {
return (str == null || !hasDateInfo(str.getBytes(Charset.forName("UTF-8")))) ? str : str.substring(str.indexOf(32) + 1, str.length());
}
public static byte[] clearDateInfo(byte[] bArr) {
return hasDateInfo(bArr) ? copyOfRange(bArr, indexOf(bArr, mSeparator) + 1, bArr.length) : bArr;
}
private static boolean hasDateInfo(byte[] bArr) {
return bArr != null && bArr.length > 15 && bArr[13] == 45 && indexOf(bArr, mSeparator) > 14;
}
private static String[] getDateInfoFromDate(byte[] bArr) {
if (hasDateInfo(bArr)) {
return new String[]{new String(copyOfRange(bArr, 0, 13), Charset.forName("UTF-8")), new String(copyOfRange(bArr, 14, indexOf(bArr, mSeparator)), Charset.forName("UTF-8"))};
}
return null;
}
private static int indexOf(byte[] bArr, char c) {
for (int i = 0; i < bArr.length; i++) {
if (bArr[i] == c) {
return i;
}
}
return -1;
}
private static byte[] copyOfRange(byte[] bArr, int i, int i2) {
int i3 = i2 - i;
if (i3 < 0) {
throw new IllegalArgumentException(i + " > " + i2);
}
byte[] bArr2 = new byte[i3];
System.arraycopy(bArr, i, bArr2, 0, Math.min(bArr.length - i, i3));
return bArr2;
}
private static String createDateInfo(int i) {
String str = System.currentTimeMillis() + "";
while (str.length() < 13) {
str = AppEventsConstants.EVENT_PARAM_VALUE_NO + str;
}
return str + "-" + i + mSeparator;
}
public static byte[] bitmap2Bytes(Bitmap bitmap) {
if (bitmap == null) {
return null;
}
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream);
return byteArrayOutputStream.toByteArray();
}
public static Bitmap bytes2Bimap(byte[] bArr) {
if (bArr.length == 0) {
return null;
}
return BitmapFactory.decodeByteArray(bArr, 0, bArr.length);
}
public static Bitmap drawable2Bitmap(Drawable drawable) {
if (drawable == null) {
return null;
}
int intrinsicWidth = drawable.getIntrinsicWidth();
int intrinsicHeight = drawable.getIntrinsicHeight();
Bitmap createBitmap = Bitmap.createBitmap(intrinsicWidth, intrinsicHeight, drawable.getOpacity() != -1 ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565);
Canvas canvas = new Canvas(createBitmap);
drawable.setBounds(0, 0, intrinsicWidth, intrinsicHeight);
drawable.draw(canvas);
return createBitmap;
}
public static Drawable bitmap2Drawable(Bitmap bitmap) {
if (bitmap == null) {
return null;
}
new BitmapDrawable(bitmap).setTargetDensity(bitmap.getDensity());
return new BitmapDrawable(bitmap);
}
}
}