677 lines
21 KiB
Java
677 lines
21 KiB
Java
package com.bumptech.glide.load.engine;
|
|
|
|
import android.os.Build;
|
|
import android.util.Log;
|
|
import androidx.core.util.Pools$Pool;
|
|
import com.bumptech.glide.GlideContext;
|
|
import com.bumptech.glide.Priority;
|
|
import com.bumptech.glide.Registry;
|
|
import com.bumptech.glide.load.DataSource;
|
|
import com.bumptech.glide.load.EncodeStrategy;
|
|
import com.bumptech.glide.load.Key;
|
|
import com.bumptech.glide.load.Options;
|
|
import com.bumptech.glide.load.ResourceEncoder;
|
|
import com.bumptech.glide.load.Transformation;
|
|
import com.bumptech.glide.load.data.DataFetcher;
|
|
import com.bumptech.glide.load.data.DataRewinder;
|
|
import com.bumptech.glide.load.engine.DataFetcherGenerator;
|
|
import com.bumptech.glide.load.engine.DecodePath;
|
|
import com.bumptech.glide.load.engine.cache.DiskCache;
|
|
import com.bumptech.glide.load.resource.bitmap.Downsampler;
|
|
import com.bumptech.glide.util.LogTime;
|
|
import com.bumptech.glide.util.pool.FactoryPools;
|
|
import com.bumptech.glide.util.pool.GlideTrace;
|
|
import com.bumptech.glide.util.pool.StateVerifier;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/* loaded from: classes.dex */
|
|
class DecodeJob<R> implements DataFetcherGenerator.FetcherReadyCallback, Runnable, Comparable<DecodeJob<?>>, FactoryPools.Poolable {
|
|
private Object A;
|
|
private DataSource B;
|
|
private DataFetcher<?> C;
|
|
private volatile DataFetcherGenerator D;
|
|
private volatile boolean E;
|
|
private volatile boolean F;
|
|
private final DiskCacheProvider d;
|
|
private final Pools$Pool<DecodeJob<?>> e;
|
|
private GlideContext h;
|
|
private Key i;
|
|
private Priority j;
|
|
private EngineKey k;
|
|
private int l;
|
|
private int m;
|
|
private DiskCacheStrategy n;
|
|
private Options o;
|
|
private Callback<R> p;
|
|
private int q;
|
|
private Stage r;
|
|
private RunReason s;
|
|
private long t;
|
|
private boolean u;
|
|
private Object v;
|
|
private Thread x;
|
|
private Key y;
|
|
private Key z;
|
|
private final DecodeHelper<R> a = new DecodeHelper<>();
|
|
private final List<Throwable> b = new ArrayList();
|
|
private final StateVerifier c = StateVerifier.b();
|
|
private final DeferredEncodeManager<?> f = new DeferredEncodeManager<>();
|
|
private final ReleaseManager g = new ReleaseManager();
|
|
|
|
/* renamed from: com.bumptech.glide.load.engine.DecodeJob$1, reason: invalid class name */
|
|
static /* synthetic */ class AnonymousClass1 {
|
|
static final /* synthetic */ int[] a;
|
|
static final /* synthetic */ int[] b;
|
|
static final /* synthetic */ int[] c = new int[EncodeStrategy.values().length];
|
|
|
|
static {
|
|
try {
|
|
c[EncodeStrategy.SOURCE.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
c[EncodeStrategy.TRANSFORMED.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
b = new int[Stage.values().length];
|
|
try {
|
|
b[Stage.RESOURCE_CACHE.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
b[Stage.DATA_CACHE.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
try {
|
|
b[Stage.SOURCE.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused5) {
|
|
}
|
|
try {
|
|
b[Stage.FINISHED.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused6) {
|
|
}
|
|
try {
|
|
b[Stage.INITIALIZE.ordinal()] = 5;
|
|
} catch (NoSuchFieldError unused7) {
|
|
}
|
|
a = new int[RunReason.values().length];
|
|
try {
|
|
a[RunReason.INITIALIZE.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused8) {
|
|
}
|
|
try {
|
|
a[RunReason.SWITCH_TO_SOURCE_SERVICE.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused9) {
|
|
}
|
|
try {
|
|
a[RunReason.DECODE_DATA.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused10) {
|
|
}
|
|
}
|
|
}
|
|
|
|
interface Callback<R> {
|
|
void a(DecodeJob<?> decodeJob);
|
|
|
|
void a(GlideException glideException);
|
|
|
|
void a(Resource<R> resource, DataSource dataSource);
|
|
}
|
|
|
|
private final class DecodeCallback<Z> implements DecodePath.DecodeCallback<Z> {
|
|
private final DataSource a;
|
|
|
|
DecodeCallback(DataSource dataSource) {
|
|
this.a = dataSource;
|
|
}
|
|
|
|
@Override // com.bumptech.glide.load.engine.DecodePath.DecodeCallback
|
|
public Resource<Z> a(Resource<Z> resource) {
|
|
return DecodeJob.this.a(this.a, resource);
|
|
}
|
|
}
|
|
|
|
interface DiskCacheProvider {
|
|
DiskCache a();
|
|
}
|
|
|
|
private enum RunReason {
|
|
INITIALIZE,
|
|
SWITCH_TO_SOURCE_SERVICE,
|
|
DECODE_DATA
|
|
}
|
|
|
|
private enum Stage {
|
|
INITIALIZE,
|
|
RESOURCE_CACHE,
|
|
DATA_CACHE,
|
|
SOURCE,
|
|
ENCODE,
|
|
FINISHED
|
|
}
|
|
|
|
DecodeJob(DiskCacheProvider diskCacheProvider, Pools$Pool<DecodeJob<?>> pools$Pool) {
|
|
this.d = diskCacheProvider;
|
|
this.e = pools$Pool;
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
private void b(Resource<R> resource, DataSource dataSource) {
|
|
if (resource instanceof Initializable) {
|
|
((Initializable) resource).c();
|
|
}
|
|
LockedResource lockedResource = 0;
|
|
if (this.f.b()) {
|
|
resource = LockedResource.b(resource);
|
|
lockedResource = resource;
|
|
}
|
|
a((Resource) resource, dataSource);
|
|
this.r = Stage.ENCODE;
|
|
try {
|
|
if (this.f.b()) {
|
|
this.f.a(this.d, this.o);
|
|
}
|
|
o();
|
|
} finally {
|
|
if (lockedResource != 0) {
|
|
lockedResource.d();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void f() {
|
|
if (Log.isLoggable("DecodeJob", 2)) {
|
|
a("Retrieved data", this.t, "data: " + this.A + ", cache key: " + this.y + ", fetcher: " + this.C);
|
|
}
|
|
Resource<R> resource = null;
|
|
try {
|
|
resource = a(this.C, (DataFetcher<?>) this.A, this.B);
|
|
} catch (GlideException e) {
|
|
e.setLoggingDetails(this.z, this.B);
|
|
this.b.add(e);
|
|
}
|
|
if (resource != null) {
|
|
b(resource, this.B);
|
|
} else {
|
|
r();
|
|
}
|
|
}
|
|
|
|
private DataFetcherGenerator m() {
|
|
int i = AnonymousClass1.b[this.r.ordinal()];
|
|
if (i == 1) {
|
|
return new ResourceCacheGenerator(this.a, this);
|
|
}
|
|
if (i == 2) {
|
|
return new DataCacheGenerator(this.a, this);
|
|
}
|
|
if (i == 3) {
|
|
return new SourceGenerator(this.a, this);
|
|
}
|
|
if (i == 4) {
|
|
return null;
|
|
}
|
|
throw new IllegalStateException("Unrecognized stage: " + this.r);
|
|
}
|
|
|
|
private void n() {
|
|
t();
|
|
this.p.a(new GlideException("Failed to load resource", new ArrayList(this.b)));
|
|
p();
|
|
}
|
|
|
|
private void o() {
|
|
if (this.g.a()) {
|
|
q();
|
|
}
|
|
}
|
|
|
|
private void p() {
|
|
if (this.g.b()) {
|
|
q();
|
|
}
|
|
}
|
|
|
|
private void q() {
|
|
this.g.c();
|
|
this.f.a();
|
|
this.a.a();
|
|
this.E = false;
|
|
this.h = null;
|
|
this.i = null;
|
|
this.o = null;
|
|
this.j = null;
|
|
this.k = null;
|
|
this.p = null;
|
|
this.r = null;
|
|
this.D = null;
|
|
this.x = null;
|
|
this.y = null;
|
|
this.A = null;
|
|
this.B = null;
|
|
this.C = null;
|
|
this.t = 0L;
|
|
this.F = false;
|
|
this.v = null;
|
|
this.b.clear();
|
|
this.e.a(this);
|
|
}
|
|
|
|
private void r() {
|
|
this.x = Thread.currentThread();
|
|
this.t = LogTime.a();
|
|
boolean z = false;
|
|
while (!this.F && this.D != null && !(z = this.D.a())) {
|
|
this.r = a(this.r);
|
|
this.D = m();
|
|
if (this.r == Stage.SOURCE) {
|
|
d();
|
|
return;
|
|
}
|
|
}
|
|
if ((this.r == Stage.FINISHED || this.F) && !z) {
|
|
n();
|
|
}
|
|
}
|
|
|
|
private void s() {
|
|
int i = AnonymousClass1.a[this.s.ordinal()];
|
|
if (i == 1) {
|
|
this.r = a(Stage.INITIALIZE);
|
|
this.D = m();
|
|
r();
|
|
} else if (i == 2) {
|
|
r();
|
|
} else {
|
|
if (i == 3) {
|
|
f();
|
|
return;
|
|
}
|
|
throw new IllegalStateException("Unrecognized run reason: " + this.s);
|
|
}
|
|
}
|
|
|
|
private void t() {
|
|
this.c.a();
|
|
if (this.E) {
|
|
throw new IllegalStateException("Already notified");
|
|
}
|
|
this.E = true;
|
|
}
|
|
|
|
DecodeJob<R> a(GlideContext glideContext, Object obj, EngineKey engineKey, Key key, int i, int i2, Class<?> cls, Class<R> cls2, Priority priority, DiskCacheStrategy diskCacheStrategy, Map<Class<?>, Transformation<?>> map, boolean z, boolean z2, boolean z3, Options options, Callback<R> callback, int i3) {
|
|
this.a.a(glideContext, obj, key, i, i2, diskCacheStrategy, cls, cls2, priority, options, map, z, z2, this.d);
|
|
this.h = glideContext;
|
|
this.i = key;
|
|
this.j = priority;
|
|
this.k = engineKey;
|
|
this.l = i;
|
|
this.m = i2;
|
|
this.n = diskCacheStrategy;
|
|
this.u = z3;
|
|
this.o = options;
|
|
this.p = callback;
|
|
this.q = i3;
|
|
this.s = RunReason.INITIALIZE;
|
|
this.v = obj;
|
|
return this;
|
|
}
|
|
|
|
@Override // com.bumptech.glide.util.pool.FactoryPools.Poolable
|
|
public StateVerifier c() {
|
|
return this.c;
|
|
}
|
|
|
|
public void cancel() {
|
|
this.F = true;
|
|
DataFetcherGenerator dataFetcherGenerator = this.D;
|
|
if (dataFetcherGenerator != null) {
|
|
dataFetcherGenerator.cancel();
|
|
}
|
|
}
|
|
|
|
@Override // com.bumptech.glide.load.engine.DataFetcherGenerator.FetcherReadyCallback
|
|
public void d() {
|
|
this.s = RunReason.SWITCH_TO_SOURCE_SERVICE;
|
|
this.p.a((DecodeJob<?>) this);
|
|
}
|
|
|
|
boolean e() {
|
|
Stage a = a(Stage.INITIALIZE);
|
|
return a == Stage.RESOURCE_CACHE || a == Stage.DATA_CACHE;
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:12:0x001e, code lost:
|
|
|
|
if (r1 != null) goto L12;
|
|
*/
|
|
@Override // java.lang.Runnable
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct code enable 'Show inconsistent code' option in preferences
|
|
*/
|
|
public void run() {
|
|
/*
|
|
r5 = this;
|
|
java.lang.String r0 = "DecodeJob"
|
|
java.lang.Object r1 = r5.v
|
|
java.lang.String r2 = "DecodeJob#run(model=%s)"
|
|
com.bumptech.glide.util.pool.GlideTrace.a(r2, r1)
|
|
com.bumptech.glide.load.data.DataFetcher<?> r1 = r5.C
|
|
boolean r2 = r5.F // Catch: java.lang.Throwable -> L27
|
|
if (r2 == 0) goto L1b
|
|
r5.n() // Catch: java.lang.Throwable -> L27
|
|
if (r1 == 0) goto L17
|
|
r1.b()
|
|
L17:
|
|
com.bumptech.glide.util.pool.GlideTrace.a()
|
|
return
|
|
L1b:
|
|
r5.s() // Catch: java.lang.Throwable -> L27
|
|
if (r1 == 0) goto L23
|
|
L20:
|
|
r1.b()
|
|
L23:
|
|
com.bumptech.glide.util.pool.GlideTrace.a()
|
|
goto L64
|
|
L27:
|
|
r2 = move-exception
|
|
r3 = 3
|
|
boolean r3 = android.util.Log.isLoggable(r0, r3) // Catch: java.lang.Throwable -> L66
|
|
if (r3 == 0) goto L4f
|
|
java.lang.StringBuilder r3 = new java.lang.StringBuilder // Catch: java.lang.Throwable -> L66
|
|
r3.<init>() // Catch: java.lang.Throwable -> L66
|
|
java.lang.String r4 = "DecodeJob threw unexpectedly, isCancelled: "
|
|
r3.append(r4) // Catch: java.lang.Throwable -> L66
|
|
boolean r4 = r5.F // Catch: java.lang.Throwable -> L66
|
|
r3.append(r4) // Catch: java.lang.Throwable -> L66
|
|
java.lang.String r4 = ", stage: "
|
|
r3.append(r4) // Catch: java.lang.Throwable -> L66
|
|
com.bumptech.glide.load.engine.DecodeJob$Stage r4 = r5.r // Catch: java.lang.Throwable -> L66
|
|
r3.append(r4) // Catch: java.lang.Throwable -> L66
|
|
java.lang.String r3 = r3.toString() // Catch: java.lang.Throwable -> L66
|
|
android.util.Log.d(r0, r3, r2) // Catch: java.lang.Throwable -> L66
|
|
L4f:
|
|
com.bumptech.glide.load.engine.DecodeJob$Stage r0 = r5.r // Catch: java.lang.Throwable -> L66
|
|
com.bumptech.glide.load.engine.DecodeJob$Stage r3 = com.bumptech.glide.load.engine.DecodeJob.Stage.ENCODE // Catch: java.lang.Throwable -> L66
|
|
if (r0 == r3) goto L5d
|
|
java.util.List<java.lang.Throwable> r0 = r5.b // Catch: java.lang.Throwable -> L66
|
|
r0.add(r2) // Catch: java.lang.Throwable -> L66
|
|
r5.n() // Catch: java.lang.Throwable -> L66
|
|
L5d:
|
|
boolean r0 = r5.F // Catch: java.lang.Throwable -> L66
|
|
if (r0 == 0) goto L65
|
|
if (r1 == 0) goto L23
|
|
goto L20
|
|
L64:
|
|
return
|
|
L65:
|
|
throw r2 // Catch: java.lang.Throwable -> L66
|
|
L66:
|
|
r0 = move-exception
|
|
if (r1 == 0) goto L6c
|
|
r1.b()
|
|
L6c:
|
|
com.bumptech.glide.util.pool.GlideTrace.a()
|
|
throw r0
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: com.bumptech.glide.load.engine.DecodeJob.run():void");
|
|
}
|
|
|
|
private static class ReleaseManager {
|
|
private boolean a;
|
|
private boolean b;
|
|
private boolean c;
|
|
|
|
ReleaseManager() {
|
|
}
|
|
|
|
synchronized boolean a(boolean z) {
|
|
this.a = true;
|
|
return b(z);
|
|
}
|
|
|
|
synchronized boolean b() {
|
|
this.c = true;
|
|
return b(false);
|
|
}
|
|
|
|
synchronized void c() {
|
|
this.b = false;
|
|
this.a = false;
|
|
this.c = false;
|
|
}
|
|
|
|
private boolean b(boolean z) {
|
|
return (this.c || z || this.b) && this.a;
|
|
}
|
|
|
|
synchronized boolean a() {
|
|
this.b = true;
|
|
return b(false);
|
|
}
|
|
}
|
|
|
|
private static class DeferredEncodeManager<Z> {
|
|
private Key a;
|
|
private ResourceEncoder<Z> b;
|
|
private LockedResource<Z> c;
|
|
|
|
DeferredEncodeManager() {
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
<X> void a(Key key, ResourceEncoder<X> resourceEncoder, LockedResource<X> lockedResource) {
|
|
this.a = key;
|
|
this.b = resourceEncoder;
|
|
this.c = lockedResource;
|
|
}
|
|
|
|
boolean b() {
|
|
return this.c != null;
|
|
}
|
|
|
|
void a(DiskCacheProvider diskCacheProvider, Options options) {
|
|
GlideTrace.a("DecodeJob.encode");
|
|
try {
|
|
diskCacheProvider.a().a(this.a, new DataCacheWriter(this.b, this.c, options));
|
|
} finally {
|
|
this.c.d();
|
|
GlideTrace.a();
|
|
}
|
|
}
|
|
|
|
void a() {
|
|
this.a = null;
|
|
this.b = null;
|
|
this.c = null;
|
|
}
|
|
}
|
|
|
|
void a(boolean z) {
|
|
if (this.g.a(z)) {
|
|
q();
|
|
}
|
|
}
|
|
|
|
@Override // java.lang.Comparable
|
|
/* renamed from: a, reason: merged with bridge method [inline-methods] */
|
|
public int compareTo(DecodeJob<?> decodeJob) {
|
|
int a = a() - decodeJob.a();
|
|
return a == 0 ? this.q - decodeJob.q : a;
|
|
}
|
|
|
|
private int a() {
|
|
return this.j.ordinal();
|
|
}
|
|
|
|
private void a(Resource<R> resource, DataSource dataSource) {
|
|
t();
|
|
this.p.a(resource, dataSource);
|
|
}
|
|
|
|
private Stage a(Stage stage) {
|
|
int i = AnonymousClass1.b[stage.ordinal()];
|
|
if (i == 1) {
|
|
return this.n.a() ? Stage.DATA_CACHE : a(Stage.DATA_CACHE);
|
|
}
|
|
if (i == 2) {
|
|
return this.u ? Stage.FINISHED : Stage.SOURCE;
|
|
}
|
|
if (i == 3 || i == 4) {
|
|
return Stage.FINISHED;
|
|
}
|
|
if (i == 5) {
|
|
return this.n.b() ? Stage.RESOURCE_CACHE : a(Stage.RESOURCE_CACHE);
|
|
}
|
|
throw new IllegalArgumentException("Unrecognized stage: " + stage);
|
|
}
|
|
|
|
@Override // com.bumptech.glide.load.engine.DataFetcherGenerator.FetcherReadyCallback
|
|
public void a(Key key, Object obj, DataFetcher<?> dataFetcher, DataSource dataSource, Key key2) {
|
|
this.y = key;
|
|
this.A = obj;
|
|
this.C = dataFetcher;
|
|
this.B = dataSource;
|
|
this.z = key2;
|
|
if (Thread.currentThread() != this.x) {
|
|
this.s = RunReason.DECODE_DATA;
|
|
this.p.a((DecodeJob<?>) this);
|
|
} else {
|
|
GlideTrace.a("DecodeJob.decodeFromRetrievedData");
|
|
try {
|
|
f();
|
|
} finally {
|
|
GlideTrace.a();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // com.bumptech.glide.load.engine.DataFetcherGenerator.FetcherReadyCallback
|
|
public void a(Key key, Exception exc, DataFetcher<?> dataFetcher, DataSource dataSource) {
|
|
dataFetcher.b();
|
|
GlideException glideException = new GlideException("Fetching data failed", exc);
|
|
glideException.setLoggingDetails(key, dataSource, dataFetcher.a());
|
|
this.b.add(glideException);
|
|
if (Thread.currentThread() != this.x) {
|
|
this.s = RunReason.SWITCH_TO_SOURCE_SERVICE;
|
|
this.p.a((DecodeJob<?>) this);
|
|
} else {
|
|
r();
|
|
}
|
|
}
|
|
|
|
private <Data> Resource<R> a(DataFetcher<?> dataFetcher, Data data, DataSource dataSource) throws GlideException {
|
|
if (data == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
long a = LogTime.a();
|
|
Resource<R> a2 = a((DecodeJob<R>) data, dataSource);
|
|
if (Log.isLoggable("DecodeJob", 2)) {
|
|
a("Decoded result " + a2, a);
|
|
}
|
|
return a2;
|
|
} finally {
|
|
dataFetcher.b();
|
|
}
|
|
}
|
|
|
|
private <Data> Resource<R> a(Data data, DataSource dataSource) throws GlideException {
|
|
return a((DecodeJob<R>) data, dataSource, (LoadPath<DecodeJob<R>, ResourceType, R>) this.a.a((Class) data.getClass()));
|
|
}
|
|
|
|
private Options a(DataSource dataSource) {
|
|
Options options = this.o;
|
|
if (Build.VERSION.SDK_INT < 26 || options.a(Downsampler.h) != null) {
|
|
return options;
|
|
}
|
|
if (dataSource != DataSource.RESOURCE_DISK_CACHE && !this.a.n()) {
|
|
return options;
|
|
}
|
|
Options options2 = new Options();
|
|
options2.a(this.o);
|
|
options2.a(Downsampler.h, true);
|
|
return options2;
|
|
}
|
|
|
|
private <Data, ResourceType> Resource<R> a(Data data, DataSource dataSource, LoadPath<Data, ResourceType, R> loadPath) throws GlideException {
|
|
Options a = a(dataSource);
|
|
DataRewinder<Data> b = this.h.e().b((Registry) data);
|
|
try {
|
|
return loadPath.a(b, a, this.l, this.m, new DecodeCallback(dataSource));
|
|
} finally {
|
|
b.b();
|
|
}
|
|
}
|
|
|
|
private void a(String str, long j) {
|
|
a(str, j, (String) null);
|
|
}
|
|
|
|
private void a(String str, long j, String str2) {
|
|
String str3;
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(str);
|
|
sb.append(" in ");
|
|
sb.append(LogTime.a(j));
|
|
sb.append(", load key: ");
|
|
sb.append(this.k);
|
|
if (str2 != null) {
|
|
str3 = ", " + str2;
|
|
} else {
|
|
str3 = "";
|
|
}
|
|
sb.append(str3);
|
|
sb.append(", thread: ");
|
|
sb.append(Thread.currentThread().getName());
|
|
Log.v("DecodeJob", sb.toString());
|
|
}
|
|
|
|
<Z> Resource<Z> a(DataSource dataSource, Resource<Z> resource) {
|
|
Resource<Z> resource2;
|
|
Transformation<Z> transformation;
|
|
EncodeStrategy encodeStrategy;
|
|
Key dataCacheKey;
|
|
Class<?> cls = resource.get().getClass();
|
|
ResourceEncoder<Z> resourceEncoder = null;
|
|
if (dataSource != DataSource.RESOURCE_DISK_CACHE) {
|
|
Transformation<Z> b = this.a.b(cls);
|
|
transformation = b;
|
|
resource2 = b.a(this.h, resource, this.l, this.m);
|
|
} else {
|
|
resource2 = resource;
|
|
transformation = null;
|
|
}
|
|
if (!resource.equals(resource2)) {
|
|
resource.a();
|
|
}
|
|
if (this.a.b((Resource<?>) resource2)) {
|
|
resourceEncoder = this.a.a((Resource) resource2);
|
|
encodeStrategy = resourceEncoder.a(this.o);
|
|
} else {
|
|
encodeStrategy = EncodeStrategy.NONE;
|
|
}
|
|
ResourceEncoder resourceEncoder2 = resourceEncoder;
|
|
if (!this.n.a(!this.a.a(this.y), dataSource, encodeStrategy)) {
|
|
return resource2;
|
|
}
|
|
if (resourceEncoder2 != null) {
|
|
int i = AnonymousClass1.c[encodeStrategy.ordinal()];
|
|
if (i == 1) {
|
|
dataCacheKey = new DataCacheKey(this.y, this.i);
|
|
} else if (i == 2) {
|
|
dataCacheKey = new ResourceCacheKey(this.a.b(), this.y, this.i, this.l, this.m, transformation, cls, this.o);
|
|
} else {
|
|
throw new IllegalArgumentException("Unknown strategy: " + encodeStrategy);
|
|
}
|
|
LockedResource b2 = LockedResource.b(resource2);
|
|
this.f.a(dataCacheKey, resourceEncoder2, b2);
|
|
return b2;
|
|
}
|
|
throw new Registry.NoResultEncoderAvailableException(resource2.get().getClass());
|
|
}
|
|
}
|