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 ?