Glide 4.11.0 Send request preparation, this article analyzes the request and cache of Glide. Requests end up wrapped as SingleRequest.
directory
Get pictures from memory 3. Get pictures from disk 4. Get Pictures from network 5
One request entry
request.begin(); The begin() method of SingleRequest is executed
SingleRequest.java
@Override
public void begin(a) {
/ / synchronization locks
synchronized(requestLock) {...if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
// Where the actual request and cache are
onSizeReady(overrideWidth, overrideHeight);
} else{···} ···}}Copy the codeUse engine.load () to load image data
SingleRequest.java
public void onSizeReady(int width, int height) {
stateVerifier.throwIfRecycled();
synchronized (requestLock) {
if (IS_VERBOSE_LOGGABLE) {
logV("Got onSizeReady in " + LogTime.getElapsedMillis(startTime));
}
if(status ! = Status.WAITING_FOR_SIZE) {return;
}
status = Status.RUNNING;
/ / thumbnails
float sizeMultiplier = requestOptions.getSizeMultiplier();
this.width = maybeApplySizeMultiplier(width, sizeMultiplier);
this.height = maybeApplySizeMultiplier(height, sizeMultiplier); ... loadStatus = engine. The load (glideContext, model, requestOptions getSignature (),this.width,
this.height,
requestOptions.getResourceClass(),
transcodeClass,
priority,
requestOptions.getDiskCacheStrategy(),
requestOptions.getTransformations(),
requestOptions.isTransformationRequired(),
requestOptions.isScaleOnlyOrNoTransform(),
requestOptions.getOptions(),
requestOptions.isMemoryCacheable(),
requestOptions.getUseUnlimitedSourceGeneratorsPool(),
requestOptions.getUseAnimationPool(),
requestOptions.getOnlyRetrieveFromCache(),
this, callbackExecutor); ...}}Copy the codeFirst the static factory method creates the engine key, using signature, width, height, transform, resource class, configuration, and so on as the parameters to generate the key
Engine.java
public <R> LoadStatus load(
GlideContext glideContext,
Object model,
Key signature,
int width,
intheight, Class<? > resourceClass, Class<R> transcodeClass, Priority priority, DiskCacheStrategy diskCacheStrategy, Map<Class<? >, Transformation<? >> transformations,boolean isTransformationRequired,
boolean isScaleOnlyOrNoTransform,
Options options,
boolean isMemoryCacheable,
boolean useUnlimitedSourceExecutorPool,
boolean useAnimationPool,
boolean onlyRetrieveFromCache,
ResourceCallback cb,
Executor callbackExecutor) {
long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;
// Create a key to load the engine through a static factory
EngineKey key =
keyFactory.buildKey(
model,
signature,
width,
height,
transformations,
resourceClass,
transcodeClass,
options);
// Fetch data from memoryEngineResource<? > memoryResource;synchronized (this) {
memoryResource = loadFromMemory(key, isMemoryCacheable, startTime);
if (memoryResource == null) {
//
returnwaitForExistingOrStartNewJob( glideContext, model, signature, width, height, resourceClass, transcodeClass, priority, diskCacheStrategy, transformations, isTransformationRequired, isScaleOnlyOrNoTransform, options, isMemoryCacheable, useUnlimitedSourceExecutorPool, useAnimationPool, onlyRetrieveFromCache, cb, callbackExecutor, key, startTime); }}// Avoid calling back while holding the engine lock, doing so makes it easier for callers to
// deadlock.
cb.onResourceReady(memoryResource, DataSource.MEMORY_CACHE);
return null;
Copy the codeFetch the image from memory
2.1 Retrieving images from memory
memoryResource = loadFromMemory(key, isMemoryCacheable, startTime); Load images from memory
Engine.java
privateEngineResource<? > loadFromMemory( EngineKey key,boolean isMemoryCacheable, long startTime) {
// If no image is fetched from memory, null is returned
if(! isMemoryCacheable) {return null;
}
// Get the resource being displayedEngineResource<? > active = loadFromActiveResources(key);if(active ! =null) {...return active;
}
// Load images from the cacheEngineResource<? > cached = loadFromCache(key);if(cached ! =null) {...return cached;
}
return null;
}
Copy the code2.1.1 Loading Image Data from Active Images & Increasing image reference count
loadFromActiveResources(key);
Engine.java
privateEngineResource<? > loadFromActiveResources(Key key) {// Fetch the image from the cacheEngineResource<? > active = activeResources.get(key);if(active ! =null) {
// Increase the reference count
active.acquire();
}
return active;
}
Copy the code2.1.1.1 Load image data from the active cache
ActiveResources.java
synchronizedEngineResource<? > get(Key key) {// Weak references decorate image references
ResourceWeakReference activeRef = activeEngineResources.get(key);
if (activeRef == null) {
return null; } EngineResource<? > active = activeRef.get();if (active == null) {
// Clear if active is null
cleanupActiveReference(activeRef);
}
// Return cached data
return active;
}
Copy the code2.2.1 Loading images from the cache
loadFromCache(key); By loading images in the cache
Engine.java
privateEngineResource<? > loadFromCache(Key key) {// Retrieve the image from the cacheEngineResource<? > cached = getEngineResourceFromCache(key);if(cached ! =null) {
// Increase the reference count
cached.acquire();
// Add to the active cache
activeResources.activate(key, cached);
}
return cached;
}
Copy the codegetEngineResourceFromCache(key); Get image data from the cache
Engine.java
privateEngineResource<? > getEngineResourceFromCache(Key key) { Resource<? > cached = cache.remove(key);finalEngineResource<? > result;// Encapsulate the return result
if (cached == null) {
result = null;
} else if (cached instanceof EngineResource) {
// Save an object allocation if we've cached an EngineResource (the typical case).result = (EngineResource<? >) cached; }else {
result =
new EngineResource<>(
cached, /*isMemoryCacheable=*/ true./*isRecyclable=*/ true, key, /*listener=*/ this);
}
return result;
}
Copy the code2.2.2 Initialization of cache
The cache obtained above is of the MemoryCache type and can be set externally and assigned at Builder Glide configuration time
GlideBuilder.java
@NonNull
Glide build(@NonNull Context context) {...if (memoryCache == null) {
// Memory cache
memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
}
if (engine == null) {
engine =
new Engine(
// Here memoryCache is passed to the load enginememoryCache, diskCacheFactory, diskCacheExecutor, sourceExecutor, GlideExecutor.newUnlimitedSourceExecutor(), animationExecutor, isActiveResourceRetentionAllowed); }...return new Glide(
context,
engine,
memoryCache,
bitmapPool,
arrayPool,
requestManagerRetriever,
connectivityMonitorFactory,
logLevel,
defaultRequestOptionsFactory,
defaultTransitionOptions,
defaultRequestListeners,
isLoggingRequestOriginsEnabled,
isImageDecoderEnabledForBitmaps);
}
Copy the code2.2.3 Memory Cache LruResourceCache
LruResourceCache inherits from LruCache and internally uses LinkedHashMap to realize LRU algorithm. The initial size is 100 and the loading factor is 0.75. All methods are synchronized modification to ensure synchronization
Fetch pictures from disk
3.1 Create the task of obtaining and decoding pictures
Starting with Engine’s load method, if no images are fetched from memory, start creating tasks to fetch images from disk or the network
Engine.java
public <R> LoadStatus load(
GlideContext glideContext,
Object model,
Key signature,
int width,
intheight, Class<? > resourceClass, Class<R> transcodeClass, Priority priority, DiskCacheStrategy diskCacheStrategy, Map<Class<? >, Transformation<? >> transformations,boolean isTransformationRequired,
boolean isScaleOnlyOrNoTransform,
Options options,
boolean isMemoryCacheable,
boolean useUnlimitedSourceExecutorPool,
boolean useAnimationPool,
boolean onlyRetrieveFromCache,
ResourceCallback cb,
Executor callbackExecutor) {
long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0; EngineKey key = keyFactory.buildKey( model, signature, width, height, transformations, resourceClass, transcodeClass, options); EngineResource<? > memoryResource;synchronized (this) {
memoryResource = loadFromMemory(key, isMemoryCacheable, startTime);
if (memoryResource == null) {
returnwaitForExistingOrStartNewJob( glideContext, model, signature, width, height, resourceClass, transcodeClass, priority, diskCacheStrategy, transformations, isTransformationRequired, isScaleOnlyOrNoTransform, options, isMemoryCacheable, useUnlimitedSourceExecutorPool, useAnimationPool, onlyRetrieveFromCache, cb, callbackExecutor, key, startTime); }}Copy the codeEngine.java
private <R> LoadStatus waitForExistingOrStartNewJob(
GlideContext glideContext,
Object model,
Key signature,
int width,
intheight, Class<? > resourceClass, Class<R> transcodeClass, Priority priority, DiskCacheStrategy diskCacheStrategy, Map<Class<? >, Transformation<? >> transformations,boolean isTransformationRequired,
boolean isScaleOnlyOrNoTransform,
Options options,
boolean isMemoryCacheable,
boolean useUnlimitedSourceExecutorPool,
boolean useAnimationPool,
boolean onlyRetrieveFromCache,
ResourceCallback cb,
Executor callbackExecutor,
EngineKey key,
long startTime) {
// If there is a task, fetch it directlyEngineJob<? > current = jobs.get(key, onlyRetrieveFromCache);if(current ! =null) { current.addCallback(cb, callbackExecutor); ...return new LoadStatus(cb, current);
}
// Create a task to execute
EngineJob<R> engineJob =
engineJobFactory.build(
key,
isMemoryCacheable,
useUnlimitedSourceExecutorPool,
useAnimationPool,
onlyRetrieveFromCache);
// Create a decoding task
DecodeJob<R> decodeJob =
decodeJobFactory.build(
glideContext,
model,
key,
signature,
width,
height,
resourceClass,
transcodeClass,
priority,
diskCacheStrategy,
transformations,
isTransformationRequired,
isScaleOnlyOrNoTransform,
onlyRetrieveFromCache,
options,
engineJob);
// Add the task to the cache
jobs.put(key, engineJob);
// Set the callback for the task
engineJob.addCallback(cb, callbackExecutor);
// Start the taskengineJob.start(decodeJob); ...return new LoadStatus(cb, engineJob);
}
Copy the code3.2 engineJob Obtains the picture task engine
The engineJob is created using the factory method
GlideBuilder.java
Glide build(@NonNull Conext context) {...if (engine == null) {
// Create a load engine if you don't have one externally
engine =
newEngine( memoryCache, diskCacheFactory, diskCacheExecutor, sourceExecutor, GlideExecutor.newUnlimitedSourceExecutor(), animationExecutor, isActiveResourceRetentionAllowed); }...}Copy the codeEngine constructor
Engine.java
public Engine(
MemoryCache memoryCache,
DiskCache.Factory diskCacheFactory,
GlideExecutor diskCacheExecutor,
GlideExecutor sourceExecutor,
GlideExecutor sourceUnlimitedExecutor,
GlideExecutor animationExecutor,
boolean isActiveResourceRetentionAllowed) {
this(
memoryCache,
diskCacheFactory,
diskCacheExecutor,
sourceExecutor,
sourceUnlimitedExecutor,
animationExecutor,
/*jobs=*/ null./*keyFactory=*/ null./*activeResources=*/ null./*engineJobFactory=*/ null./*decodeJobFactory=*/ null./*resourceRecycler=*/ null,
isActiveResourceRetentionAllowed);
}
Engine(
MemoryCache cache,
DiskCache.Factory diskCacheFactory,
GlideExecutor diskCacheExecutor,
GlideExecutor sourceExecutor,
GlideExecutor sourceUnlimitedExecutor,
GlideExecutor animationExecutor,
Jobs jobs,
EngineKeyFactory keyFactory,
ActiveResources activeResources,
EngineJobFactory engineJobFactory,
DecodeJobFactory decodeJobFactory,
ResourceRecycler resourceRecycler,
booleanIsActiveResourceRetentionAllowed) {...if (engineJobFactory == null) {
engineJobFactory =
new EngineJobFactory(
diskCacheExecutor,
sourceExecutor,
sourceUnlimitedExecutor,
animationExecutor,
/*engineJobListener=*/ this./*resourceListener=*/ this); }...}Copy the code3.3 Start the image retrieval task
engineJob.start(decodeJob); DecodeJob run()
EngineJob.java
public synchronized void start(DecodeJob<R> decodeJob) {
this.decodeJob = decodeJob;
GlideExecutor executor =
decodeJob.willDecodeFromCache() ? diskCacheExecutor : getActiveSourceExecutor();
executor.execute(decodeJob);
}
Copy the codeDecodeJob.java
public void run(a) {.../ / assignment callbackDataFetcher<? > localFetcher = currentFetcher;try {
if (isCancelled) {
notifyFailed();
return;
}
// Load method
runWrapped();
} catch (CallbackException e) {
// If a callback not controlled by Glide throws an exception, we should avoid the Glide
// specific debug logic below.
throw e;
} catch(Throwable t) {...if(stage ! = Stage.ENCODE) { throwables.add(t); notifyFailed(); }...}finally{.../ / to empty
if(localFetcher ! =null) { localFetcher.cleanup(); } GlideTrace.endSection(); }}Copy the codeCall runWrapped (); Start a mission
DecodeJob.java
private void runWrapped(a) {
switch (runReason) {
// This must be called the first time
case INITIALIZE:
stage = getNextStage(Stage.INITIALIZE);
currentGenerator = getNextGenerator();
runGenerators();
break;
case SWITCH_TO_SOURCE_SERVICE:
runGenerators();
break;
case DECODE_DATA:
decodeFromRetrievedData();
break;
default:
throw new IllegalStateException("Unrecognized run reason: "+ runReason); }}Copy the codegetNextStage(Stage.INITIALIZE); Gets the type of loaded data based on the current state
private Stage getNextStage(Stage current) {
switch (current) {
case INITIALIZE:
// A decoded cache returns stage.resource_cache
return diskCacheStrategy.decodeCachedResource()
? Stage.RESOURCE_CACHE
: getNextStage(Stage.RESOURCE_CACHE);
case RESOURCE_CACHE:
// Return stage.data_cache if there are disk meat dishes
return diskCacheStrategy.decodeCachedData()
? Stage.DATA_CACHE
: getNextStage(Stage.DATA_CACHE);
case DATA_CACHE:
// Skip loading from source if the user opted to only retrieve the resource from cache.
// Return stage.finished if only loaded from cache otherwise stage.source
return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
case SOURCE:
case FINISHED:
return Stage.FINISHED;
default:
throw new IllegalArgumentException("Unrecognized stage: "+ current); }}Copy the codeGetNextStage () returns the Stage to runWrapped() and then calls getNextGenerator() to get different ways of loading data depending on the state
DecodeJob.java
private DataFetcherGenerator getNextGenerator(a) {
switch (stage) {
case RESOURCE_CACHE:
// Fetch data from the decoded file cache
return new ResourceCacheGenerator(decodeHelper, this);
case DATA_CACHE:
// Fetch data from the file cache
return new DataCacheGenerator(decodeHelper, this);
case SOURCE:
// Load data from the network
return new SourceGenerator(decodeHelper, this);
case FINISHED:
return null;
default:
throw new IllegalStateException("Unrecognized stage: "+ stage); }}Copy the codeThe way to get loaded data is returned to runWrapped(), called
DecodeJob.java
private void runGenerators(a) {
currentThread = Thread.currentThread();
startFetchTime = LogTime.getLogTime();
boolean isStarted = false;
while(! isCancelled && currentGenerator ! =null
// This is where the load data is actually called
&& !(isStarted = currentGenerator.startNext())) {
stage = getNextStage(stage);
currentGenerator = getNextGenerator();
if (stage == Stage.SOURCE) {
reschedule();
return; ...}}}Copy the code3.4 Obtaining Data from the disk cache
CurrentGenerator. StartNext () to get the data, there are two is disk cache ResourceCacheGenerator match width was obtained from the disk cache, DataCacheGenerator derives from the disk cache
3.4.1 Obtaining the Cache with the matching width and height from the disk
ResourceCacheGenerator.java
public boolean startNext(a) { List<Key> sourceIds = helper.getCacheKeys(); ... the List < Class <? >> resourceClasses = helper.getRegisteredResourceClasses(); ...while (modelLoaders == null| |! hasNextModelLoader()) { resourceClassIndex++;if (resourceClassIndex >= resourceClasses.size()) {
sourceIdIndex++;
if (sourceIdIndex >= sourceIds.size()) {
return false;
}
resourceClassIndex = 0; } Key sourceId = sourceIds.get(sourceIdIndex); Class<? > resourceClass = resourceClasses.get(resourceClassIndex);// The type to be convertedTransformation<? > transformation = helper.getTransformation(resourceClass);// PMD.AvoidInstantiatingObjectsInLoops Each iteration is comparatively expensive anyway,
// we only run until the first one succeeds, the loop runs for only a limited
// number of iterations on the order of 10-20 in the worst case.
// The current cache key
currentKey =
new ResourceCacheKey( // NOPMD AvoidInstantiatingObjectsInLoops
helper.getArrayPool(),
sourceId,
helper.getSignature(),
helper.getWidth(),
helper.getHeight(),
transformation,
resourceClass,
helper.getOptions());
// Get the file from key
cacheFile = helper.getDiskCache().get(currentKey);
if(cacheFile ! =null) {
sourceKey = sourceId;
modelLoaders = helper.getModelLoaders(cacheFile);
modelLoaderIndex = 0;
}
}
loadData = null;
boolean started = false;
while(! started && hasNextModelLoader()) { ModelLoader<File, ? > modelLoader = modelLoaders.get(modelLoaderIndex++); loadData = modelLoader.buildLoadData( cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());if(loadData ! =null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
started = true;
// Use fetcher to load data
loadData.fetcher.loadData(helper.getPriority(), this); }}return started;
}
Copy the code3.4.2 Obtaining cache from disk
DataCacheGenerator.java
public boolean startNext(a) {
while (modelLoaders == null| |! hasNextModelLoader()) { sourceIdIndex++;if (sourceIdIndex >= cacheKeys.size()) {
return false;
}
Key sourceId = cacheKeys.get(sourceIdIndex);
// PMD.AvoidInstantiatingObjectsInLoops The loop iterates a limited number of times
// and the actions it performs are much more expensive than a single allocation.
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
Key originalKey = new DataCacheKey(sourceId, helper.getSignature());
cacheFile = helper.getDiskCache().get(originalKey);
if(cacheFile ! =null) {
this.sourceKey = sourceId;
modelLoaders = helper.getModelLoaders(cacheFile);
modelLoaderIndex = 0;
}
}
loadData = null;
boolean started = false;
while(! started && hasNextModelLoader()) { ModelLoader<File, ? > modelLoader = modelLoaders.get(modelLoaderIndex++); loadData = modelLoader.buildLoadData( cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());if(loadData ! =null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
started = true;
// Load data from fetcher
loadData.fetcher.loadData(helper.getPriority(), this); }}return started;
}
Copy the codeGet pictures from the Internet
4.1 Obtaining cache from the Network
CurrentGenerator. StartNext () to get the data, the realization of the network is the SourceGenerator class
SourceGenerator.java
@Override
public boolean startNext(a) {
if(dataToCache ! =null) {
Object data = dataToCache;
dataToCache = null;
cacheData(data);
}
// Start fetching data directly if there is any in the cache
if(sourceCacheGenerator ! =null && sourceCacheGenerator.startNext()) {
return true;
}
sourceCacheGenerator = null;
loadData = null;
boolean started = false;
while(! started && hasNextModelLoader()) { loadData = helper.getLoadData().get(loadDataListIndex++);if(loadData ! =null
&& (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
|| helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
started = true;
// Start network request datastartNextLoad(loadData); }}return started;
}
// Start using the network to get data
private void startNextLoad(finalLoadData<? > toStart) {
loadData.fetcher.loadData(
helper.getPriority(),
new DataCallback<Object>() {
@Override
public void onDataReady(@Nullable Object data) {
if(isCurrentRequest(toStart)) { onDataReadyInternal(toStart, data); }}@Override
public void onLoadFailed(@NonNull Exception e) {
if(isCurrentRequest(toStart)) { onLoadFailedInternal(toStart, e); }}}); }Copy the codeFetcher this fetcher has many implementation classes. The network implementation class is HttpUrlFetcher, which calls loadData to loadData
HttpUrlFetcher.java
public void loadData(
@NonNull Priority priority, @NonNull DataCallback<? super InputStream> callback) {
long startTime = LogTime.getLogTime();
try {
// Use HttpURLConnection by default for network requests
InputStream result = loadDataWithRedirects(glideUrl.toURL(), 0.null, glideUrl.getHeaders());
// The callback was successfully downloaded
callback.onDataReady(result);
} catch(IOException e) {...// Download failed
callback.onLoadFailed(e);
} finally{...}}Copy the codeFive picture download after successful callback
5.1 Successful Network Callback
SourceGenerator.java
private void startNextLoad(finalLoadData<? > toStart) {
loadData.fetcher.loadData(
helper.getPriority(),
new DataCallback<Object>() {
@Override
public void onDataReady(@Nullable Object data) {
if (isCurrentRequest(toStart)) {
// The network request is successfully callbackonDataReadyInternal(toStart, data); }}@Override
public void onLoadFailed(@NonNull Exception e) {
if(isCurrentRequest(toStart)) { onLoadFailedInternal(toStart, e); }}}); }Copy the codeSourceGenerator.java
void onDataReadyInternal(LoadData
loadData, Object data) {
DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
if(data ! =null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
dataToCache = data;
// We might be being called back on someone else's thread. Before doing anything, we should
// reschedule to get back onto Glide's thread.
cb.reschedule();
} else {
// Continue calling the callbackcb.onDataFetcherReady( loadData.sourceKey, data, loadData.fetcher, loadData.fetcher.getDataSource(), originalKey); }}Copy the codeDecodeJob.java
public void onDataFetcherReady( Key sourceKey, Object data, DataFetcher
fetcher, DataSource dataSource, Key attemptedKey) {
this.currentSourceKey = sourceKey;
this.currentData = data;
this.currentFetcher = fetcher;
this.currentDataSource = dataSource;
this.currentAttemptingKey = attemptedKey;
if(Thread.currentThread() ! = currentThread) {// Call back to Glide call thread
runReason = RunReason.DECODE_DATA;
// Callback This is what creates DecodeJob. It's EngineJob, callback
callback.reschedule(this);
} else {
GlideTrace.beginSection("DecodeJob.decodeFromRetrievedData");
try {
// The onResourceReady of the EngineJob is called
decodeFromRetrievedData();
} finally{ GlideTrace.endSection(); }}}Copy the codeDecodeJob.java
private void decodeFromRetrievedData(a) {··· Resource<R> Resource =null;
try {
resource = decodeFromData(currentFetcher, currentData, currentDataSource);
} catch (GlideException e) {
e.setLoggingDetails(currentAttemptingKey, currentDataSource);
throwables.add(e);
}
if(resource ! =null) {
// Call EngineJob, callback
notifyEncodeAndRelease(resource, currentDataSource);
} else{ runGenerators(); }}Copy the codeDecodeJob.java
private void notifyEncodeAndRelease(Resource<R> resource, DataSource dataSource) {
if (resource instanceofInitializable) { ((Initializable) resource).initialize(); }...// Call EngineJob, callbacknotifyComplete(result, dataSource); ...}Copy the codeAt this point, the onResourceReady method that calls the EngineJob is invoked
DecodeJob.java
private void notifyComplete(Resource<R> resource, DataSource dataSource) {
setNotifiedOrThrow();
callback.onResourceReady(resource, dataSource);
}
Copy the codeEngineJob.java
public void onResourceReady(Resource<R> resource, DataSource dataSource) {
synchronized (this) {
this.resource = resource;
this.dataSource = dataSource;
}
notifyCallbacksOfResult();
}
Copy the code
void notifyCallbacksOfResult(a) {...// Call the callback
engineJobListener.onEngineJobComplete(this, localKey, localResource);
for (final ResourceCallbackAndExecutor entry : copy) {
// Perform the callback
entry.executor.execute(new CallResourceReady(entry.cb));
}
decrementPendingCallbacks();
}
Copy the codeExecute the CallResourceReadyde run method
CallResourceReady.java
public void run(a) {
// Make sure we always acquire the request lock, then the EngineJob lock to avoid deadlock
// (b/136032534).
/ / lock
synchronized (cb.getLock()) {
synchronized (EngineJob.this) {
if (cbs.contains(cb)) {
// Acquire for this particular callback.
// Add a referenceengineResource.acquire(); callCallbackOnResourceReady(cb); removeCallback(cb); } decrementPendingCallbacks(); }}}Copy the codeEngineJob.java
void callCallbackOnResourceReady(ResourceCallback cb) {
try {
// This is overly broad, some Glide code is actually called here, but it's much
// simpler to encapsulate here than to do so at the actual call point in the
// Request implementation.
cb.onResourceReady(engineResource, dataSource);
} catch (Throwable t) {
throw newCallbackException(t); }}Copy the codeCb. OnResourceReady (engineResource, dataSource); The cb is final ResourceCallbacksAndExecutors CBS = new ResourceCallbacksAndExecutors (). He is a few storage monitored successfully callbacks and actuators, his assignment is waitForExistingOrStartNewJob in Engine
Engine.java
private <R> LoadStatus waitForExistingOrStartNewJob(
GlideContext glideContext,
Object model,
Key signature,
int width,
intheight, Class<? > resourceClass, Class<R> transcodeClass, Priority priority, DiskCacheStrategy diskCacheStrategy, Map<Class<? >, Transformation<? >> transformations,boolean isTransformationRequired,
boolean isScaleOnlyOrNoTransform,
Options options,
boolean isMemoryCacheable,
boolean useUnlimitedSourceExecutorPool,
boolean useAnimationPool,
boolean onlyRetrieveFromCache,
ResourceCallback cb,
Executor callbackExecutor,
EngineKey key,
long startTime) { EngineJob<? > current = jobs.get(key, onlyRetrieveFromCache);if(current ! =null) {
// Add callback and actuatorcurrent.addCallback(cb, callbackExecutor); ...return new LoadStatus(cb, current);
}
EngineJob<R> engineJob =
engineJobFactory.build(
key,
isMemoryCacheable,
useUnlimitedSourceExecutorPool,
useAnimationPool,
onlyRetrieveFromCache);
DecodeJob<R> decodeJob =
decodeJobFactory.build(
glideContext,
model,
key,
signature,
width,
height,
resourceClass,
transcodeClass,
priority,
diskCacheStrategy,
transformations,
isTransformationRequired,
isScaleOnlyOrNoTransform,
onlyRetrieveFromCache,
options,
engineJob);
jobs.put(key, engineJob);
// Add callback and actuatorengineJob.addCallback(cb, callbackExecutor); engineJob.start(decodeJob); ...return new LoadStatus(cb, engineJob);
}
Copy the codeThis ResourceCallback type cb is passed in from Engine’s load method, engine.Load () is called onSizeReady() in SingleRequest, and onSizeReady implements ResourceCallback
SingleRequest.java
public void onSizeReady(int width, int height) {
stateVerifier.throwIfRecycled();
synchronized(requestLock) {... loadStatus = engine. The load (glideContext, model, requestOptions getSignature (),this.width,
this.height,
requestOptions.getResourceClass(),
transcodeClass,
priority,
requestOptions.getDiskCacheStrategy(),
requestOptions.getTransformations(),
requestOptions.isTransformationRequired(),
requestOptions.isScaleOnlyOrNoTransform(),
requestOptions.getOptions(),
requestOptions.isMemoryCacheable(),
requestOptions.getUseUnlimitedSourceGeneratorsPool(),
requestOptions.getUseAnimationPool(),
requestOptions.getOnlyRetrieveFromCache(),
// This is ResourceCallback
this, callbackExecutor); ...}}Copy the codeThe SingleRequest onResourceReady
SingleRequest.java
public void onResourceReady(Resource
resource, DataSource dataSource) { stateVerifier.throwIfRecycled(); Resource<? > toRelease =null;
try {
synchronized (requestLock) {
loadStatus = null;
if (resource == null) {.../ / error
onLoadFailed(exception);
return;
}
Object received = resource.get();
if (received == null| |! TranscodeClass. IsAssignableFrom (received) getClass ())) {... onLoadFailed (exception);return;
}
if(! canSetResource()) { toRelease = resource;this.resource = null;
// We can't put the status to complete before asking canSetResource().
status = Status.COMPLETE;
return;
}
// Call processing dataonResourceReady((Resource<R>) resource, (R) received, dataSource); }}finally {
if(toRelease ! =null) { engine.release(toRelease); }}}Copy the codeSingleRequest.java
private void onResourceReady(Resource<R> resource, R result, DataSource dataSource) {
// We must call isFirstReadyResource before setting status.
boolean isFirstResource = isFirstReadyResource();
// Status succeeded
status = Status.COMPLETE;
this.resource = resource;
···
isCallingCallbacks = true;
try {
boolean anyListenerHandledUpdatingTarget = false;
if(requestListeners ! =null) {
for (RequestListener<R> listener : requestListeners) {
anyListenerHandledUpdatingTarget |=
// The listener callback is completelistener.onResourceReady(result, model, target, dataSource, isFirstResource); } } anyListenerHandledUpdatingTarget |= targetListener ! =null
// The targetListener call succeeded
&& targetListener.onResourceReady(result, model, target, dataSource, isFirstResource);
if(! anyListenerHandledUpdatingTarget) { Transition<?super R> animation = animationFactory.build(dataSource, isFirstResource);
// Call target successfully. This target is the target we set externallytarget.onResourceReady(result, animation); }}finally {
isCallingCallbacks = false;
}
notifyLoadSuccess();
}
Copy the codeSix summarize
1. After the image is loaded, the image will be fetched from memory, and the image will have a counter marking the number of references. 2, the active cache is a Map
type, the current View is displayed, the memory cache is LruCache