676 lines
26 KiB
Java
676 lines
26 KiB
Java
package c.i.a.c.h2.y;
|
|
|
|
import android.content.ContentValues;
|
|
import android.database.Cursor;
|
|
import android.database.SQLException;
|
|
import android.database.sqlite.SQLiteDatabase;
|
|
import android.database.sqlite.SQLiteException;
|
|
import android.util.SparseArray;
|
|
import android.util.SparseBooleanArray;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.WorkerThread;
|
|
import c.i.a.c.i2.f;
|
|
import c.i.a.c.i2.f0;
|
|
import c.i.a.c.i2.y;
|
|
import com.airbnb.lottie.parser.AnimatableValueParser;
|
|
import com.google.android.exoplayer2.database.DatabaseIOException;
|
|
import java.io.BufferedInputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.DataInputStream;
|
|
import java.io.DataOutputStream;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.security.InvalidAlgorithmParameterException;
|
|
import java.security.InvalidKeyException;
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.security.SecureRandom;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
import javax.crypto.Cipher;
|
|
import javax.crypto.CipherInputStream;
|
|
import javax.crypto.CipherOutputStream;
|
|
import javax.crypto.NoSuchPaddingException;
|
|
import javax.crypto.spec.IvParameterSpec;
|
|
import javax.crypto.spec.SecretKeySpec;
|
|
/* compiled from: CachedContentIndex */
|
|
public class j {
|
|
public final HashMap<String, i> a;
|
|
public final SparseArray<String> b;
|
|
|
|
/* renamed from: c reason: collision with root package name */
|
|
public final SparseBooleanArray f897c;
|
|
public final SparseBooleanArray d;
|
|
public c e;
|
|
@Nullable
|
|
public c f;
|
|
|
|
/* compiled from: CachedContentIndex */
|
|
public static final class a implements c {
|
|
public static final String[] a = {"id", "key", "metadata"};
|
|
public final c.i.a.c.w1.a b;
|
|
|
|
/* renamed from: c reason: collision with root package name */
|
|
public final SparseArray<i> f898c = new SparseArray<>();
|
|
public String d;
|
|
public String e;
|
|
|
|
public a(c.i.a.c.w1.a aVar) {
|
|
this.b = aVar;
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void a(i iVar, boolean z2) {
|
|
if (z2) {
|
|
this.f898c.delete(iVar.a);
|
|
} else {
|
|
this.f898c.put(iVar.a, null);
|
|
}
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void b(HashMap<String, i> hashMap) throws IOException {
|
|
try {
|
|
SQLiteDatabase writableDatabase = this.b.getWritableDatabase();
|
|
writableDatabase.beginTransactionNonExclusive();
|
|
try {
|
|
j(writableDatabase);
|
|
for (i iVar : hashMap.values()) {
|
|
i(writableDatabase, iVar);
|
|
}
|
|
writableDatabase.setTransactionSuccessful();
|
|
this.f898c.clear();
|
|
} finally {
|
|
writableDatabase.endTransaction();
|
|
}
|
|
} catch (SQLException e) {
|
|
throw new DatabaseIOException(e);
|
|
}
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void c(i iVar) {
|
|
this.f898c.put(iVar.a, iVar);
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public boolean d() throws DatabaseIOException {
|
|
SQLiteDatabase readableDatabase = this.b.getReadableDatabase();
|
|
String str = this.d;
|
|
Objects.requireNonNull(str);
|
|
return AnimatableValueParser.Q0(readableDatabase, 1, str) != -1;
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void e(HashMap<String, i> hashMap) throws IOException {
|
|
if (this.f898c.size() != 0) {
|
|
try {
|
|
SQLiteDatabase writableDatabase = this.b.getWritableDatabase();
|
|
writableDatabase.beginTransactionNonExclusive();
|
|
for (int i = 0; i < this.f898c.size(); i++) {
|
|
try {
|
|
i valueAt = this.f898c.valueAt(i);
|
|
if (valueAt == null) {
|
|
int keyAt = this.f898c.keyAt(i);
|
|
String str = this.e;
|
|
Objects.requireNonNull(str);
|
|
writableDatabase.delete(str, "id = ?", new String[]{Integer.toString(keyAt)});
|
|
} else {
|
|
i(writableDatabase, valueAt);
|
|
}
|
|
} finally {
|
|
writableDatabase.endTransaction();
|
|
}
|
|
}
|
|
writableDatabase.setTransactionSuccessful();
|
|
this.f898c.clear();
|
|
writableDatabase.endTransaction();
|
|
} catch (SQLException e) {
|
|
throw new DatabaseIOException(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void f(long j) {
|
|
String hexString = Long.toHexString(j);
|
|
this.d = hexString;
|
|
this.e = c.d.b.a.a.s("ExoPlayerCacheIndex", hexString);
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:25:0x0082, code lost:
|
|
r2 = move-exception;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:26:0x0083, code lost:
|
|
if (r0 != null) goto L_0x0085;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:28:?, code lost:
|
|
r0.close();
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:29:0x0089, code lost:
|
|
r0 = move-exception;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:30:0x008a, code lost:
|
|
r1.addSuppressed(r0);
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:31:0x008d, code lost:
|
|
throw r2;
|
|
*/
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void g(HashMap<String, i> hashMap, SparseArray<String> sparseArray) throws IOException {
|
|
AnimatableValueParser.D(this.f898c.size() == 0);
|
|
try {
|
|
SQLiteDatabase readableDatabase = this.b.getReadableDatabase();
|
|
String str = this.d;
|
|
Objects.requireNonNull(str);
|
|
if (AnimatableValueParser.Q0(readableDatabase, 1, str) != 1) {
|
|
SQLiteDatabase writableDatabase = this.b.getWritableDatabase();
|
|
writableDatabase.beginTransactionNonExclusive();
|
|
try {
|
|
j(writableDatabase);
|
|
writableDatabase.setTransactionSuccessful();
|
|
} finally {
|
|
writableDatabase.endTransaction();
|
|
}
|
|
}
|
|
SQLiteDatabase readableDatabase2 = this.b.getReadableDatabase();
|
|
String str2 = this.e;
|
|
Objects.requireNonNull(str2);
|
|
Cursor query = readableDatabase2.query(str2, a, null, null, null, null, null);
|
|
while (query.moveToNext()) {
|
|
int i = query.getInt(0);
|
|
String string = query.getString(1);
|
|
hashMap.put(string, new i(i, string, j.a(new DataInputStream(new ByteArrayInputStream(query.getBlob(2))))));
|
|
sparseArray.put(i, string);
|
|
}
|
|
query.close();
|
|
} catch (SQLiteException e) {
|
|
hashMap.clear();
|
|
sparseArray.clear();
|
|
throw new DatabaseIOException(e);
|
|
}
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void h() throws DatabaseIOException {
|
|
c.i.a.c.w1.a aVar = this.b;
|
|
String str = this.d;
|
|
Objects.requireNonNull(str);
|
|
try {
|
|
String str2 = "ExoPlayerCacheIndex" + str;
|
|
SQLiteDatabase writableDatabase = aVar.getWritableDatabase();
|
|
writableDatabase.beginTransactionNonExclusive();
|
|
try {
|
|
if (f0.I(writableDatabase, "ExoPlayerVersions")) {
|
|
writableDatabase.delete("ExoPlayerVersions", "feature = ? AND instance_uid = ?", new String[]{Integer.toString(1), str});
|
|
}
|
|
writableDatabase.execSQL("DROP TABLE IF EXISTS " + str2);
|
|
writableDatabase.setTransactionSuccessful();
|
|
writableDatabase.endTransaction();
|
|
} catch (SQLException e) {
|
|
throw new DatabaseIOException(e);
|
|
}
|
|
} catch (SQLException e2) {
|
|
throw new DatabaseIOException(e2);
|
|
}
|
|
}
|
|
|
|
public final void i(SQLiteDatabase sQLiteDatabase, i iVar) throws IOException {
|
|
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
|
|
j.b(iVar.e, new DataOutputStream(byteArrayOutputStream));
|
|
byte[] byteArray = byteArrayOutputStream.toByteArray();
|
|
ContentValues contentValues = new ContentValues();
|
|
contentValues.put("id", Integer.valueOf(iVar.a));
|
|
contentValues.put("key", iVar.b);
|
|
contentValues.put("metadata", byteArray);
|
|
String str = this.e;
|
|
Objects.requireNonNull(str);
|
|
sQLiteDatabase.replaceOrThrow(str, null, contentValues);
|
|
}
|
|
|
|
public final void j(SQLiteDatabase sQLiteDatabase) throws DatabaseIOException {
|
|
String str = this.d;
|
|
Objects.requireNonNull(str);
|
|
AnimatableValueParser.A2(sQLiteDatabase, 1, str, 1);
|
|
String str2 = this.e;
|
|
Objects.requireNonNull(str2);
|
|
sQLiteDatabase.execSQL("DROP TABLE IF EXISTS " + str2);
|
|
sQLiteDatabase.execSQL("CREATE TABLE " + this.e + " (id INTEGER PRIMARY KEY NOT NULL,key TEXT NOT NULL,metadata BLOB NOT NULL)");
|
|
}
|
|
}
|
|
|
|
/* compiled from: CachedContentIndex */
|
|
public static class b implements c {
|
|
public final boolean a;
|
|
@Nullable
|
|
public final Cipher b;
|
|
@Nullable
|
|
|
|
/* renamed from: c reason: collision with root package name */
|
|
public final SecretKeySpec f899c;
|
|
@Nullable
|
|
public final SecureRandom d;
|
|
public final f e;
|
|
public boolean f;
|
|
@Nullable
|
|
public y g;
|
|
|
|
public b(File file, @Nullable byte[] bArr, boolean z2) {
|
|
SecretKeySpec secretKeySpec;
|
|
Cipher cipher;
|
|
boolean z3 = false;
|
|
AnimatableValueParser.D(bArr != null || !z2);
|
|
SecureRandom secureRandom = null;
|
|
if (bArr != null) {
|
|
AnimatableValueParser.k(bArr.length == 16 ? true : z3);
|
|
try {
|
|
if (f0.a == 18) {
|
|
try {
|
|
cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING", "BC");
|
|
} catch (Throwable unused) {
|
|
}
|
|
secretKeySpec = new SecretKeySpec(bArr, "AES");
|
|
}
|
|
cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
|
|
secretKeySpec = new SecretKeySpec(bArr, "AES");
|
|
} catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
|
|
throw new IllegalStateException(e);
|
|
}
|
|
} else {
|
|
AnimatableValueParser.k(!z2);
|
|
cipher = null;
|
|
secretKeySpec = null;
|
|
}
|
|
this.a = z2;
|
|
this.b = cipher;
|
|
this.f899c = secretKeySpec;
|
|
this.d = z2 ? new SecureRandom() : secureRandom;
|
|
this.e = new f(file);
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void a(i iVar, boolean z2) {
|
|
this.f = true;
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:33:0x00b3 A[SYNTHETIC, Splitter:B:33:0x00b3] */
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void b(HashMap<String, i> hashMap) throws IOException {
|
|
Throwable th;
|
|
DataOutputStream dataOutputStream = null;
|
|
try {
|
|
OutputStream c2 = this.e.c();
|
|
y yVar = this.g;
|
|
if (yVar == null) {
|
|
this.g = new y(c2);
|
|
} else {
|
|
yVar.a(c2);
|
|
}
|
|
y yVar2 = this.g;
|
|
DataOutputStream dataOutputStream2 = new DataOutputStream(yVar2);
|
|
try {
|
|
dataOutputStream2.writeInt(2);
|
|
dataOutputStream2.writeInt(this.a ? 1 : 0);
|
|
if (this.a) {
|
|
byte[] bArr = new byte[16];
|
|
SecureRandom secureRandom = this.d;
|
|
int i = f0.a;
|
|
secureRandom.nextBytes(bArr);
|
|
dataOutputStream2.write(bArr);
|
|
try {
|
|
this.b.init(1, this.f899c, new IvParameterSpec(bArr));
|
|
dataOutputStream2.flush();
|
|
dataOutputStream2 = new DataOutputStream(new CipherOutputStream(yVar2, this.b));
|
|
} catch (InvalidAlgorithmParameterException | InvalidKeyException e) {
|
|
throw new IllegalStateException(e);
|
|
}
|
|
}
|
|
dataOutputStream2.writeInt(hashMap.size());
|
|
int i2 = 0;
|
|
for (i iVar : hashMap.values()) {
|
|
dataOutputStream2.writeInt(iVar.a);
|
|
dataOutputStream2.writeUTF(iVar.b);
|
|
j.b(iVar.e, dataOutputStream2);
|
|
i2 += i(iVar, 2);
|
|
}
|
|
dataOutputStream2.writeInt(i2);
|
|
f fVar = this.e;
|
|
Objects.requireNonNull(fVar);
|
|
dataOutputStream2.close();
|
|
fVar.b.delete();
|
|
int i3 = f0.a;
|
|
this.f = false;
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
dataOutputStream = dataOutputStream2;
|
|
int i4 = f0.a;
|
|
if (dataOutputStream != null) {
|
|
try {
|
|
dataOutputStream.close();
|
|
} catch (IOException unused) {
|
|
}
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
int i4 = f0.a;
|
|
if (dataOutputStream != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void c(i iVar) {
|
|
this.f = true;
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public boolean d() {
|
|
return this.e.a();
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void e(HashMap<String, i> hashMap) throws IOException {
|
|
if (this.f) {
|
|
b(hashMap);
|
|
}
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void f(long j) {
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:48:0x00b6 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:55:0x00bf */
|
|
/* JADX WARNING: Removed duplicated region for block: B:59:0x00c7 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:62:? A[RETURN, SYNTHETIC] */
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void g(HashMap<String, i> hashMap, SparseArray<String> sparseArray) {
|
|
Throwable th;
|
|
boolean z2 = true;
|
|
AnimatableValueParser.D(!this.f);
|
|
if (this.e.a()) {
|
|
DataInputStream dataInputStream = null;
|
|
try {
|
|
BufferedInputStream bufferedInputStream = new BufferedInputStream(this.e.b());
|
|
DataInputStream dataInputStream2 = new DataInputStream(bufferedInputStream);
|
|
try {
|
|
int readInt = dataInputStream2.readInt();
|
|
if (readInt >= 0) {
|
|
if (readInt <= 2) {
|
|
if ((dataInputStream2.readInt() & 1) != 0) {
|
|
if (this.b != null) {
|
|
byte[] bArr = new byte[16];
|
|
dataInputStream2.readFully(bArr);
|
|
IvParameterSpec ivParameterSpec = new IvParameterSpec(bArr);
|
|
try {
|
|
Cipher cipher = this.b;
|
|
SecretKeySpec secretKeySpec = this.f899c;
|
|
int i = f0.a;
|
|
cipher.init(2, secretKeySpec, ivParameterSpec);
|
|
dataInputStream2 = new DataInputStream(new CipherInputStream(bufferedInputStream, this.b));
|
|
} catch (InvalidAlgorithmParameterException | InvalidKeyException e) {
|
|
throw new IllegalStateException(e);
|
|
}
|
|
}
|
|
} else if (this.a) {
|
|
this.f = true;
|
|
}
|
|
int readInt2 = dataInputStream2.readInt();
|
|
int i2 = 0;
|
|
for (int i3 = 0; i3 < readInt2; i3++) {
|
|
i j = j(readInt, dataInputStream2);
|
|
hashMap.put(j.b, j);
|
|
sparseArray.put(j.a, j.b);
|
|
i2 += i(j, readInt);
|
|
}
|
|
int readInt3 = dataInputStream2.readInt();
|
|
boolean z3 = dataInputStream2.read() == -1;
|
|
if (readInt3 == i2 && z3) {
|
|
int i4 = f0.a;
|
|
try {
|
|
dataInputStream2.close();
|
|
} catch (IOException unused) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int i5 = f0.a;
|
|
try {
|
|
dataInputStream2.close();
|
|
} catch (IOException unused2) {
|
|
}
|
|
} catch (IOException unused3) {
|
|
dataInputStream = dataInputStream2;
|
|
if (dataInputStream != null) {
|
|
}
|
|
z2 = false;
|
|
if (!z2) {
|
|
}
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
dataInputStream = dataInputStream2;
|
|
if (dataInputStream != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (IOException unused4) {
|
|
if (dataInputStream != null) {
|
|
int i6 = f0.a;
|
|
dataInputStream.close();
|
|
}
|
|
z2 = false;
|
|
if (!z2) {
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
if (dataInputStream != null) {
|
|
int i7 = f0.a;
|
|
try {
|
|
dataInputStream.close();
|
|
} catch (IOException unused5) {
|
|
}
|
|
}
|
|
throw th;
|
|
}
|
|
z2 = false;
|
|
}
|
|
if (!z2) {
|
|
hashMap.clear();
|
|
sparseArray.clear();
|
|
f fVar = this.e;
|
|
fVar.a.delete();
|
|
fVar.b.delete();
|
|
}
|
|
}
|
|
|
|
@Override // c.i.a.c.h2.y.j.c
|
|
public void h() {
|
|
f fVar = this.e;
|
|
fVar.a.delete();
|
|
fVar.b.delete();
|
|
}
|
|
|
|
public final int i(i iVar, int i) {
|
|
int hashCode = iVar.b.hashCode() + (iVar.a * 31);
|
|
if (i >= 2) {
|
|
return (hashCode * 31) + iVar.e.hashCode();
|
|
}
|
|
long a = k.a(iVar.e);
|
|
return (hashCode * 31) + ((int) (a ^ (a >>> 32)));
|
|
}
|
|
|
|
public final i j(int i, DataInputStream dataInputStream) throws IOException {
|
|
n nVar;
|
|
int readInt = dataInputStream.readInt();
|
|
String readUTF = dataInputStream.readUTF();
|
|
if (i < 2) {
|
|
long readLong = dataInputStream.readLong();
|
|
m mVar = new m();
|
|
m.a(mVar, readLong);
|
|
nVar = n.a.a(mVar);
|
|
} else {
|
|
nVar = j.a(dataInputStream);
|
|
}
|
|
return new i(readInt, readUTF, nVar);
|
|
}
|
|
}
|
|
|
|
/* compiled from: CachedContentIndex */
|
|
public interface c {
|
|
void a(i iVar, boolean z2);
|
|
|
|
void b(HashMap<String, i> hashMap) throws IOException;
|
|
|
|
void c(i iVar);
|
|
|
|
boolean d() throws IOException;
|
|
|
|
void e(HashMap<String, i> hashMap) throws IOException;
|
|
|
|
void f(long j);
|
|
|
|
void g(HashMap<String, i> hashMap, SparseArray<String> sparseArray) throws IOException;
|
|
|
|
void h() throws IOException;
|
|
}
|
|
|
|
public j(@Nullable c.i.a.c.w1.a aVar, @Nullable File file, @Nullable byte[] bArr, boolean z2, boolean z3) {
|
|
AnimatableValueParser.D((aVar == null && file == null) ? false : true);
|
|
this.a = new HashMap<>();
|
|
this.b = new SparseArray<>();
|
|
this.f897c = new SparseBooleanArray();
|
|
this.d = new SparseBooleanArray();
|
|
b bVar = null;
|
|
a aVar2 = aVar != null ? new a(aVar) : null;
|
|
bVar = file != null ? new b(new File(file, "cached_content_index.exi"), bArr, z2) : bVar;
|
|
if (aVar2 == null || (bVar != null && z3)) {
|
|
int i = f0.a;
|
|
this.e = bVar;
|
|
this.f = aVar2;
|
|
return;
|
|
}
|
|
this.e = aVar2;
|
|
this.f = bVar;
|
|
}
|
|
|
|
public static n a(DataInputStream dataInputStream) throws IOException {
|
|
int readInt = dataInputStream.readInt();
|
|
HashMap hashMap = new HashMap();
|
|
for (int i = 0; i < readInt; i++) {
|
|
String readUTF = dataInputStream.readUTF();
|
|
int readInt2 = dataInputStream.readInt();
|
|
if (readInt2 >= 0) {
|
|
int min = Math.min(readInt2, 10485760);
|
|
byte[] bArr = f0.f;
|
|
int i2 = 0;
|
|
while (i2 != readInt2) {
|
|
int i3 = i2 + min;
|
|
bArr = Arrays.copyOf(bArr, i3);
|
|
dataInputStream.readFully(bArr, i2, min);
|
|
min = Math.min(readInt2 - i3, 10485760);
|
|
i2 = i3;
|
|
}
|
|
hashMap.put(readUTF, bArr);
|
|
} else {
|
|
throw new IOException(c.d.b.a.a.j("Invalid value size: ", readInt2));
|
|
}
|
|
}
|
|
return new n(hashMap);
|
|
}
|
|
|
|
public static void b(n nVar, DataOutputStream dataOutputStream) throws IOException {
|
|
Set<Map.Entry<String, byte[]>> entrySet = nVar.f900c.entrySet();
|
|
dataOutputStream.writeInt(entrySet.size());
|
|
for (Map.Entry<String, byte[]> entry : entrySet) {
|
|
dataOutputStream.writeUTF(entry.getKey());
|
|
byte[] value = entry.getValue();
|
|
dataOutputStream.writeInt(value.length);
|
|
dataOutputStream.write(value);
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public i c(String str) {
|
|
return this.a.get(str);
|
|
}
|
|
|
|
public i d(String str) {
|
|
i iVar = this.a.get(str);
|
|
if (iVar != null) {
|
|
return iVar;
|
|
}
|
|
SparseArray<String> sparseArray = this.b;
|
|
int size = sparseArray.size();
|
|
int i = 0;
|
|
int keyAt = size == 0 ? 0 : sparseArray.keyAt(size - 1) + 1;
|
|
if (keyAt < 0) {
|
|
while (i < size && i == sparseArray.keyAt(i)) {
|
|
i++;
|
|
}
|
|
keyAt = i;
|
|
}
|
|
i iVar2 = new i(keyAt, str, n.a);
|
|
this.a.put(str, iVar2);
|
|
this.b.put(keyAt, str);
|
|
this.d.put(keyAt, true);
|
|
this.e.c(iVar2);
|
|
return iVar2;
|
|
}
|
|
|
|
@WorkerThread
|
|
public void e(long j) throws IOException {
|
|
c cVar;
|
|
this.e.f(j);
|
|
c cVar2 = this.f;
|
|
if (cVar2 != null) {
|
|
cVar2.f(j);
|
|
}
|
|
if (this.e.d() || (cVar = this.f) == null || !cVar.d()) {
|
|
this.e.g(this.a, this.b);
|
|
} else {
|
|
this.f.g(this.a, this.b);
|
|
this.e.b(this.a);
|
|
}
|
|
c cVar3 = this.f;
|
|
if (cVar3 != null) {
|
|
cVar3.h();
|
|
this.f = null;
|
|
}
|
|
}
|
|
|
|
public void f(String str) {
|
|
i iVar = this.a.get(str);
|
|
if (iVar != null && iVar.f896c.isEmpty() && iVar.d.isEmpty()) {
|
|
this.a.remove(str);
|
|
int i = iVar.a;
|
|
boolean z2 = this.d.get(i);
|
|
this.e.a(iVar, z2);
|
|
if (z2) {
|
|
this.b.remove(i);
|
|
this.d.delete(i);
|
|
return;
|
|
}
|
|
this.b.put(i, null);
|
|
this.f897c.put(i, true);
|
|
}
|
|
}
|
|
|
|
@WorkerThread
|
|
public void g() throws IOException {
|
|
this.e.e(this.a);
|
|
int size = this.f897c.size();
|
|
for (int i = 0; i < size; i++) {
|
|
this.b.remove(this.f897c.keyAt(i));
|
|
}
|
|
this.f897c.clear();
|
|
this.d.clear();
|
|
}
|
|
}
|