Discussion :

[mazertys17]

Bonjour,

J'ai un problème de fuite de mémoire avec le chargement d'images.

J'ai un ArrayList<Picture> qui sert a afficher les images. L'Objet Picture contient simplement un Bitmap, un paint et 2 rects.
Afin de pouvoir gérer les animations, j'ai un autre objet PictureData qui contient une référence de la Picture ainsi que des données servant a l'animation, au positionnement etc...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Picture implements  Comparable<Picture> {
 
    Bitmap bitmap ;
    Rect rect1, rect2 ;
    Paint paint ;
    Integer z ;
 
    Picture(Bitmap b ){
        bitmap = b ;
        z = 0 ;
        rect1 = new Rect(0,0,b.getWidth(),b.getHeight());
        rect2 = new Rect(0,0,b.getWidth(),b.getHeight());
        paint = new Paint(); paint.setColor(Color.WHITE);
    }
    @Override
    public int compareTo(Picture p) {
        return z.compareTo(p.z) ;
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class PictureData {
 
    Picture picture ;
    String  name, type ;
    int x,y, width, height, animator, animatorX, animatorY ;
    int z, number, factor, additional = 0 ;
    Float proportional ;
 
    PictureData(Picture p, String n, String t, int ww, int hh ){
        picture = p ;
        name = n ;
        type = t ;
        x = 0 ;
        y = 0 ;
        z = 0 ;
        width = p.bitmap.getHeight()/ww ;
        height = p.bitmap.getWidth()/hh ;
        animator = 0 ;
        animatorX = 0 ;
        animatorY = 0 ;
        additional = 0 ;
        proportional = (float)0 ;
        factor = 1 ;
        number = p.bitmap.getWidth()/width * p.bitmap.getHeight()/height ;
    }
    PictureData(Picture pic,PictureData p){
 
        picture = pic;
        name = p.name ;
        type = p.type ;
        x = p.x ;
        y = p.y ;
        z = p.z ;
        width = p.width ;
        height = p.height ;
        animator = p.animator ;
        animatorX = p.animatorX ;
        animatorY = p.animatorY ;
        additional = p.additional ;
        factor= p.factor ;
        proportional = p.proportional ;
        number = p.number ;
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
public class GameSurface extends SurfaceView implements SurfaceHolder.Callback{
    ///...
    ArrayList<Picture> pictureWord, pictureHud ;
    ///...
    GameSurface(Context c, GameSystem gs){
        ///...
        pictureWord = new ArrayList<Picture>();
        pictureHud = new ArrayList<Picture>();
        ///...
    }
    void draw(){
 
        if (holder!=null) {
            Canvas canvas = holder.lockCanvas();
            if (canvas!=null){
                canvas.drawRect(background, paint);
                gameView.word(canvas);
                for ( Picture p : pictureWord){
                    canvas.drawBitmap(p.bitmap,p.rect1,p.rect2,p.paint);
                }
                gameView.hud(canvas);
                for ( Picture p : pictureHud){
                    canvas.drawBitmap(p.bitmap,p.rect1,p.rect2,p.paint);
                }
                hud.update(canvas);
                holder.unlockCanvasAndPost(canvas);
            }
        }
    }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class GameResource {
    ///...
    ArrayList<Bitmap> bitmaps ;
    HashMap<String,Picture> picture ;
    HashMap<String,PictureData> pictureDatas ;
    ///...
    GameResource(){
           Bitmap ground1 = Bitmap.createScaledBitmap(BitmapFactory.decodeResource(context.getResources(), R.drawable.ground1 ), measure.unitWord, measure.unitWord, true);
        Picture ground1P = new Picture(ground1 );
        ground1P.z = 0 ;
        PictureData desertD = new PictureData(ground1P,"ground1 ","floor",1,1);
        bitmaps.add(ground1 );
        picture.put("ground1 ", ground1 P);
        pictureDatas.put("ground1 ",ground1D);

Cela fonctionne mais lorsque je quitte l'activité qui les utilise pour la relancer et que je répète l'opération, il ne tarde pas a planter en me parlant d'un problème d'allocation de mémoire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
05-26 12:15:02.700    1903-1903/com.letremail.myApp/art﹕ Alloc concurrent mark sweep GC freed 3(96B) AllocSpace objects, 0(0B) LOS objects, 0% free, 31MB/32MB, paused 0 total 20ms
05-26 12:15:02.700    1903-1903/com.letremail.myAppI/art﹕ Forcing collection of SoftReferences for 900KB allocation
05-26 12:15:02.710    1903-1903/com.letremail.myAppD/AndroidRuntime﹕ Shutting down VM

Avez vous une idée de ce qui se passe ?

[mazertys17]

En fait je viens de constater que cela ne venait pas forcément de mon code en soit :

Lorsque je charge simplement un Bitmap, il finit par planter donc cela signifie sans doute qu'il génère une fuite de mémoire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
        Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.bitmap );

[dinobogan]

Ton image est probablement trop grande par rapport à la RAM disponible, ce qui est bien différent d'une fuite mémoire.
Quelles sont les caractéristiques de l'image que tu tentes de charger ?
As-tu tenter de charger une image très petite (genre 64x64 pixels) ?

[mazertys17]

Je ne pense pas puisqu'il réussit a la charger et a l'utiliser.
C'est quand je quitte l'application puis la relance que ca plante.

Mais je crois que je viens de trouver comment empêcher cela.
En fait il semblerait qu'il ne détruit pas complètement l'image tant qu'il y a une référence qui reste quelque part.

En nettoyant bien tous les composants en quittant, le plantage ne se fait plus ( en tout cas plus tard ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        ///...
        pictureWord.clear();
        pictureHud.clear();
        ///...
    }