Example #1
0
 /** Returns the in memory size of the given {@link Bitmap} in bytes. */
 @TargetApi(Build.VERSION_CODES.KITKAT)
 public static int getBitmapByteSize(Bitmap bitmap) {
   // The return value of getAllocationByteCount silently changes for recycled bitmaps from the
   // internal buffer size to row bytes * height. To avoid random inconsistencies in caches, we
   // instead assert here.
   if (bitmap.isRecycled()) {
     throw new IllegalStateException(
         "Cannot obtain size for recycled Bitmap: "
             + bitmap
             + "["
             + bitmap.getWidth()
             + "x"
             + bitmap.getHeight()
             + "] "
             + bitmap.getConfig());
   }
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
     // Workaround for KitKat initial release NPE in Bitmap, fixed in MR1. See issue #148.
     try {
       return bitmap.getAllocationByteCount();
     } catch (NullPointerException e) {
       // Do nothing.
     }
   }
   return bitmap.getHeight() * bitmap.getRowBytes();
 }
Example #2
0
 /** Returns the in memory size of the given {@link Bitmap}. */
 public static int getSize(Bitmap bitmap) {
   if (Build.VERSION.SDK_INT >= 19) {
     return bitmap.getAllocationByteCount();
   } else {
     return bitmap.getHeight() * bitmap.getRowBytes();
   }
 }
Example #3
0
 // TODO get bytes of bitmap
 private static int byteSizeOf(Bitmap bitmap) {
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
     return bitmap.getAllocationByteCount();
   } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1) {
     return bitmap.getByteCount();
   } else {
     return bitmap.getRowBytes() * bitmap.getHeight();
   }
 }
Example #4
0
 protected int a(Object obj, Bitmap bitmap)
 {
     int i;
     if (android.os.Build.VERSION.SDK_INT >= 19)
     {
         i = bitmap.getAllocationByteCount();
     } else
     {
         i = bitmap.getByteCount();
     }
     return (i + 1023) / 1024;
 }
  /**
   * Get the size in bytes of a bitmap in a BitmapDrawable. Note that from Android 4.4 (KitKat)
   * onward this returns the allocated memory size of the bitmap which can be larger than the actual
   * bitmap data byte count (in the case it was re-used).
   *
   * @param value
   * @return size in bytes
   */
  @TargetApi(VERSION_CODES.KITKAT)
  public static int getBitmapSize(BitmapDrawable value) {
    Bitmap bitmap = value.getBitmap();

    // From KitKat onward use getAllocationByteCount() as allocated bytes can potentially be
    // larger than bitmap byte count.
    if (Utils.hasKitKat()) {
      return bitmap.getAllocationByteCount();
    }

    if (Utils.hasHoneycombMR1()) {
      return bitmap.getByteCount();
    }

    // Pre HC-MR1
    return bitmap.getRowBytes() * bitmap.getHeight();
  }
Example #6
0
 /**
  * reutilizableParaInBitmap: Checa si un bitmap se puede reutilizar de acuerdo a las opciones
  * especificadas.
  *
  * @param candidato Bitmap que se va a investigar
  * @param opciones BitmapFactory.Options que el candidato debe satisfacer
  * @return true si se puede reutilizar este candidato, false de otro modo.
  */
 static boolean reutilizableParaInBitmap(Bitmap candidato, BitmapFactory.Options opciones) {
   int ancho = opciones.outWidth / opciones.inSampleSize;
   int alto = opciones.outHeight / opciones.inSampleSize;
   Bitmap.Config configuracion = candidato.getConfig();
   int bytes_por_pixel;
   // Checa cada configuracion
   if (configuracion == Bitmap.Config.ARGB_8888) {
     bytes_por_pixel = 4;
   } else if (configuracion == Bitmap.Config.RGB_565) {
     bytes_por_pixel = 2;
   } else if (configuracion == Bitmap.Config.ARGB_4444) {
     bytes_por_pixel = 2;
   } else {
     bytes_por_pixel = 1;
   }
   int conteo_bytes = ancho * alto * bytes_por_pixel;
   return conteo_bytes <= candidato.getAllocationByteCount();
 }
  /**
   * @param candidate - Bitmap to check
   * @param targetOptions - Options that have the out* value populated
   * @return true if <code>candidate</code> can be used for inBitmap re-use with <code>targetOptions
   *     </code>
   */
  @TargetApi(VERSION_CODES.KITKAT)
  private static boolean canUseForInBitmap(Bitmap candidate, BitmapFactory.Options targetOptions) {
    // BEGIN_INCLUDE(can_use_for_inbitmap)
    if (!Utils.hasKitKat()) {
      // On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
      return candidate.getWidth() == targetOptions.outWidth
          && candidate.getHeight() == targetOptions.outHeight
          && targetOptions.inSampleSize == 1;
    }

    // From Android 4.4 (KitKat) onward we can re-use if the byte size of the new bitmap
    // is smaller than the reusable bitmap candidate allocation byte count.
    int width = targetOptions.outWidth / targetOptions.inSampleSize;
    int height = targetOptions.outHeight / targetOptions.inSampleSize;
    int byteCount = width * height * getBytesPerPixel(candidate.getConfig());
    return byteCount <= candidate.getAllocationByteCount();
    // END_INCLUDE(can_use_for_inbitmap)
  }
Example #8
0
  private static boolean canUseForInBitmap(Bitmap candidate, BitmapFactory.Options targetOptions) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
      // From Android 4.4 (KitKat) onward we can re-use if the byte size
      // of
      // the new bitmap is smaller than the reusable bitmap candidate
      // allocation byte count.
      int width = targetOptions.outWidth / targetOptions.inSampleSize;
      int height = targetOptions.outHeight / targetOptions.inSampleSize;
      int byteCount = width * height * getBytesPerPixel(candidate.getConfig());
      return byteCount <= candidate.getAllocationByteCount();
    }

    // On earlier versions, the dimensions must match exactly and the
    // inSampleSize must be 1
    return candidate.getWidth() == targetOptions.outWidth
        && candidate.getHeight() == targetOptions.outHeight
        && targetOptions.inSampleSize == 1;
  }
Example #9
0
  /** @return size in bytes of the underlying bitmap */
  @SuppressLint("NewApi")
  public static int getSizeInBytes(@Nullable Bitmap bitmap) {
    if (bitmap == null) {
      return 0;
    }

    // There's a known issue in KitKat where getAllocationByteCount() can throw an NPE. This was
    // apparently fixed in MR1: http://bit.ly/1IvdRpd. So we do a version check here, and
    // catch any potential NPEs just to be safe.
    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {
      try {
        return bitmap.getAllocationByteCount();
      } catch (NullPointerException npe) {
        // Swallow exception and try fallbacks.
      }
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1) {
      return bitmap.getByteCount();
    }

    // Estimate for earlier platforms.
    return bitmap.getWidth() * bitmap.getRowBytes();
  }
Example #10
0
 protected int sizeOf(String key, Bitmap value) {
   if (VERSION.SDK_INT >= 19) {
     return value.getAllocationByteCount() / 1024;
   }
   return (value.getRowBytes() * value.getHeight()) / 1024;
 }