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
|
package com.bumptech.glide;
import android.content.Context;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.load.model.ModelLoader;
import com.bumptech.glide.load.resource.transcode.ResourceTranscoder;
import com.bumptech.glide.load.resource.transcode.UnitTranscoder;
import com.bumptech.glide.manager.Lifecycle;
import com.bumptech.glide.manager.RequestTracker;
import com.bumptech.glide.provider.DataLoadProvider;
import com.bumptech.glide.provider.FixedLoadProvider;
import com.bumptech.glide.provider.LoadProvider;
import com.bumptech.glide.request.FutureTarget;
import com.bumptech.glide.request.target.Target;
import java.io.File;
/**
* A class for handling requests to load a generic resource type or transcode the generic resource type into another
* generic resource type.
*
* <p>
* Warning - It is <em>not</em> safe to use this builder after calling <code>into()</code>, it may be pooled and
* reused.
* </p>
*
* @param <ModelType> The type of the model used to retrieve data.
* @param <DataType> The type of data retrieved.
* @param <ResourceType> The type of resource to be decoded from the the data.
*/
public class GenericTranscodeRequest<ModelType, DataType, ResourceType>
extends GenericRequestBuilder<ModelType, DataType, ResourceType, ResourceType> implements DownloadOptions {
private final ModelLoader<ModelType, DataType> modelLoader;
private final Class<DataType> dataClass;
private final Class<ResourceType> resourceClass;
private final RequestManager.OptionsApplier optionsApplier;
private static <A, T, Z, R> LoadProvider<A, T, Z, R> build(Glide glide, ModelLoader<A, T> modelLoader,
Class<T> dataClass, Class<Z> resourceClass, ResourceTranscoder<Z, R> transcoder) {
DataLoadProvider<T, Z> dataLoadProvider = glide.buildDataProvider(dataClass, resourceClass);
return new FixedLoadProvider<A, T, Z, R>(modelLoader, transcoder, dataLoadProvider);
}
GenericTranscodeRequest(
Class<ResourceType> transcodeClass, GenericRequestBuilder<ModelType, ?, ?, ?> other,
ModelLoader<ModelType, DataType> modelLoader, Class<DataType> dataClass, Class<ResourceType> resourceClass,
RequestManager.OptionsApplier optionsApplier) {
super(build(other.glide, modelLoader, dataClass, resourceClass, UnitTranscoder.<ResourceType>get()),
transcodeClass, other);
this.modelLoader = modelLoader;
this.dataClass = dataClass;
this.resourceClass = resourceClass;
this.optionsApplier = optionsApplier;
}
GenericTranscodeRequest(Context context, Glide glide, ModelType model, ModelLoader<ModelType, DataType> modelLoader,
Class<DataType> dataClass, Class<ResourceType> resourceClass, RequestTracker requestTracker,
Lifecycle lifecycle, RequestManager.OptionsApplier optionsApplier) {
super(context, model, build(glide, modelLoader, dataClass, resourceClass, UnitTranscoder.<ResourceType>get()),
resourceClass, glide, requestTracker, lifecycle);
this.modelLoader = modelLoader;
this.dataClass = dataClass;
this.resourceClass = resourceClass;
this.optionsApplier = optionsApplier;
}
/**
* Adds a transcoder to this request to transcode from the resource type to the given transcode type.
*
* @param transcoder The transcoder to use.
* @param transcodeClass The class of the resource type that will be transcoded to.
* @param <TranscodeType> The type of the resource that will be transcoded to.
* @return A new request builder to set options for the transcoded load.
*/
public <TranscodeType> GenericRequestBuilder<ModelType, DataType, ResourceType, TranscodeType> transcode(
ResourceTranscoder<ResourceType, TranscodeType> transcoder, Class<TranscodeType> transcodeClass) {
LoadProvider<ModelType, DataType, ResourceType, TranscodeType> loadProvider = build(glide, modelLoader,
dataClass, resourceClass, transcoder);
return optionsApplier.apply(model,
new GenericRequestBuilder<ModelType, DataType, ResourceType, TranscodeType>(loadProvider,
transcodeClass, this));
}
/**
* {@inheritDoc}
*/
public <Y extends Target<File>> Y downloadOnly(Y target) {
return getDownloadOnlyRequest().into(target);
}
/**
* {@inheritDoc}
*/
public FutureTarget<File> downloadOnly(int width, int height) {
return getDownloadOnlyRequest().into(width, height);
}
private GenericRequestBuilder<ModelType, DataType, File, File> getDownloadOnlyRequest() {
ResourceTranscoder<File, File> transcoder = UnitTranscoder.get();
DataLoadProvider<DataType, File> dataLoadProvider = glide.buildDataProvider(dataClass, File.class);
FixedLoadProvider<ModelType, DataType, File, File> fixedLoadProvider =
new FixedLoadProvider<ModelType, DataType, File, File>(modelLoader, transcoder, dataLoadProvider);
return optionsApplier.apply(model, new GenericRequestBuilder<ModelType, DataType, File, File>(fixedLoadProvider,
File.class, this))
.priority(Priority.LOW)
.diskCacheStrategy(DiskCacheStrategy.SOURCE)
.skipMemoryCache(true);
}
}
|
