Glide是一个高效、开源、 Android设备上的媒体管理框架,它遵循BSD、MIT以及Apache 2.0协议发布。Glide具有获取、解码和展示视频剧照、图片、动画等功能,它还有灵活的API,这些API使开发者能够将Glide应用在几乎任何网络协议栈里。创建Glide的主要目的有两个,一个是实现平滑的图片列表滚动效果,另一个是支持远程图片的获取、大小调整和展示。近日,Glide 3.0发布,现已提供jar包下载,同时还支持使用Gradle以及Maven进行构建。该版本包括很多值得关注的新功能,如支持Gif 动画和视频剧照解码、智能的暂停和重新开始请求、支持缩略图等,具体新增功能如下如下:GIF动画的解码:通过调用Glide.with(context).load(“图片路径“)方法,GIF动画图片可以自动显示为动画效果。如果想有更多的控制,还可以使用Glide.with(context).load(“图片路径“).asBitmap()方法加载静态图片,使用Glide.with(context).load(“图片路径“).asGif()方法加载动画图片

1.本地视频剧照的解码:通过调用Glide.with(context).load(“图片路径“)方法,Glide能够支持Android设备中的所有视频剧照的加载和展示

2.缩略图的支持:为了减少在同一个view组件里同时加载多张图片的时间,可以调用Glide.with(context).load(“图片路径“).thumbnail(“缩略比例“).into(“view组件“)方法加载一个缩略图,还可以控制thumbnail()中的参数的大小,以控制显示不同比例大小的缩略图

3.Activity生命周期的集成:当Activity暂停和重启时,Glide能够做到智能的暂停和重新开始请求,并且当Android设备的连接状态变化时,所有失败的请求能够自动重新请求
4.转码的支持:Glide的toBytes() 和transcode() 两个方法可以用来获取、解码和变换背景图片,并且transcode() 方法还能够改变图片的样式
5.动画的支持:新增支持图片的淡入淡出动画效果(调用crossFade()方法)和查看动画的属性的功能
6.OkHttp和Volley的支持:默认选择HttpUrlConnection作为网络协议栈,还可以选择OkHttp和Volley作为网络协议

7.其他功能:如在图片加载过程中,使用Drawables对象作为占位符、图片请求的优化、图片的宽度和高度可重新设定、缩略图和原图的缓存等功能

Glide.class

利用这个方法可以获得一个RequestManager对象.

RequestManager.class

这个类主要是用来处理低内存的时候的处理;管理请求,比如请求的开始,暂停,结束;还有通过加载方法获得一个DrawableTypeRequest对象。

低内存处理方法:

管理请求的方法:与activity或者fragment的生命周期同步。

加载的方法:

load方法都是设置了一个泛型,最后都调用了:

DrawableRequestBuilder.class

  1. @Override
  2. public DrawableRequestBuilder<ModelType> load(ModelType model) {
  3. super.load(model);
  4. return this;
  5. }

接着调用了GenericRequestBuilder类里面的方法,就是设置加载的参数到GenericRequestBuilder的this.model里:

GenericRequestBuilder.class

  1. public GenericRequestBuilder<ModelType, DataType, ResourceType, TranscodeType> load(ModelType model) {
  2. this.model = model;
  3. isModelSet = true;
  4. return this;
  5. }

这里接触了两个类,一个是GenericRequestBuilder,一个是DrawableRequestBuilder。

由GenericRequestBuilder得四种泛型参数可以看出, 这个类提供了加载各种资源的方法,是各种资源请求构建类的父类:

通过以上方法来加载缩略图。

第一个是对原数据的解码。

第二个是对磁盘缓存的数据进行解码。

第三个是对请求的数据进行编码,然后存到缓存里,之后从缓存中拿出的时候要通过解码。

设置磁盘缓存的内容,DiskCacheStrategy类是个枚举类,他提供了四个参数:

  1. /** Caches with both {@link #SOURCE} and {@link #RESULT}. */
  2. ALL(true, true),
  3. /** Saves no data to cache. */
  4. NONE(false, false),
  5. /** Saves just the original data to cache. */
  6. SOURCE(true, false),
  7. /** Saves the media item after all transformations to cache. */
  8. RESULT(false, true);

all:缓存源资源和转换后的资源

none:不作任何磁盘缓存

source:缓存源资源

result:缓存转换后的资源

  1. priority(Priority priority)

设置当次请求的优先级。

  1. transform(Transformation<ResourceType>... transformations)

设置对资源进行转换的接口:

对于加载一般的图片到Imageview中,默认提供了CenterCrop和FitCenter两种实现。

  1. dontTransform()

移除当前的转换。

  1. transcoder(ResourceTranscoder<ResourceType, TranscodeType> transcoder)

设置资源加载完成后的动画,不包括从内存缓存中获取。

  1. dontAnimate()

移除设置的动画。

  1. placeholder(int resourceId)
  2. placeholder(Drawable drawable)

设置加载的时候的图片。

  1. error(int resourceId)
  2. error(Drawable drawable)

设置加载失败后显示的图片

  1. listener(RequestListener<? super ModelType, TranscodeType> requestListener)

设置加载监听。

这个监听接口中有两个回调方法:

  1. skipMemoryCache(boolean skip)

设置是否跳过内存缓存。

  1. override(int width, int height)

设置加载资源图片的像素宽高。

  1. signature(Key signature)
  1. load(ModelType model)

设置要加载的内容。

通过上面的方法开启加载,中间的方法直接加载到view上,前后的方法用于预加载。

预加载,真正调用的是上面的两个into方法。

接着看子类DrawableRequestBuilder里面特有的方法:

DrawableRequestBuilder类不仅继承了父类GenericRequestBuilder里面的方法,还显示了BitmapOptions和DrawableOptions两个接口:

一个是控制bitmap的显示的位置或者大小(就是bitmap的转换),一个是控制图片显示出来时候的动画效果(不包括从内存中获取的图片资源)。接着看这些方法的具体实现:

  1. public DrawableRequestBuilder<ModelType> centerCrop() {
  2. return transform(glide.getDrawableCenterCrop());
  3. }
  1. public DrawableRequestBuilder<ModelType> fitCenter() {
  2. return transform(glide.getDrawableFitCenter());
  3. }

将Glide中两个BitmapTransformation进行包装后,通过间接调用父类的transform设置到父类的transformation属性中。

  1. public final DrawableRequestBuilder<ModelType> crossFade() {
  2. super.animate(new DrawableCrossFadeFactory<GlideDrawable>());
  3. return this;
  4. }

而设置淡入淡出效果其实是设置了默认动画实现的DrawableCrossFadeFactory类到父类animationFactory属性中。

  1. public <Y extends Target<TranscodeType>> Y into(Y target) {
  2. Util.assertMainThread();
  3. if (target == null) {
  4. throw new IllegalArgumentException("You must pass in a non null Target");
  5. }
  6. if (!isModelSet) {
  7. throw new IllegalArgumentException("You must first set a model (try #load())");
  8. }
  9. Request previous = target.getRequest();
  10. if (previous != null) {
  11. previous.clear();
  12. requestTracker.removeRequest(previous);
  13. previous.recycle();
  14. }
  15. Request request = buildRequest(target);
  16. target.setRequest(request);
  17. lifecycle.addListener(target);
  18. requestTracker.runRequest(request);
  19. return target;
  20. }

这里构建好request的是个GenericRequest类型,然后就通过requestTracker.runRequest(request);来调用GenericRequest里的begin方法:

  1. @Override
  2. public void begin() {
  3. startTime = LogTime.getLogTime();
  4. if (model == null) {
  5. onException(null);
  6. return;
  7. }
  8. status = Status.WAITING_FOR_SIZE;
  9. if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
  10. onSizeReady(overrideWidth, overrideHeight);
  11. } else {
  12. target.getSize(this);
  13. }
  14. if (!isComplete() && !isFailed() && canNotifyStatusChanged()) {
  15. target.onLoadStarted(getPlaceholderDrawable());
  16. }
  17. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  18. logV("finished run method in " + LogTime.getElapsedMillis(startTime));
  19. }
  20. }

这里的target.getSize(this);最终也是调用onSizeReady()方法:

  1. public void onSizeReady(int width, int height) {
  2. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  3. logV("Got onSizeReady in " + LogTime.getElapsedMillis(startTime));
  4. }
  5. if (status != Status.WAITING_FOR_SIZE) {
  6. return;
  7. }
  8. status = Status.RUNNING;
  9. width = Math.round(sizeMultiplier * width);
  10. height = Math.round(sizeMultiplier * height);
  11. ModelLoader<A, T> modelLoader = loadProvider.getModelLoader();
  12. final DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(model, width, height);
  13. if (dataFetcher == null) {
  14. onException(new Exception("Got null fetcher from model loader"));
  15. return;
  16. }
  17. ResourceTranscoder<Z, R> transcoder = loadProvider.getTranscoder();
  18. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  19. logV("finished setup for calling load in " + LogTime.getElapsedMillis(startTime));
  20. }
  21. loadedFromMemoryCache = true;
  22. loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
  23. priority, isMemoryCacheable, diskCacheStrategy, this);
  24. loadedFromMemoryCache = resource != null;
  25. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  26. logV("finished onSizeReady in " + LogTime.getElapsedMillis(startTime));
  27. }
  28. }

接着调用了Engine类的load方法,这个类就是加载数据的引擎类:

  1. public <T, Z, R> LoadStatus load(Key signature, int width, int height, DataFetcher<T> fetcher,
  2. DataLoadProvider<T, Z> loadProvider, Transformation<Z> transformation, ResourceTranscoder<Z, R> transcoder,
  3. Priority priority, boolean isMemoryCacheable, DiskCacheStrategy diskCacheStrategy, ResourceCallback cb) {
  4. Util.assertMainThread();
  5. long startTime = LogTime.getLogTime();
  6. final String id = fetcher.getId();
  7. EngineKey key = keyFactory.buildKey(id, signature, width, height, loadProvider.getCacheDecoder(),
  8. loadProvider.getSourceDecoder(), transformation, loadProvider.getEncoder(),
  9. transcoder, loadProvider.getSourceEncoder());
  10. EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
  11. if (cached != null) {
  12. cb.onResourceReady(cached);
  13. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  14. logWithTimeAndKey("Loaded resource from cache", startTime, key);
  15. }
  16. return null;
  17. }
  18. EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
  19. if (active != null) {
  20. cb.onResourceReady(active);
  21. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  22. logWithTimeAndKey("Loaded resource from active resources", startTime, key);
  23. }
  24. return null;
  25. }
  26. EngineJob current = jobs.get(key);
  27. if (current != null) {
  28. current.addCallback(cb);
  29. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  30. logWithTimeAndKey("Added to existing load", startTime, key);
  31. }
  32. return new LoadStatus(cb, current);
  33. }
  34. EngineJob engineJob = engineJobFactory.build(key, isMemoryCacheable);
  35. DecodeJob<T, Z, R> decodeJob = new DecodeJob<T, Z, R>(key, width, height, fetcher, loadProvider, transformation,
  36. transcoder, diskCacheProvider, diskCacheStrategy, priority);
  37. EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
  38. jobs.put(key, engineJob);
  39. engineJob.addCallback(cb);
  40. engineJob.start(runnable);
  41. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  42. logWithTimeAndKey("Started new load", startTime, key);
  43. }
  44. return new LoadStatus(cb, engineJob);
  45. }

这个方法会先从内存缓存中去获取,没有就构建一个EngineJob引擎任务类,这个类会将一个任务(runnable对象)提交到线程池中,然后线程池经过一系列的调度,调用了EngineRunnable对象的run方法:

  1. public void run() {
  2. if (isCancelled) {
  3. return;
  4. }
  5. Exception exception = null;
  6. Resource<?> resource = null;
  7. try {
  8. resource = decode();
  9. } catch (Exception e) {
  10. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  11. Log.v(TAG, "Exception decoding", e);
  12. }
  13. exception = e;
  14. }
  15. if (isCancelled) {
  16. if (resource != null) {
  17. resource.recycle();
  18. }
  19. return;
  20. }
  21. if (resource == null) {
  22. onLoadFailed(exception);
  23. } else {
  24. onLoadComplete(resource);
  25. }
  26. }

这里的decode()方法会先从磁盘缓存中去取数据,如果没有就源资源(网络中下载的资源)中获取:

  1. private Resource<?> decode() throws Exception {
  2. if (isDecodingFromCache()) {
  3. return decodeFromCache();
  4. } else {
  5. return decodeFromSource();
  6. }
  7. }

1.首先来看从磁盘缓存中获取资源:

  1. private Resource<?> decodeFromCache() throws Exception {
  2. Resource<?> result = null;
  3. try {
  4. result = decodeJob.decodeResultFromCache();
  5. } catch (Exception e) {
  6. if (Log.isLoggable(TAG, Log.DEBUG)) {
  7. Log.d(TAG, "Exception decoding result from cache: " + e);
  8. }
  9. }
  10. if (result == null) {
  11. result = decodeJob.decodeSourceFromCache();
  12. }
  13. return result;
  14. }

这里有两个方法:第一个,decodeJob.decodeResultFromCache(),如果设置缓存的是DiskCacheStrategy.RESULT,那么磁盘缓存中缓存的是transformed后的结果,所以就会调用该方法:

  1. public Resource<Z> decodeResultFromCache() throws Exception {
  2. if (!diskCacheStrategy.cacheResult()) {
  3. return null;
  4. }
  5. long startTime = LogTime.getLogTime();
  6. Resource<T> transformed = loadFromCache(resultKey);
  7. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  8. logWithTimeAndKey("Decoded transformed from cache", startTime);
  9. }
  10. startTime = LogTime.getLogTime();
  11. Resource<Z> result = transcode(transformed);
  12. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  13. logWithTimeAndKey("Transcoded transformed from cache", startTime);
  14. }
  15. return result;
  16. }

这里首先通过loadFromCache(resultKey)方法从磁盘缓存文件中decode已经经过transformed的资源(默认是使用UnitTransformation,在这里面没有做任何的资源转换),然后调用transcode(transformed)方法:该方法是把从磁盘decode出来的资源通过transcoder.transcode(transformed)来进行转换(这个方法是用来转换资源的类型用的,默认是使用UnitTranscoder,没有做任何操作)

第二个,decodeJob.decodeSourceFromCache(),如果设置缓存的是DiskCacheStrategy.SOURCE,那么磁盘缓存中缓存的是原始数据,所以就会调用该方法:

  1. public Resource<Z> decodeSourceFromCache() throws Exception {
  2. if (!diskCacheStrategy.cacheSource()) {
  3. return null;
  4. }
  5. long startTime = LogTime.getLogTime();
  6. Resource<T> decoded = loadFromCache(resultKey.getOriginalKey());
  7. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  8. logWithTimeAndKey("Decoded source from cache", startTime);
  9. }
  10. return transformEncodeAndTranscode(decoded);
  11. }

这里首先从磁盘缓存中decode原数据,然后再调用transformEncodeAndTranscode(decoded)方法先进行transform,transform后会通过writeTransformedToCache(transformed);将经过转换的资源存入磁盘缓存,然后再进行transcode:

  1. private Resource<Z> transformEncodeAndTranscode(Resource<T> decoded) {
  2. long startTime = LogTime.getLogTime();
  3. Resource<T> transformed = transform(decoded);
  4. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  5. logWithTimeAndKey("Transformed resource from source", startTime);
  6. }
  7. writeTransformedToCache(transformed);
  8. startTime = LogTime.getLogTime();
  9. Resource<Z> result = transcode(transformed);
  10. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  11. logWithTimeAndKey("Transcoded transformed from source", startTime);
  12. }
  13. return result;
  14. }

2.再来看从源资源获取资源:

  1. private Resource<?> decodeFromSource() throws Exception {
  2. return decodeJob.decodeFromSource();
  3. }
  1. public Resource<Z> decodeFromSource() throws Exception {
  2. Resource<T> decoded = decodeSource();
  3. return transformEncodeAndTranscode(decoded);
  4. }

这里调用了decodeSource(),这个方法是从网络中获取data资源:

  1. private Resource<T> decodeSource() throws Exception {
  2. Resource<T> decoded = null;
  3. try {
  4. long startTime = LogTime.getLogTime();
  5. final A data = fetcher.loadData(priority);
  6. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  7. logWithTimeAndKey("Fetched data", startTime);
  8. }
  9. if (isCancelled) {
  10. return null;
  11. }
  12. decoded = decodeFromSourceData(data);
  13. } finally {
  14. fetcher.cleanup();
  15. }
  16. return decoded;
  17. }

获取到网络资源后调用decodeFromSourceData(data)方法:

  1. private Resource<T> decodeFromSourceData(A data) throws IOException {
  2. final Resource<T> decoded;
  3. if (diskCacheStrategy.cacheSource()) {
  4. decoded = cacheAndDecodeSourceData(data);
  5. } else {
  6. long startTime = LogTime.getLogTime();
  7. decoded = loadProvider.getSourceDecoder().decode(data, width, height);
  8. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  9. logWithTimeAndKey("Decoded from source", startTime);
  10. }
  11. }
  12. return decoded;
  13. }

这个方法里通过diskCacheStrategy.cacheSource()判断资源是否是将源数据保存在磁盘里,如果是则会调用cacheAndDecodeSourceData(A data):

  1. private Resource<T> cacheAndDecodeSourceData(A data) throws IOException {
  2. long startTime = LogTime.getLogTime();
  3. SourceWriter<A> writer = new SourceWriter<A>(loadProvider.getSourceEncoder(), data);
  4. diskCacheProvider.getDiskCache().put(resultKey.getOriginalKey(), writer);
  5. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  6. logWithTimeAndKey("Wrote source to cache", startTime);
  7. }
  8. startTime = LogTime.getLogTime();
  9. Resource<T> result = loadFromCache(resultKey.getOriginalKey());
  10. if (Log.isLoggable(TAG, Log.VERBOSE) && result != null) {
  11. logWithTimeAndKey("Decoded source from cache", startTime);
  12. }
  13. return result;
  14. }

这里先将原数据保存在磁盘缓存里,然后再decode出来。

但是如果不需要保存源数据,就直接decode源数据:

  1. private Resource<T> decodeFromSourceData(A data) throws IOException {
  2. final Resource<T> decoded;
  3. if (diskCacheStrategy.cacheSource()) {
  4. decoded = cacheAndDecodeSourceData(data);
  5. } else {
  6. long startTime = LogTime.getLogTime();
  7. decoded = loadProvider.getSourceDecoder().decode(data, width, height);
  8. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  9. logWithTimeAndKey("Decoded from source", startTime);
  10. }
  11. }
  12. return decoded;
  13. }

decodeSource()方法执行完之后,接着执行transformEncodeAndTranscode(decoded):

  1. private Resource<Z> transformEncodeAndTranscode(Resource<T> decoded) {
  2. long startTime = LogTime.getLogTime();
  3. Resource<T> transformed = transform(decoded);
  4. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  5. logWithTimeAndKey("Transformed resource from source", startTime);
  6. }
  7. writeTransformedToCache(transformed);
  8. startTime = LogTime.getLogTime();
  9. Resource<Z> result = transcode(transformed);
  10. if (Log.isLoggable(TAG, Log.VERBOSE)) {
  11. logWithTimeAndKey("Transcoded transformed from source", startTime);
  12. }
  13. return result;
  14. }

这里是将直接从源数据decode出来资源后,经过transform的转换,然后将transform后的资源存进磁盘缓存,然后在经过transcode方法来进行资源类型的转换(默认是使用UnitTranscoder,没有做任何操作)。还是提供逻辑图,一目了然吧:

这个是基本流程图:

使用方法:

1.设置的不是imageview,可以用SimpleTarget来接受,然后在回调里面设置view的现实(但是缺少目标view的设置,似乎在列表中会出现错乱)

  1. Glide.with(StaggeredGridViewDemo.this).load(mImages.get(arg0).getPic()).asBitmap().override(250, 250).into(new SimpleTarget<Bitmap>() {
  2. @Override
  3. public void onResourceReady(Bitmap arg0, GlideAnimation<? super Bitmap> arg1) {
  4. Log.i("llj", "arg0.getWidth()+arg0.getHeight()" + arg0.getWidth() + arg0.getHeight());
  5. holder.textView.setBackgroundDrawable(new BitmapDrawable(arg0));
  6. }
  7. });

但是override(250, 250)方法没有起作用:

也可以通过SimpleTarget的构造函数传参数:

  1. Glide.with(StaggeredGridViewDemo.this).load(mImages.get(arg0).getPic()).asBitmap().into(new SimpleTarget<Bitmap>(250, 250) {
  2. @Override
  3. public void onResourceReady(Bitmap arg0, GlideAnimation<? super Bitmap> arg1) {
  4. Log.i("llj", "arg0.getWidth()+arg0.getHeight()" + arg0.getWidth() + ";" + arg0.getHeight());
  5. // holder.textView.setBackgroundDrawable(new BitmapDrawable(arg0));
  6. }
  7. });

但是SimpleTarget的构造函数穿进去的参数也没有起作用:

2.设置预加载:(可以提前将资源加载到磁盘缓存中,默认的缓存目录是data\data下的250M空间,自己可以根据需求更改)

  1. final PreloadTarget<Bitmap> target = PreloadTarget.obtain(250, 250);
  2. Glide.with(StaggeredGridViewDemo.this).load(mImages.get(arg0).getPic()).asBitmap().listener(new RequestListener<String, Bitmap>() {
  3. @Override
  4. public boolean onException(Exception e, String model, Target<Bitmap> target, boolean isFirstResource) {
  5. return false;
  6. }
  7. @Override
  8. public boolean onResourceReady(Bitmap resource, String model, Target<Bitmap> target, boolean isFromMemoryCache, boolean isFirstResource) {
  9. Log.i("llj", "arg0.getWidth()+arg0.getHeight()" + resource.getWidth() + resource.getHeight());
  10. return false;
  11. }
  12. }).into(target);

这里在PreloadTarget中设置的像素的缩放还是没有用:

  1. final PreloadTarget<Bitmap> target = PreloadTarget.obtain(0, 0);
  2. Glide.with(StaggeredGridViewDemo.this).load(mImages.get(arg0).getPic()).asBitmap().override(250, 250).listener(new RequestListener<String, Bitmap>() {
  3. @Override
  4. public boolean onException(Exception e, String model, Target<Bitmap> target, boolean isFirstResource) {
  5. return false;
  6. }
  7. @Override
  8. public boolean onResourceReady(Bitmap resource, String model, Target<Bitmap> target, boolean isFromMemoryCache, boolean isFirstResource) {
  9. Log.i("llj", "arg0.getWidth()+arg0.getHeight()" + resource.getWidth() + resource.getHeight());
  10. return false;
  11. }
  12. }).into(target);

这里在override(250, 250)设置依然没有作用:

3.加载到imageview上

  1. Glide.with(StaggeredGridViewDemo.this).load(mImages.get(arg0).getPic()).asBitmap().override(250, 250).listener(new RequestListener<String, Bitmap>() {
  2. @Override
  3. public boolean onException(Exception e, String model, Target<Bitmap> target, boolean isFirstResource) {
  4. return false;
  5. }
  6. @Override
  7. public boolean onResourceReady(Bitmap resource, String model, Target<Bitmap> target, boolean isFromMemoryCache, boolean isFirstResource) {
  8. Log.i("llj", "arg0.getWidth()+arg0.getHeight()" + resource.getWidth() + resource.getHeight());
  9. return false;
  10. }
  11. }).into(holder.imageview);

拿到的Bitmap的宽高经过了转换,但转换后的比例并不是250:250:

但是如果设置了centerCrop():

而用Picasso转换后的图片是250:250:

  1. Picasso.with(StaggeredGridViewDemo.this).load(mImages.get(arg0).getPic()).resize(250, 250).into(new com.squareup.picasso.Target() {
  2. @Override
  3. public void onPrepareLoad(Drawable arg0) {
  4. }
  5. @Override
  6. public void onBitmapLoaded(Bitmap arg0, LoadedFrom arg1) {
  7. Log.i("llj", "arg0.getWidth()+arg0.getHeight()" + arg0.getWidth() + ";" + arg0.getHeight());
  8. }
  9. @Override
  10. public void onBitmapFailed(Drawable arg0) {
  11. }
  12. });

说明两者的按比例缩放的方法不一样!

Android的媒体管理框架:Glide的更多相关文章

  1. Android图片缓存之Glide进阶

    前言: 前面学习了Glide的简单使用(Android图片缓存之初识Glide),今天来学习一下Glide稍微复杂一点的使用. 图片缓存相关博客地址: Android图片缓存之Bitmap详解 And ...

  2. Android的电源管理框架

    Android的电源管理框架 Android通过锁和定时器来切换系统的状态,使系统的功耗降至最低,整个系统的电源管理框架分成五个部分:应用层,framework层,JNI层,HAL层和内核层.电源管理 ...

  3. Android media媒体库分析之:MediaProvider

    在做Android媒体应用程序时(Audio.Image.Video)需要对Android的媒体提供者(MediaProvider)做详细的分析,下面记录一下我的收获: 一.获取MediaProvid ...

  4. Android 的媒体路由功能应用与框架解析

    一.功能描述 Android 的媒体路由API被设计用来允许多种媒体(视频.音乐.图片)在与ANDROID设备连接(无线或有线)的辅助设备(如电视.立体声.家庭戏院系统.音乐播放机)上显示和播放,使用 ...

  5. Android图片缓存框架Glide

    Android图片缓存框架Glide Glide是Google提供的一个组件.它具有获取.解码和展示视频剧照.图片.动画等功能.它提供了灵活的API,帮助开发者将Glide应用在几乎任何网络协议栈中. ...

  6. Android轻量级日志管理框架

    代码地址如下:http://www.demodashi.com/demo/12134.html ViseLog Android 轻量级日志框架,使用森林对象维护不同的日志树进行日志输出,可以是Logc ...

  7. 如何扫描出Android系统媒体库中视频文件

    Android系统启动时会去扫描系统文件,并将系统支持的视频文件(mp4,3gp,wmv)扫描到媒体库(MediaStore)中,下面代码演示如何获得这些文件的信息: publicstatic Lis ...

  8. 【Android - 框架】之Glide的使用

    一.Glide简介: Glide是Google官方推荐的一个图片加载和缓存的开源库,它不仅能实现平滑的图片列表滚动效果,还支持远程图片的获取.大小调整和展示,并且可以加载GIF图片.Glide相比与U ...

  9. Android笔记之使用Glide加载网络图片、下载图片

    Glide简介 不想说太多,真的很方便:P)可以节省我不少时间 GitHub地址:https://github.com/bumptech/glide 加载网络图片到ImageView Glide.wi ...

随机推荐

  1. Comparable接口与Comparator接口的区别

    1. Comparator 和 Comparable 相同的地方 他们都是java的一个接口, 并且是用来对自定义的class比较大小的, 什么是自定义class: 如 public class Pe ...

  2. AS与.net的交互——加载web上的xml

    最近搞了个私活,需要用as去加载一个网站的xml,不过本人as也不咋滴,就去看看怎么玩,看完之后也蛮简单的. 由于业务上比较复杂,就随便说个小例子吧. 很多时候,为了页面区域更加灵活,生动,有吸引力, ...

  3. (转,有改动)测试网页响应时间的shell脚本[需要curl支持]

    用法及返回结果如下: [root@myserver01 tmp]# sh test_web.sh -n500 http://www.baidu.com Request url: http://www. ...

  4. MSSQL OPTION语句详解

    一些联合表查询语句,这些表里都建立有索引.在没有加 option ( force order ) 前,整个查询费时40多秒,但 单独表 查询基本不到1秒.查看查询计划后发现查询过程是从table n开 ...

  5. addrinfo 结构

    typedef struct addrinfo {int             ai_flags;int            ai_family;int             ai_sockty ...

  6. Android ScrollView中的组件设置android:layout_height="fill_parent"不起作用的解决办法

    例子,在ScrollView下加入的组件,无论如何也不能自动扩展到屏幕高度. 布局文件. [html] <?xml version="1.0" encoding=" ...

  7. node命令

  8. openwrt修改flash大小

    前言 默认openwrt trunk编译出来的flash大小为8M,但是我们手上的板子可能flash大小更大,本文以MT7620a为例,将其flash大小由8M修改为16M或者32M 增加dts文件 ...

  9. 谈谈Lucene和Solr索引存目录

    在Lucene中,有几种索引存放模式呢?用过的人可能记得SimpleFSDirectory.MMapDirectory.NIOFSDirectory.RAMDirectory这四种.新版本的通过FSD ...

  10. MMORPG大型游戏设计与开发(part2 of net)

    网络第二部分的将要给大家描述的是网络代码方面的设计,从基础的代码讲起,了解详细的网络模块构架. 没有放出整个源代码,是因为其中还有许多不足的地方,不过想必大家应该也能猜想出这个项目源码的地址了.不过对 ...