Android高效安全加载图片的方法详解

creates bitmap objects from various sources, including files, streams,and byte-arrays.

 /**
 * synonym for opening the given resource and calling
 * {@link #decoderesourcestream}.
 *
 * @param res the resources object containing the image data
 * @param id the resource id of the image data
 * @param opts null-ok; options that control downsampling and whether the
 *  image should be completely decoded, or just is size returned.
 * @return the decoded bitmap, or null if the image data could not be
 *  decoded, or, if opts is non-null, if opts requested only the
 *  size be returned (in opts.outwidth and opts.outheight)
 * @throws illegalargumentexception if {@link bitmapfactory.options#inpreferredconfig}
 *  is {@link android.graphics.bitmap.config#hardware}
 *  and {@link bitmapfactory.options#inmutable} is set, if the specified color space
 *  is not {@link colorspace.model#rgb rgb}, or if the specified color space's transfer
 *  function is not an {@link colorspace.rgb.transferparameters icc parametric curve}
 */
 public static bitmap decoderesource(resources res, int id, options opts) {

 /**
 * if set to true, the decoder will return null (no bitmap), but
 * the <code>out...</code> fields will still be set, allowing the caller to
 * query the bitmap without having to allocate the memory for its pixels.
 */
 public boolean injustdecodebounds;

 bitmapfactory.options options = new bitmapfactory.options();
 // 指定在解析图片文件时，仅仅解析边缘信息而不创建 bitmap 对象。
 options.injustdecodebounds = true;
 // r.drawable.test 是使用的 2560x1920 的测试图片资源文件。
 bitmapfactory.decoderesource(getresources(), r.drawable.test, options);
 int width = options.outwidth;
 int height = options.outheight;
 log.i(tag, "width: " + width + ", height: " + height);

 /**
 * if set to a value > 1, requests the decoder to subsample the original
 * image, returning a smaller image to save memory. the sample size is
 * the number of pixels in either dimension that correspond to a single
 * pixel in the decoded bitmap. for example, insamplesize == 4 returns
 * an image that is 1/4 the width/height of the original, and 1/16 the
 * number of pixels. any value <= 1 is treated the same as 1. note: the
 * decoder uses a final value based on powers of 2, any other value will
 * be rounded down to the nearest power of 2.
 */
 public int insamplesize;

 /**
 * @param originwidth the width of the origin bitmap
 * @param originheight the height of the origin bitmap
 * @param deswidth the max width of the desired bitmap
 * @param desheight the max height of the desired bitmap
 * @return the optimal sample size to make sure the size of bitmap is not more than the desired.
 */
 public static int calculatesamplesize(int originwidth, int originheight, int deswidth, int desheight) {
 int samplesize = 1;
 int width = originwidth;
 int height = originheight;
 while((width / samplesize) > deswidth && (height / samplesize) > desheight) {
  samplesize *= 2;
 }
 return samplesize;
 }

 int samplesize = bitmapcompressor.calculatesamplesize(2560, 1920, 100, 100);
 log.i(tag, "samplesize: " + samplesize);

 public static bitmap compressbitmapresource(resources res, int resid, int insamplesize) {
 bitmapfactory.options options = new bitmapfactory.options();
 options.injustdecodebounds = false;
 options.insamplesize = insamplesize;
 return bitmapfactory.decoderesource(res, resid, options);
 }

 /**
 * bitmapregiondecoder can be used to decode a rectangle region from an image.
 * bitmapregiondecoder is particularly useful when an original image is large and
 * you only need parts of the image.
 *
 * <p>to create a bitmapregiondecoder, call newinstance(...).
 * given a bitmapregiondecoder, users can call decoderegion() repeatedly
 * to get a decoded bitmap of the specified region.
 *
 */
 public final class bitmapregiondecoder { ... }

 /**
 * create a bitmapregiondecoder from an input stream.
 * the stream's position will be where ever it was after the encoded data
 * was read.
 * currently only the jpeg and png formats are supported.
 *
 * @param is the input stream that holds the raw data to be decoded into a
 *  bitmapregiondecoder.
 * @param isshareable if this is true, then the bitmapregiondecoder may keep a
 *   shallow reference to the input. if this is false,
 *   then the bitmapregiondecoder will explicitly make a copy of the
 *   input data, and keep that. even if sharing is allowed,
 *   the implementation may still decide to make a deep
 *   copy of the input data. if an image is progressively encoded,
 *   allowing sharing may degrade the decoding speed.
 * @return bitmapregiondecoder, or null if the image data could not be decoded.
 * @throws ioexception if the image format is not supported or can not be decoded.
 *
 * <p class="note">prior to {@link android.os.build.version_codes#kitkat},
 * if {@link inputstream#marksupported is.marksupported()} returns true,
 * <code>is.mark(1024)</code> would be called. as of
 * {@link android.os.build.version_codes#kitkat}, this is no longer the case.</p>
 */
 public static bitmapregiondecoder newinstance(inputstream is,
  boolean isshareable) throws ioexception { ... }

 /**
 * decodes a rectangle region in the image specified by rect.
 *
 * @param rect the rectangle that specified the region to be decode.
 * @param options null-ok; options that control downsampling.
 *  inpurgeable is not supported.
 * @return the decoded bitmap, or null if the image data could not be
 *  decoded.
 * @throws illegalargumentexception if {@link bitmapfactory.options#inpreferredconfig}
 *  is {@link android.graphics.bitmap.config#hardware}
 *  and {@link bitmapfactory.options#inmutable} is set, if the specified color space
 *  is not {@link colorspace.model#rgb rgb}, or if the specified color space's transfer
 *  function is not an {@link colorspace.rgb.transferparameters icc parametric curve}
 */
 public bitmap decoderegion(rect rect, bitmapfactory.options options) { ... }

 // 解析得到原图的长宽值，方便后面进行局部显示时指定需要显示的区域。
 bitmapfactory.options options = new bitmapfactory.options();
 options.injustdecodebounds = true;
 bitmapfactory.decoderesource(getresources(), r.drawable.test, options);
 int width = options.outwidth;
 int height = options.outheight;

 try {
 // 创建局部解析器 
 inputstream inputstream = getresources().openrawresource(r.drawable.test);
 bitmapregiondecoder decoder = bitmapregiondecoder.newinstance(inputstream,false);
 
 // 指定需要显示的矩形区域，这里要显示的原图的左上 1/4 区域。
 rect rect = new rect(0, 0, width / 2, height / 2);

 // 创建位图配置，这里使用 rgb_565，每个像素占 2 字节。
 bitmapfactory.options regionoptions = new bitmapfactory.options();
 regionoptions.inpreferredconfig = bitmap.config.rgb_565;
 
 // 创建得到指定区域的 bitmap 对象并进行显示。
 bitmap regionbitmap = decoder.decoderegion(rect,regionoptions);
 imageview imageview = (imageview) findviewbyid(r.id.main_image);
 imageview.setimagebitmap(regionbitmap);
 } catch (exception e) {
 e.printstacktrace();
 }

/**
 * a cache that holds strong references to a limited number of values. each time
 * a value is accessed, it is moved to the head of a queue. when a value is
 * added to a full cache, the value at the end of that queue is evicted and may
 * become eligible for garbage collection.
 */
public class lrucache<k, v> { ... }

 // 获得进程可以使用的最大内存量
 int maxmemory = (int) runtime.getruntime().maxmemory();
 
 mcache = new lrucache<string, bitmap>(maxmemory / 4) {
  @override
  protected int sizeof(string key, bitmap value) {
   return value.getbytecount();
  }
 };

 public bitmap get(string key) {
  bitmap bitmap = mcache.get(key);
  if (bitmap != null) {
   return bitmap;
  } else {
   new bitmapasynctask().execute(key);
   return null;
  }
 }

 private class bitmapasynctask extends asynctask<string, void, bitmap> {
  @override
  protected bitmap doinbackground(string... url) {
   bitmap bitmap = getbitmapfromurl(url[0]);
   if (bitmap != null) {
    mcache.put(url[0],bitmap);
   }
   return bitmap;
  }

  private bitmap getbitmapfromurl(string url) {
   bitmap bitmap = null;
   // 在这里要利用给定的 url 信息从网络获取 bitmap 信息.
   return bitmap;
  }
 }