mirror of https://github.com/TeamNewPipe/NewPipe
121 lines
3.8 KiB
Java
121 lines
3.8 KiB
Java
package org.schabi.newpipe.util;
|
|
|
|
import android.util.Log;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.collection.LruCache;
|
|
|
|
import org.schabi.newpipe.MainActivity;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.Serializable;
|
|
import java.util.UUID;
|
|
|
|
public final class SerializedCache {
|
|
private static final boolean DEBUG = MainActivity.DEBUG;
|
|
private static final SerializedCache INSTANCE = new SerializedCache();
|
|
private static final int MAX_ITEMS_ON_CACHE = 5;
|
|
private static final LruCache<String, CacheData> LRU_CACHE =
|
|
new LruCache<>(MAX_ITEMS_ON_CACHE);
|
|
private static final String TAG = "SerializedCache";
|
|
|
|
private SerializedCache() {
|
|
//no instance
|
|
}
|
|
|
|
public static SerializedCache getInstance() {
|
|
return INSTANCE;
|
|
}
|
|
|
|
@Nullable
|
|
public <T> T take(@NonNull final String key, @NonNull final Class<T> type) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "take() called with: key = [" + key + "]");
|
|
}
|
|
synchronized (LRU_CACHE) {
|
|
return LRU_CACHE.get(key) != null ? getItem(LRU_CACHE.remove(key), type) : null;
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public <T> T get(@NonNull final String key, @NonNull final Class<T> type) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "get() called with: key = [" + key + "]");
|
|
}
|
|
synchronized (LRU_CACHE) {
|
|
final CacheData data = LRU_CACHE.get(key);
|
|
return data != null ? getItem(data, type) : null;
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public <T extends Serializable> String put(@NonNull final T item,
|
|
@NonNull final Class<T> type) {
|
|
final String key = UUID.randomUUID().toString();
|
|
return put(key, item, type) ? key : null;
|
|
}
|
|
|
|
public <T extends Serializable> boolean put(@NonNull final String key, @NonNull final T item,
|
|
@NonNull final Class<T> type) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "put() called with: key = [" + key + "], item = [" + item + "]");
|
|
}
|
|
synchronized (LRU_CACHE) {
|
|
try {
|
|
LRU_CACHE.put(key, new CacheData<>(clone(item, type), type));
|
|
return true;
|
|
} catch (final Exception error) {
|
|
Log.e(TAG, "Serialization failed for: ", error);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void clear() {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "clear() called");
|
|
}
|
|
synchronized (LRU_CACHE) {
|
|
LRU_CACHE.evictAll();
|
|
}
|
|
}
|
|
|
|
public long size() {
|
|
synchronized (LRU_CACHE) {
|
|
return LRU_CACHE.size();
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
private <T> T getItem(@NonNull final CacheData data, @NonNull final Class<T> type) {
|
|
return type.isAssignableFrom(data.type) ? type.cast(data.item) : null;
|
|
}
|
|
|
|
@NonNull
|
|
private <T extends Serializable> T clone(@NonNull final T item,
|
|
@NonNull final Class<T> type) throws Exception {
|
|
final ByteArrayOutputStream bytesOutput = new ByteArrayOutputStream();
|
|
try (ObjectOutputStream objectOutput = new ObjectOutputStream(bytesOutput)) {
|
|
objectOutput.writeObject(item);
|
|
objectOutput.flush();
|
|
}
|
|
final Object clone = new ObjectInputStream(
|
|
new ByteArrayInputStream(bytesOutput.toByteArray())).readObject();
|
|
return type.cast(clone);
|
|
}
|
|
|
|
private static final class CacheData<T> {
|
|
private final T item;
|
|
private final Class<T> type;
|
|
|
|
private CacheData(@NonNull final T item, @NonNull final Class<T> type) {
|
|
this.item = item;
|
|
this.type = type;
|
|
}
|
|
}
|
|
}
|