Z - The type of resource that this target will receive.public abstract class SimpleTarget<Z> extends BaseTarget<Z>
Target base class with default (usually no-op)
implementations of non essential methods that allows the caller to specify an exact width/height.
Typically use cases look something like this:
Target target =
Glide.with(fragment)
.asBitmap()
.load("http://somefakeurl.com/fakeImage.jpeg")
.apply(fitCenterTransform())
.into(new SimpleTarget(250, 250) {
@Override
public void onResourceReady(Bitmap resource, GlideAnimation glideAnimation) {
// Do something with bitmap here.
}
});
}
// At some later point, clear the Target to release the resources, prevent load queues from
// blowing out proportion, and to improve load times for future requests:
Glide.with(fragment).clear(target);
Warning! this class is extremely prone to mis-use. Use SimpleTarget only as a last
resort. ViewTarget or a subclass of ViewTarget is almost always a better choice.
Don't forget to clear instances of this class!. If you must use this class, keep in
mind that unlike ViewTarget it is not safe to load into new instances of this class
repeatedly if every instance updates the same underlying View or caller. If you need to
load into the same View or caller repeatedly using this class, always retain a reference
to the previous instance and either call RequestManager.clear(Target)
on the old instance before starting a new load or you must re-use the old instance for the new
load. Glide's RequestBuilder.into(Target) method returns the
Target instance you provided to make retaining a reference to the Target as easy
as possible. That said, you must wait until you're completely finished with the resource before
calling RequestManager.clear(Target) and you should always null out
references to any loaded resources in Target.onLoadCleared(Drawable).
Always try to provide a size when using this class. Use
SimpleTarget(int, int) whenever possible with values that are not
Target.SIZE_ORIGINAL. Using Target.SIZE_ORIGINAL is unsafe if you're loading
large images or are running your application on older or memory constrained devices because it
can cause Glide to load very large images into memory. In some cases those images may throw
OutOfMemoryError and in others they may exceed the texture limit for the device, which
will prevent them from being rendered. Providing a valid size allows Glide to downsample large
images, which can avoid issues with texture size or memory limitations. You don't have to worry
about providing a size in most cases if you use ViewTarget so prefer ViewTarget
over this class whenver possible.
SIZE_ORIGINAL| Constructor and Description |
|---|
SimpleTarget()
Constructor for the target that uses
Target.SIZE_ORIGINAL as the target width and
height. |
SimpleTarget(int width,
int height)
Constructor for the target that takes the desired dimensions of the decoded and/or transformed
resource.
|
| Modifier and Type | Method and Description |
|---|---|
void |
getSize(SizeReadyCallback cb)
Immediately calls the given callback with the sizes given in the constructor.
|
void |
removeCallback(SizeReadyCallback cb)
Removes the given callback from the pending set if it's still retained.
|
getRequest, onDestroy, onLoadCleared, onLoadFailed, onLoadStarted, onStart, onStop, setRequestclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitonResourceReadypublic SimpleTarget()
Target.SIZE_ORIGINAL as the target width and
height.public SimpleTarget(int width,
int height)
width - The width in pixels of the desired resource.height - The height in pixels of the desired resource.public final void getSize(@NonNull SizeReadyCallback cb)
cb - The callback that must be called when the size of the target has been determinedpublic void removeCallback(@NonNull SizeReadyCallback cb)
Targetcb - The callback to remove.