将Base64字符串解码并编码为Bitmap时出现OutOfMemoryError

7 回答

• 13

  当从文件中显示 ImageView ImageView 时，首先在 BitmapHelper.decodeFile(picturePath, 200, 200, true) 的帮助下解码它，这将返回压缩的 Bitmap ，这样在编码此Bitmap时，您可以处理高分辨率图像以及高达100 MB文件的大尺寸图像 .

  解码文件后，将其设置为 ImageView ，并使用 BitmapHelper class获取压缩图像上方的 Base64 字符串形式;从 ImageView 获取 Bitmap （即已经被压缩）并使用 ImageBase64.encodeTobase64(bitmap) 这将再次压缩文件并在 Encoding a Bitmap 时处理 OutOfMemory 异常 .

  对于 decoding ，首先将 Base64String 写入设备内存中的文件 . 然后读取块中的 Bytes 并解码 ByteArray ，这将使您的位图在您的内存中 . 在使用 decodeFile() 方法缩小此位图之后，您将从 Base64String 压缩 Bitmap

  我搜索了各种各样的博客并发布了帖子，并从中发布了我最合适的代码并将它们组合成一个以使其更可靠 . 尝试下面的代码，使用meory管理更快地 encoding 和 decoding .

  解码 Base64String

  Bitmap bitmap = ImageBase64.decodeBase64(base64ImageStr,MainActivity.this);
  imageView.setImageBitmap(bitmap);
  bitmap = null;
  System.gc();
  

  编码 Bitmap 试试这个：

  imageView.setImageBitmap(BitmapHelper.decodeFile(picturePath, 200, 200, true));
  
  Bitmap bitmap = ((BitmapDrawable)imageView.getDrawable()).getBitmap();              
  base64ImageStr = ImageBase64.encodeTobase64(bitmap);
  

  试试这个代码 ImageBase64

  public class ImageBase64 {
  
      private ImageBase64() {
          super();
      }
      private static Context appContext;
  
      public static String encodeTobase64(Bitmap image) {
  
           ByteArrayOutputStream baos=new  ByteArrayOutputStream();
           image.compress(Bitmap.CompressFormat.JPEG,100, baos);
              byte [] b=baos.toByteArray();
              String temp=null;
              try{
              System.gc();
              temp=Base64.encodeToString(b, Base64.DEFAULT);
              }catch(Exception e){
                  e.printStackTrace();
              }catch(OutOfMemoryError e){
                  baos=new  ByteArrayOutputStream();
                  image.compress(Bitmap.CompressFormat.JPEG,50, baos);
                  b=baos.toByteArray();
                  temp=Base64.encodeToString(b, Base64.DEFAULT);
                  Log.e("EWN", "Out of memory error catched");
              }
              return temp;
      }
  
  
      public static Bitmap decodeBase64(String input,Context context) {
          byte[] decodedByte = Base64.decode(input, 0);
  
          appContext = context;
          Boolean isSDPresent = android.os.Environment
                  .getExternalStorageState().equals(
                          android.os.Environment.MEDIA_MOUNTED);
  
          File sdCardDirectory;
          if (isSDPresent) {
              // yes SD-card is present
               sdCardDirectory = new File(
                          Environment
                                  .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
                          "IMG");
  
                  if (!sdCardDirectory.exists()) {
                      if (!sdCardDirectory.mkdirs()) {
                          Log.d("MySnaps", "failed to create directory");
  
                      }
                  }
          } else {
              // Sorry
              sdCardDirectory = new File(context.getCacheDir(),"");
          }
  
  
  
          String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
                  .format(new Date());
  
          Random rand = new Random();
  
          // nextInt is normally exclusive of the top value,
          // so add 1 to make it inclusive
          int randomNum = rand.nextInt((1000 - 0) + 1) + 0;
  
          String nw = "IMG_" + timeStamp + randomNum+".txt";
          File image = new File(sdCardDirectory, nw);
  
  
  
          // Encode the file as a PNG image.
          FileOutputStream outStream;
          try {
  
  
              outStream = new FileOutputStream(image);
              outStream.write(input.getBytes());
  
              outStream.flush();
              outStream.close();
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          } catch (IOException e) {
              e.printStackTrace();
          }
  
  
          Log.i("Compress bitmap path", image.getPath());
          Bitmap bitmap;
          try{
          bitmap = BitmapFactory.decodeByteArray(decodedByte, 0, decodedByte.length);
          }catch(OutOfMemoryError e){
              e.printStackTrace();
              InputStream is = context.getResources().openRawResource(R.drawable.default_profile_pic);
              bitmap  = BitmapFactory.decodeStream(is);  
  
          }catch (Exception e) {
              // TODO: handle exception
              e.printStackTrace();
              bitmap=null;
          }
  
          return bitmap;//BitmapFactory.decodeByteArray(decodedByte, 0, decodedByte.length);
          //return decodeFile(image); 
      }
  
      private static Bitmap decodeFile(File f){
          try {
              //Decode image size
              BitmapFactory.Options o = new BitmapFactory.Options();
              o.inJustDecodeBounds = true;
              BitmapFactory.decodeStream(new FileInputStream(f),null,o);
  
              //The new size we want to scale to
              final int REQUIRED_SIZE=70;
  
              //Find the correct scale value. It should be the power of 2.
              int scale=1;
              while(o.outWidth/scale>=REQUIRED_SIZE && o.outHeight/scale>=REQUIRED_SIZE)
                  scale*=2;
  
              //Decode with inSampleSize
              BitmapFactory.Options o2 = new BitmapFactory.Options();
              o2.inSampleSize=scale;
  
              Bitmap bmp = BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
  
  
              Boolean isSDPresent = android.os.Environment
                      .getExternalStorageState().equals(
                              android.os.Environment.MEDIA_MOUNTED);
              File sdCardDirectory;
              if (isSDPresent) {
                  // yes SD-card is present
                   sdCardDirectory = new File(
                              Environment
                                      .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
                              "IMG");
  
                      if (!sdCardDirectory.exists()) {
                          if (!sdCardDirectory.mkdirs()) {
                              Log.d("MySnaps", "failed to create directory");
  
                          }
                      }
              } else {
                  // Sorry
                  sdCardDirectory = new File(appContext.getCacheDir(),"");
              }
  
  
  
              String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
                      .format(new Date());
  
              Random rand = new Random();
  
              // nextInt is normally exclusive of the top value,
              // so add 1 to make it inclusive
              int randomNum = rand.nextInt((1000 - 0) + 1) + 0;
  
              String nw = "IMG_" + timeStamp + randomNum+".png";
              File image = new File(sdCardDirectory, nw);
  
  
  
              FileOutputStream out = null;
              try {
                  out = new FileOutputStream(image);
                  bmp.compress(Bitmap.CompressFormat.PNG, 100, out); // bmp is your Bitmap instance
                  // PNG is a lossless format, the compression factor (100) is ignored
              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  try {
                      if (out != null) {
                          out.close();
                      }
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
  
              String pathNew =compressImage(image.getAbsolutePath());
              Uri uri = Uri.parse(pathNew);   
              Bitmap bitmap=null ;
              try {
                   bitmap     = MediaStore.Images.Media.getBitmap(appContext.getContentResolver(),uri);
              } catch (IOException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              }
  
              return bitmap;
          } catch (FileNotFoundException e) {}
          return null;
      }
  
  
      public static String compressImage(String imageUri) {
  
          String filePath = imageUri;//getRealPathFromURI(imageUri);
          Bitmap scaledBitmap = null;
  
          BitmapFactory.Options options = new BitmapFactory.Options();
  
  //      by setting this field as true, the actual bitmap pixels are not loaded in the memory. Just the bounds are loaded. If
  //      you try the use the bitmap here, you will get null.
          options.inJustDecodeBounds = true;
          Bitmap bmp = BitmapFactory.decodeFile(filePath, options);
  
          int actualHeight = options.outHeight;
          int actualWidth = options.outWidth;
  
  //      max Height and width values of the compressed image is taken as 816x612
  
          float maxHeight = 816.0f;
          float maxWidth = 612.0f;
          float imgRatio = actualWidth / actualHeight;
          float maxRatio = maxWidth / maxHeight;
  
  //      width and height values are set maintaining the aspect ratio of the image
  
          if (actualHeight > maxHeight || actualWidth > maxWidth) {
              if (imgRatio < maxRatio) {               imgRatio = maxHeight / actualHeight;                actualWidth = (int) (imgRatio * actualWidth);               actualHeight = (int) maxHeight;             } else if (imgRatio > maxRatio) {
                  imgRatio = maxWidth / actualWidth;
                  actualHeight = (int) (imgRatio * actualHeight);
                  actualWidth = (int) maxWidth;
              } else {
                  actualHeight = (int) maxHeight;
                  actualWidth = (int) maxWidth;
  
              }
          }
  
  //      setting inSampleSize value allows to load a scaled down version of the original image
  
          options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);
  
  //      inJustDecodeBounds set to false to load the actual bitmap
          options.inJustDecodeBounds = false;
  
  //      this options allow android to claim the bitmap memory if it runs low on memory
          options.inPurgeable = true;
          options.inInputShareable = true;
          options.inTempStorage = new byte[16 * 1024];
  
          try {
  //          load the bitmap from its path
              bmp = BitmapFactory.decodeFile(filePath, options);
          } catch (OutOfMemoryError exception) {
              exception.printStackTrace();
  
          }
          try {
              scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight,Bitmap.Config.ARGB_8888);
          } catch (OutOfMemoryError exception) {
              exception.printStackTrace();
          }
  
          float ratioX = actualWidth / (float) options.outWidth;
          float ratioY = actualHeight / (float) options.outHeight;
          float middleX = actualWidth / 2.0f;
          float middleY = actualHeight / 2.0f;
  
          Matrix scaleMatrix = new Matrix();
          scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
  
          Canvas canvas = new Canvas(scaledBitmap);
          canvas.setMatrix(scaleMatrix);
          canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
  
  //      check the rotation of the image and display it properly
          ExifInterface exif;
          try {
              exif = new ExifInterface(filePath);
  
              int orientation = exif.getAttributeInt(
                      ExifInterface.TAG_ORIENTATION, 0);
              Log.d("EXIF", "Exif: " + orientation);
              Matrix matrix = new Matrix();
              if (orientation == 6) {
                  matrix.postRotate(90);
                  Log.d("EXIF", "Exif: " + orientation);
              } else if (orientation == 3) {
                  matrix.postRotate(180);
                  Log.d("EXIF", "Exif: " + orientation);
              } else if (orientation == 8) {
                  matrix.postRotate(270);
                  Log.d("EXIF", "Exif: " + orientation);
              }
              scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                      scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix,
                      true);
          } catch (IOException e) {
              e.printStackTrace();
          }
  
          FileOutputStream out = null;
          String filename = getFilename();
          try {
              out = new FileOutputStream(filename);
  
  //          write the compressed bitmap at the destination specified by filename.
              scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
  
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          }
  
          return filename;
  
      }
  
      public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
          final int height = options.outHeight;
          final int width = options.outWidth;
          int inSampleSize = 1;
  
          if (height > reqHeight || width > reqWidth) {
              final int heightRatio = Math.round((float) height/ (float) reqHeight);
              final int widthRatio = Math.round((float) width / (float) reqWidth);
              inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;      }       final float totalPixels = width * height;       final float totalReqPixelsCap = reqWidth * reqHeight * 2;       while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
              inSampleSize++;
          }
  
          return inSampleSize;
      }
  
      public static String getFilename() {
          /*File file = new File(Environment.getExternalStorageDirectory().getPath(), "IMG/Images");
          if (!file.exists()) {
              file.mkdirs();
          }
          String uriSting = (file.getAbsolutePath() + "/" + System.currentTimeMillis() + ".jpg");
          */
  
  
          Boolean isSDPresent = android.os.Environment
                  .getExternalStorageState().equals(
                          android.os.Environment.MEDIA_MOUNTED);
  
          File sdCardDirectory;
          if (isSDPresent) {
              // yes SD-card is present
               sdCardDirectory = new File(
                          Environment
                                  .getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES).getPath(),
                          "IMG/Images");
  
                  if (!sdCardDirectory.exists()) {
                      if (!sdCardDirectory.mkdirs()) {
                          Log.d("MySnaps", "failed to create directory");
  
                      }
                  }
          } else {
              // Sorry
              sdCardDirectory = new File(appContext.getCacheDir(),"");
          }
  
          String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
          .format(new Date());
  
          Random rand = new Random();
  
  // nextInt is normally exclusive of the top value,
  // so add 1 to make it inclusive
          int randomNum = rand.nextInt((1000 - 0) + 1) + 0;
  
          String nw = "img_" + timeStamp + randomNum+".jpg";
          File image = new File(sdCardDirectory, nw);
  
           String uriSting1 = (sdCardDirectory.getAbsolutePath() + "/" + nw);//System.currentTimeMillis() + ".jpg");
  
          return uriSting1;
  
      }
  }
  

  添加此类以处理繁重的图像

  public class BitmapHelper
  {
  
      //decodes image and scales it to reduce memory consumption
      public static Bitmap decodeFile(String bitmapFile, int requiredWidth, int requiredHeight, boolean quickAndDirty)
      {
          try
          {
              //Decode image size
              BitmapFactory.Options bitmapSizeOptions = new BitmapFactory.Options();
              bitmapSizeOptions.inJustDecodeBounds = true;
              BitmapFactory.decodeStream(new FileInputStream(bitmapFile), null, bitmapSizeOptions);
  
              // load image using inSampleSize adapted to required image size
              BitmapFactory.Options bitmapDecodeOptions = new BitmapFactory.Options();
              bitmapDecodeOptions.inTempStorage = new byte[16 * 1024];
              bitmapDecodeOptions.inSampleSize = computeInSampleSize(bitmapSizeOptions, requiredWidth, requiredHeight, false);
              bitmapDecodeOptions.inPurgeable = true;
              bitmapDecodeOptions.inDither = !quickAndDirty;
              bitmapDecodeOptions.inPreferredConfig = quickAndDirty ? Bitmap.Config.RGB_565 : Bitmap.Config.ARGB_8888;
  
              Bitmap decodedBitmap = BitmapFactory.decodeStream(new FileInputStream(bitmapFile), null, bitmapDecodeOptions);
  
              // scale bitmap to mathc required size (and keep aspect ratio)
  
              float srcWidth = (float) bitmapDecodeOptions.outWidth;
              float srcHeight = (float) bitmapDecodeOptions.outHeight;
  
              float dstWidth = (float) requiredWidth;
              float dstHeight = (float) requiredHeight;
  
              float srcAspectRatio = srcWidth / srcHeight;
              float dstAspectRatio = dstWidth / dstHeight;
  
              // recycleDecodedBitmap is used to know if we must recycle intermediary 'decodedBitmap'
              // (DO NOT recycle it right away: wait for end of bitmap manipulation process to avoid
              // java.lang.RuntimeException: Canvas: trying to use a recycled bitmap android.graphics.Bitmap@416ee7d8
              // I do not excatly understand why, but this way it's OK
  
              boolean recycleDecodedBitmap = false;
  
              Bitmap scaledBitmap = decodedBitmap;
              if (srcAspectRatio < dstAspectRatio)
              {
                  scaledBitmap = getScaledBitmap(decodedBitmap, (int) dstWidth, (int) (srcHeight * (dstWidth / srcWidth)));
                  // will recycle recycleDecodedBitmap
                  recycleDecodedBitmap = true;
              }
              else if (srcAspectRatio > dstAspectRatio)
              {
                  scaledBitmap = getScaledBitmap(decodedBitmap, (int) (srcWidth * (dstHeight / srcHeight)), (int) dstHeight);
                  recycleDecodedBitmap = true;
              }
  
              // crop image to match required image size
  
              int scaledBitmapWidth = scaledBitmap.getWidth();
              int scaledBitmapHeight = scaledBitmap.getHeight();
  
              Bitmap croppedBitmap = scaledBitmap;
  
              if (scaledBitmapWidth > requiredWidth)
              {
                  int xOffset = (scaledBitmapWidth - requiredWidth) / 2;
                  croppedBitmap = Bitmap.createBitmap(scaledBitmap, xOffset, 0, requiredWidth, requiredHeight);
                  scaledBitmap.recycle();
              }
              else if (scaledBitmapHeight > requiredHeight)
              {
                  int yOffset = (scaledBitmapHeight - requiredHeight) / 2;
                  croppedBitmap = Bitmap.createBitmap(scaledBitmap, 0, yOffset, requiredWidth, requiredHeight);
                  scaledBitmap.recycle();
              }
  
              if (recycleDecodedBitmap)
              {
                  decodedBitmap.recycle();
              }
              decodedBitmap = null;
  
              scaledBitmap = null;
              return croppedBitmap;
          }
          catch (Exception ex)
          {
              ex.printStackTrace();
          }
          return null;
      }
  
      /**
       * compute powerOf2 or exact scale to be used as {@link BitmapFactory.Options#inSampleSize} value (for subSampling)
       * 
       * @param requiredWidth
       * @param requiredHeight
       * @param powerOf2
       *            weither we want a power of 2 sclae or not
       * @return
       */
      public static int computeInSampleSize(BitmapFactory.Options options, int dstWidth, int dstHeight, boolean powerOf2)
      {
          int inSampleSize = 1;
  
          // Raw height and width of image
          final int srcHeight = options.outHeight;
          final int srcWidth = options.outWidth;
  
          if (powerOf2)
          {
              //Find the correct scale value. It should be the power of 2.
  
              int tmpWidth = srcWidth, tmpHeight = srcHeight;
              while (true)
              {
                  if (tmpWidth / 2 < dstWidth || tmpHeight / 2 < dstHeight)
                      break;
                  tmpWidth /= 2;
                  tmpHeight /= 2;
                  inSampleSize *= 2;
              }
          }
          else
          {
              // Calculate ratios of height and width to requested height and width
              final int heightRatio = Math.round((float) srcHeight / (float) dstHeight);
              final int widthRatio = Math.round((float) srcWidth / (float) dstWidth);
  
              // Choose the smallest ratio as inSampleSize value, this will guarantee
              // a final image with both dimensions larger than or equal to the
              // requested height and width.
              inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
          }
  
          return inSampleSize;
      }
  
      public static Bitmap drawableToBitmap(Drawable drawable)
      {
          if (drawable instanceof BitmapDrawable)
          {
              return ((BitmapDrawable) drawable).getBitmap();
          }
  
          Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Config.ARGB_8888);
          Canvas canvas = new Canvas(bitmap);
          drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
          drawable.draw(canvas);
  
          return bitmap;
      }
  
      public static Bitmap getScaledBitmap(Bitmap bitmap, int newWidth, int newHeight)
      {
          int width = bitmap.getWidth();
          int height = bitmap.getHeight();
          float scaleWidth = ((float) newWidth) / width;
          float scaleHeight = ((float) newHeight) / height;
  
          // CREATE A MATRIX FOR THE MANIPULATION
          Matrix matrix = new Matrix();
          // RESIZE THE BIT MAP
          matrix.postScale(scaleWidth, scaleHeight);
  
          // RECREATE THE NEW BITMAP
          Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, false);
          return resizedBitmap;
      }
  
  }
  

  回复于 2024-04-26T08:24:01+08:00
• 5

  我建议你：

  • 如果使用基于xml的协议从服务器接收数据 - 请使用 SAX parser而不是DOM .

  • 不要将整个base64字符串加载到内存中 . 使用 InputStream 将部分数据加载到 byte[] 数组中，从数组中解码Base64并通过 FileOutputStream 将结果附加到缓存文件 .

  • 使用options.inJustDecodeBounds选项可防止将满量程位图文件加载到内存中 . 例如，您可以评估所需的内存总量，并决定将其缩小 . UPD . 我注意到你已经在使用它了 .

  • 请记住您持有的对象引用并通过方法流程 . 强引用可防止GC回收内存 .

  在您的代码之后：方法 decodeBase64 在堆栈中保存 String input 参数参数， byte[] decodedByte 参考并在最后返回 BitmapFactory.decodeStream(new FileInputStream(f), null, o2) . 同时将所有这些对象保存在内存中意味着GC和内存分配的压力很大 . 作为最简单的解决方案，您可以在使用相应的对象（字符串和字节数组）之后进行引用，因此GC将能够释放它们 .

  回复于 2024-04-26T08:24:01+08:00
• 6

  试试这个伪代码：如果您有任何疑问，请告诉我

  Bitmap bmp = (Bitmap) data.getExtras().get("data");
  
          img.setImageBitmap(bmp);
          btnadd.requestFocus();
  
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          bmp.compress(Bitmap.CompressFormat.JPEG, 100, baos);
          byte[] b = baos.toByteArray();
          encodedImageString = Base64.encodeToString(b, Base64.DEFAULT);
  
          byte[] bytarray = Base64.decode(encodedImageString, Base64.DEFAULT);
          Bitmap bmimage = BitmapFactory.decodeByteArray(bytarray, 0,
                  bytarray.length);
  

  回复于 2024-04-26T08:24:01+08:00
• 17

  只需在清单文件中增加应用程序的堆大小即可 .

  android:largeHeap="true"
  
  eg:
  <application
          android:allowBackup="true"
          android:icon="@drawable/ic_launcher"
          android:label="@string/app_name"
          android:theme="@style/Theme.AppTheme"
          android:largeHeap="true" >
  

  回复于 2024-04-26T08:24:01+08:00
• 5

  您不是base64编码Bitmap实例（正如您在帖子中甚至在主题中所建议的那样），而是 String imageEncoded = Base64.encodeToString(b, Base64.DEFAULT); 中的字节数组 b . 如果要将这些字节写入文件，则字节数组'b'包含.jpg文件内容的字节 .

  您需要做的是将要上载的.jpg文件的内容直接放在字节数组中 . 然后编码该数组 .

  谷歌 android put file content in byte array . 代码已在本网站上多次发布

  回复于 2024-04-26T08:24:01+08:00
• 6

  正如greenapps建议的那样，最好避免使用Bitmap和BitmapFactory来传输文件：

  FileInputStream fis = new FileInputStream(imageFile);
  byte[] byteArray = inputStreamToByteArray(fis);
  String base64ImageSend = Base64.encodeToString(byteArray, Base64.NO_WRAP);
  

  哪里：

  /**
   * Convert an InputStream object into a byte array
   * @param inputStream The InputStream to convert
   * @return The byte[] representing the converted InputStream or null if the inputStream is null
   */
  public static byte[] inputStreamToByteArray(InputStream inputStream) throws IOException {
      if(inputStream==null) {
          return null;
      }
      ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
      int bufferSize = 1024;
      byte[] buffer = new byte[bufferSize];
  
      int len = 0;
      while ((len = inputStream.read(buffer)) != -1) {
          byteBuffer.write(buffer, 0, len);
      }
      return byteBuffer.toByteArray();
  }
  

  实际上，如Kai所述，outOfMemory问题是由于您正在解码全分辨率和高质量图像 . 避免这种情况的更好方法是对您的图像进行下采样：

  /**
   * Decode a file, representing an image, into a bitmap, trying to scale the original image if required
   * @param context The application context
   * @param file The image file
   * @param requestedWidth The requested width
   * @param requestedHeight The requested height
   * @return The decoded bitmap or null if it is not possible to decode the file parameter
   */
  public static Bitmap decodeImageFileIntoMutableBitmap(Context context, File file, int requestedWidth, int requestedHeight) {
      BitmapFactory.Options options = new BitmapFactory.Options();
      options.inJustDecodeBounds = true; // just compute size, don't create bitmap
      BitmapFactory.decodeFile(file.getAbsolutePath(), options);
      float sampleSize = computeImageScaleCoefficient(options, requestedWidth, requestedHeight);
      if (sampleSize == -1) {
          return null;
      }
      else if (sampleSize <= 1) {
          options.inSampleSize = 1;
      }
      else {
          options.inSampleSize = (int) sampleSize;
      }
      options.inJustDecodeBounds = false; // compute size and create bitmap
      /*it is possible to reduce the memory when decoding through skipping ARGB_8888 and using RGB_565 instead and inDither to true to preserve image quality.*/
      //options.inPreferredConfig = Bitmap.Config.RGB_565;
      //options.inDither = true;
      Bitmap bitmap = BitmapFactory.decodeFile(file.getAbsolutePath(), options);
      if (bitmap == null) {
          return null;
      }
      return bitmap;
  }
  
  /**
   * Find the sample coefficient <code><b>s<sub>k</sub></b>=2<sup>k</sup></code>, with <code>k &isin &#8469;</code>, such that
   * <code>min<sub>k</sub>(requestedWidth-options.outWidth&times;<b>s<sub>k</sub></b>)&gt;0</code>
   * <code>&&</code>
   * <code>min<sub>k</sub>(requestedHeight-options.outHeight&times;<b>s<sub>k</sub></b>)&gt;0</code>
   * @param options The BitmapFactory.Options instance of the original image user wants to scale
   * @param requestedWidth The requested width
   * @param requestedHeight The requested height
   * @return -1 if if there is an error trying to decode the image
   * or the sample coefficient <code><b>s<sub>k</sub></b></code>,
   * &gt;1 if the image needs to be down-sampled,
   * &lt;1 if the image needs to be up-sampled
   */
  public static float computeImageScaleCoefficient(BitmapFactory.Options options, int requestedWidth, int requestedHeight) {
      float sampleCoefficient = 1;
      int imageWidth = options.outWidth;
      int imageHeight = options.outHeight;
      if (imageWidth == -1 || imageHeight == -1) {
          return -1;
      }
      double outWidth = imageWidth;
      double outHeight = imageHeight;
      if ((outWidth > requestedWidth) || (outHeight > requestedHeight)) {
          while ((outWidth > requestedWidth) || (outHeight > requestedHeight)) {
              outWidth = Math.floor(outWidth/2.0);
              outHeight = Math.floor(outHeight/2.0);
              sampleCoefficient *= 2.0;
          }
      }
      else {
          while ((outWidth < requestedWidth) && (outHeight < requestedHeight)) {
              outWidth *= 2;
              outHeight *= 2;
              if ((outWidth <= requestedWidth) && (outHeight <= requestedHeight)) {
                  sampleCoefficient /= 2.0;
              }
          }
      }
      return sampleCoefficient;
  }
  

  回复于 2024-04-26T08:24:01+08:00
• 2

  你可以尝试这个，它应该解决你的问题 .

  基本上首先将数据保存到文件中，使用缓冲区来避免内存问题 . 之后我们检查并调整文件大小 - 直接加载调整大小的位图，再次避免内存问题 .

  从我可以想到的，你从服务器获取编码的字符串...所以你可以管理你的代码直接写入文件 .

  将数据写入文件：

  private Bitmap getBitmapThumbnail(String base64StringReceive) {
          byte[] data = Base64.decode(base64StringReceive, Base64.DEFAULT);
          File file = new File(getFilesDir(), "testFile");
  
          try {
              BufferedOutputStream bos = new BufferedOutputStream(openFileOutput("testFile", Context.MODE_PRIVATE),1024);
              bos.write(data);
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          } catch (IOException e) {
              e.printStackTrace();
          }
          return getThumbFromFile(file, false);
      }
  

  从图像文件创建缩略图：

  private Bitmap getThumbFromFile(File file) {
      Bitmap tempImage = null;
      try {
          tempImage = decodeSampledBitmapFromFile(file.getAbsolutePath(), 50, 50); // this is in pixels - use your desired size
          return ThumbnailUtils.extractThumbnail(tempImage, 50, 50);
      } finally {
          if (tempImage != null) {
              tempImage.recycle();
          }
      }
  }
  

  仅加载已调整大小的位图：

  private Bitmap decodeSampledBitmapFromFile(String filePath, int reqWidth, int reqHeight) {
      // First decode with inJustDecodeBounds=true to check dimensions
      final BitmapFactory.Options options = new BitmapFactory.Options();
      options.inJustDecodeBounds = true;
      BitmapFactory.decodeFile(filePath, options);
  
      // Calculate inSampleSize
      options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
  
      // Decode bitmap with inSampleSize set
      options.inJustDecodeBounds = false;
      return BitmapFactory.decodeFile(filePath, options);
  }
  

  计算采样值 - 由Google提供，您可以找到他们的教程：

  private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
      // Raw height and width of image
      final int height = options.outHeight;
      final int width = options.outWidth;
      int inSampleSize = 1;
  
      if (height > reqHeight || width > reqWidth) {
  
          final int halfHeight = height / 2;
          final int halfWidth = width / 2;
  
          // Calculate the largest inSampleSize value that is a power of 2 and keeps both
          // height and width larger than the requested height and width.
          while ((halfHeight / inSampleSize) > reqHeight &&
                  (halfWidth / inSampleSize) > reqWidth) {
              inSampleSize *= 2;
          }
      }
  
      return inSampleSize;
  }
  

  回复于 2024-04-26T08:24:01+08:00