1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
package com.bumptech.glide.load.engine;
import android.util.Log;
import com.bumptech.glide.Priority;
import com.bumptech.glide.load.engine.executor.Prioritized;
import com.bumptech.glide.request.ResourceCallback;
/**
* A runnable class responsible for using an {@link com.bumptech.glide.load.engine.DecodeJob} to decode resources on a
* background thread in two stages.
*
* <p>
* In the first stage, this class attempts to decode a resource
* from cache, first using transformed data and then using source data. If no resource can be decoded from cache,
* this class then requests to be posted again. During the second stage this class then attempts to use the
* {@link com.bumptech.glide.load.engine.DecodeJob} to decode data directly from the original source.
* </p>
*
* <p>
* Using two stages with a re-post in between allows us to run fast disk cache decodes on one thread and slow source
* fetches on a second pool so that loads for local data are never blocked waiting for loads for remote data to
* complete.
* </p>
*/
class EngineRunnable implements Runnable, Prioritized {
private static final String TAG = "EngineRunnable";
private final Priority priority;
private final EngineRunnableManager manager;
private final DecodeJob<?, ?, ?> decodeJob;
private Stage stage;
private volatile boolean isCancelled;
public EngineRunnable(EngineRunnableManager manager, DecodeJob<?, ?, ?> decodeJob, Priority priority) {
this.manager = manager;
this.decodeJob = decodeJob;
this.stage = Stage.CACHE;
this.priority = priority;
}
public void cancel() {
isCancelled = true;
decodeJob.cancel();
}
@Override
public void run() {
if (isCancelled) {
return;
}
Exception exception = null;
Resource<?> resource = null;
try {
resource = decode();
} catch (Exception e) {
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "Exception decoding", e);
}
exception = e;
}
if (isCancelled) {
if (resource != null) {
resource.recycle();
}
return;
}
if (resource == null) {
onLoadFailed(exception);
} else {
onLoadComplete(resource);
}
}
private boolean isDecodingFromCache() {
return stage == Stage.CACHE;
}
private void onLoadComplete(Resource resource) {
manager.onResourceReady(resource);
}
private void onLoadFailed(Exception e) {
if (isDecodingFromCache()) {
stage = Stage.SOURCE;
manager.submitForSource(this);
} else {
manager.onException(e);
}
}
private Resource<?> decode() throws Exception {
if (isDecodingFromCache()) {
return decodeFromCache();
} else {
return decodeFromSource();
}
}
private Resource<?> decodeFromCache() throws Exception {
Resource<?> result = null;
try {
result = decodeJob.decodeResultFromCache();
} catch (Exception e) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Exception decoding result from cache: " + e);
}
}
if (result == null) {
result = decodeJob.decodeSourceFromCache();
}
return result;
}
private Resource<?> decodeFromSource() throws Exception {
return decodeJob.decodeFromSource();
}
@Override
public int getPriority() {
return priority.ordinal();
}
private enum Stage {
/** Attempting to decode resource from cache. */
CACHE,
/** Attempting to decode resource from source data. */
SOURCE
}
interface EngineRunnableManager extends ResourceCallback {
void submitForSource(EngineRunnable runnable);
}
}
|
