创建某些图像后内存不足

Question

in my application I create some foto on button click where I take the screen view and thene I merge this image with 2 logo, the app with 5,10 image don't have problem but with more the 10 image I get an out of memory, this is the code:

    @Override
    public void onScreenshotImage(ImageStruct image) {
        //do whatever you want with the image parameter

        super.onScreenshotImage(image);

        Bitmap a = image.getBitmap();

        ResizeImage resize = new ResizeImage(a);
        resize.execute();

        Log.d("onScreenshot","get image");
    }

private class ResizeImage extends AsyncTask<String, Void, String> {
    Bitmap bottomImage;

    public ResizeImage (Bitmap image) {
        bottomImage = image;
    }

    @Override
    protected String doInBackground(String... params) {

        Bitmap output = Bitmap.createBitmap(bottomImage.getWidth(), bottomImage.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(output);
        Paint paint = new Paint();
        paint.setAntiAlias(true);

        canvas.drawBitmap(bottomImage, 0, 0, paint);

        Bitmap a = BitmapFactory.decodeResource(getResources(), R.drawable.logo);
        canvas.drawBitmap(a, 0, 0, paint);
        Bitmap b = BitmapFactory.decodeResource(getResources(), R.drawable.logo_1);
        canvas.drawBitmap(b, bottomImage.getWidth()-(b.getWidth()+20), bottomImage.getHeight()-(b.getHeight()+30), paint);

        String outputString = Environment.getExternalStorageDirectory().getPath() + "/images/";

        File folder_thumb= new File(outputString);
        if (!folder_thumb.exists()) {
            folder_thumb.mkdirs();
        }

        String tmpImg = String.valueOf(System.currentTimeMillis()) + ".png";
        OutputStream os = null;
        try {
            os = new FileOutputStream(outputString + tmpImg);
            output.compress(Bitmap.CompressFormat.PNG, 100, os);
            os.close();
        }
        catch(IOException e) {
            Log.e("combineImages", "problem saving images", e);
        }

        a.recycle();
        b.recycle();
        output.recycle();
        bottomImage.recycle();

        return "Executed";
    }

    @Override
    protected void onPostExecute(String result)  {
        System.gc();
        Runtime.getRuntime().gc();
    }
}

ps. the first funciton is the function for get the image in metaio. where is the mistake?

edit: I saw that waiting for the end of the task the memory does not exceed tot mb , while removing the block ( a simple boolean ) memory also goes to 100mb.

Answer 1

You can do two things:

1. Handle this problem yourself with Android SDK
2. Let the appropriate library handle it for you

If you choose option 2 , just use Picasso . Check examples on their website. There's no simpler API for loading images on Android out there and it's better option.

Sample API call looks like this:

Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

If you choose option 1 , you'll have more work and you can follow tips below:

There's an article about Loading Large Bitmaps Efficiently on official Android Developers website, which is worth reading. It explains the problem and presents possible solution.

We can deal with memory problem in three steps:

1. Read image dimensions and type
2. Scale down image
3. Load scaled down version of the image to memory

You can use the following code snippet:

public static Bitmap decodeSampledBitmap(String filePath, int reqWidth, int reqHeight) {
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(filePath,options);
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeFile(filePath,options);
}

You will also need calculateInSampleSize method borrowed from Android documentation :

public static 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;
}

Answer 2

In your AndroidManifest.xml add this line inside <application /> tag

android:largeHeap="true"

Remember the documentations warning about this though ( https://developer.android.com/training/articles/memory.html ):

In very special situations, you can request a larger heap size by setting the largeHeap attribute to "true" in the manifest tag. If you do so, you can call getLargeMemoryClass() to get an estimate of the large heap size.

However, the ability to request a large heap is intended only for a small set of apps that can justify the need to consume more RAM (such as a large photo editing app). Never request a large heap simply because you've run out of memory and you need a quick fix—you should use it only when you know exactly where all your memory is being allocated and why it must be retained. Yet, even when you're confident your app can justify the large heap, you should avoid requesting it to whatever extent possible. Using the extra memory will increasingly be to the detriment of the overall user experience because garbage collection will take longer and system performance may be slower when task switching or performing other common operations.

Additionally, the large heap size is not the same on all devices and, when running on devices that have limited RAM, the large heap size may be exactly the same as the regular heap size. So even if you do request the large heap size, you should call getMemoryClass() to check the regular heap size and strive to always stay below that limit.