Wsrtjtyk

I am using

Drawable drawable = res.getDrawable(id);

Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_4444);

Canvas canvas = new Canvas(bitmap);

bitmap.eraseColor(0);

drawable.setBounds(0,0, width, height);

drawable.draw(canvas);

return load(bitmap, linear);

to load a drawable from a resource id into OpenGL with a given width, and height. (Using

android.opengl.GLUtils.texImage2D(GL_TEXTURE_2D, 0, bitmap, 0);

)
The load function does the GL-calls, and calls also bitmap.recycle().

I specify width and height myself, because Android would match the resolution to the screen size, which I don't want.

Now my problem (this part is all working fine):
if I start my app for the first time, from Android Studio, everything works; HOWEVER if I want to restart it, it crashes because of OutOfMemoryError. I am doing the exactly same calls in both cases.

I located the issue to be in the resource management of Android, as you can see in the heap analysis:
my most expensive allocations

My images are way smaller than 9 MB each in raw (512x512, RGBA, so 1 MB).
How can I prevent Android from storing these large byte arrays, which probably are meant as some kind of cache; which however doesn't run on first start after app installation?

I am testing on Android 6.0.1, API Version 23, Galaxy S5.

Implementation of texImage2D looks like this:

public static void texImage2D(int target, int level, int internalformat,

        Bitmap bitmap, int border) {

    if (bitmap == null) {

        throw new NullPointerException("texImage2D can't be used with a null Bitmap");

    }

    if (bitmap.isRecycled()) {

        throw new IllegalArgumentException("bitmap is recycled");

    }

    if (native_texImage2D(target, level, internalformat, bitmap, -1, border)!=0) {

        throw new IllegalArgumentException("invalid Bitmap format");

    }

}

It doesn't look like it's recycling anything. Are you sure you are not loading a huge bitmap into memory? Two calls of those are more than enough to guarantee a huge explosion in your app, if not just one (I've seen it happen many times in my app). Remember, restarting your activity does not mean restarting your proccess.

Run the Android Profiler before the first load and check how much memory it takes.

Also, you can cache and reuse bitmaps yourself.

I solved it (myself) by putting the files into the raw folder of the resource directory, and loading them using

fun loadBitmap(res: Resources, rawId: Int): Bitmap {

    val inputStream = BufferedInputStream(res.openRawResource(rawId))

    return BitmapFactory.decodeStream(inputStream)

}

and then calling

load(bitmap, linear);

and

bitmap.recycle()

like before.
Luckily those all were png/jpeg files, so I didn't need the additional features of the drawables folder. Using this, they'll automatically use their right resolution.

My Java RAM allocation is now back on 25 MB to 35 MB instead of the 110 MB when using the old way :).