BitmapFactory.decode - Out of memory

Version imprimable

Bonjour,

J'ai un problème très gênant sur mon appli qui utilise les bitmap pour afficher des images de bonne qualité (où l'on peut zoomer, 1280*960 résolution mini).

Mon appli crashe très souvent à cause des dépassements de mémoire.

J'ai beau avoir cherché, hormis diviser par deux la qualité des images, je n'ai trouvé aucune solution.
Comment faire ?

Merci.

Mon code :
Code:

1 2 3 4 5 6 7 8 BitmapFactory.Options bo = new BitmapFactory.Options(); //bo.inSampleSize = 2; // divise par X les images pour éviter les crashs bo.inDither = false; bo.inPreferredConfig = Bitmap.Config.ARGB_8888; Bitmap bm = BitmapFactory.decodeResource(getResources(), monImage, bo); TouchImageView i = new TouchImageView(context); i.setImageDrawable(new BitmapDrawable(bm));

06/06/2013, 16h05
nicroman

Avez vous suivi les indications de la documentation Android ?
(http://developer.android.com/trainin...aps/index.html)

(au passage, il vaut mieux utiliser setImageBitmap plutôt que de passer par un BitmapDrawable qui *risque* de dupliquer les données de la bitmap).

Il est étonnant que pour afficher une bitmap il y ai un OOM...
06/06/2013, 16h38
Narion

Citation:

Envoyé par nicroman

Il est étonnant que pour afficher une bitmap il y ai un OOM...

j'ai réussi à en avoir avec des background trop gros :oops:....

utilise le liens de nicroman (cache et recycle) sa devrais régler le problème.
06/06/2013, 17h10
Manu0086

Merci de cette réponse.

Oui j'ai essayé de suivre la procédure, sans réussite.

setImageBitmap ne change pas grand chose, ça crash de la même façon.

N'y a-t-il aucune autre solution que le bitmap ? (suis débutant sur Androïd)
06/06/2013, 17h59
Narion

de toute façon tu auras le même problème, c'est pas uniquement lié à android mais aussi à java et au garbage collector.

je suis pas sur de pouvoir t'aider, car mon problème était plus un caprice qu'un réel besoin dans mon application (donc je l'ai réglé différemment), et mon explication risque d'être plus que brouillon.

mais si j'ai bien compris, il faut que tu force java à libérer de la mémoire. donc en utilisant des recycle().
http://developer.android.com/trainin...ge-memory.html

si tu veux pouvoir utiliser plusieurs image, sans avoir à les recharger, utilise la mémoire cache.
http://developer.android.com/trainin...he-bitmap.html.
06/06/2013, 18h27
Manu0086

Merci de votre aide.

Mais la majorité des conseils se résument à utiliser "decodeSampledBitmapFromResource" qui permet de réduire la taille de l'image et donc sa qualité.
Tous les conseils utilisent les recommandations précédentes, ce qui fait qu'au final, on reprend tout, c'est bien bordélique...

Bonjour,

J'ai fortement diminué les crashs (même si encore présents)

J'utilise la classe suivante :

Code:

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
45
46
47
48
49
50
51
52
53
class ImageManager {
    private HashMap<Integer, Bitmap> mBitmaps;
    private HashMap<Integer, Drawable> mDrawables;
    private Context mContext;
 
    private boolean mActive = true;
 
    public ImageManager(Context c) {
        mBitmaps = new HashMap<Integer, Bitmap>();
        mDrawables = new HashMap<Integer, Drawable>();
        mContext = c;
    }
 
    // We need to share and cache resources between objects to save on memory.
    public Bitmap getBitmap(int resource) {
        if (mActive) {
            if (!mBitmaps.containsKey(resource)) {
                mBitmaps.put(resource,
                    BitmapFactory.decodeResource(mContext.getResources(), resource));
            }
            return mBitmaps.get(resource);
        }
        return null;
    }
 
    public Drawable getDrawable(int resource) {
        if (mActive) {
            if (!mDrawables.containsKey(resource)) {
                mDrawables.put(resource, mContext.getResources().getDrawable(resource));
            }
            return mDrawables.get(resource);
        }
        return null;
    }
 
    public void recycleBitmaps() {
        Iterator itr = mBitmaps.entrySet().iterator();
        while (itr.hasNext()) {
            Map.Entry e = (Map.Entry)itr.next();
            ((Bitmap) e.getValue()).recycle();
        }
        mBitmaps.clear();
    }
 
    public ImageManager setActive(boolean b) {
        mActive = b;
        return this;
    }
 
    public boolean isActive() {
        return mActive;
    }
}

Source : http://blog.pseudoblue.com/2010/08/1...-memory-leaks/

C'est simple et assez efficace, je vais m'en contenter pour le moment.

07/06/2013, 21h03
Narion

je vais tenter d'expliquer un peu mieux, le problème que tu vas rencontrer avec le garbage collector.

Comme tu le sais, dans une application android, il y a plusieurs fichier drawable (mdpi, hdpi........) leur utilité est d'alléger la consommation du gc. D’ailleurs mon problème (background trop gros) ce produisais uniquement sur mdpi et ldpi.

j'en ai conclue, que le gc était différent en fonction de l’appareille ou de la taille de l'écran.

Donc sans redimensionner tes images, ton application vas peut être marcher sur un type d’appareille/écran et pas du tout sur un plus petit....

si tu veux vraiment faire ça, je regarderais plus du coté du NDK (mais alors la c'est vraiment hypothétique, car je ne connais absolument pas...).
10/06/2013, 09h09
Manu0086

Bonjour,

Oui j'ai remarqué cela sur une petite tablette Nexus, ça plantait constamment alors que sur la samsung 10.1, ça passait 8 fois sur 10.
Enfin bon, c'est aussi lié à la mémoire de celle-ci.