Discussion :

[red112]

Bonjour,
Je recherche une méthode afin de stocker des bitmaps dans la mémoire afin de pouvoir y accéder au moment voulu. Je m'explique, je récupere sur un serveur une liste d'images. Pour le moment je stock les url et je possede deux boutons pour passer a l'image suivante ou la précedente. Le probleme c'est qu'il y a une attente a chaque appui sur un bouton. J'ai essayer de charger toutes mes images dans une ArrayList<Bitmap> mais sa à l'air d'etre couteux en mémoire. Car au bout de quelque seconde l'application se ferme toute seule.

Est-ce qu'il existe une méthode moins couteuse pour stocker tout mes bitmaps et pouvoir y accéder rapidement ?

[bobby51]

salut,

si tu est sur que tes images ont un nom unique et que ce seront toujours plus ou moins les mêmes images qui seront téléchargés, tu peut les sauvegarder sur la mémoire du téléphone, en utilisant quelque chose de ce genre :
- a partir de l'url de l'image je récupère son nom
- je vérifie si l'image existe dans un répertoire de mon application que j'aurai défini (sur la carte sd ou mémoire interne)
- si non, jé télécharge l'image dans un asyncTask, en prenant soin de la redimensionner si par exemple l'image fait plus de 1000px de largeur (tout en gardant l'image à échelle), puis je la sauvegarde dans le répertoire temporaire.
- je charge le bitmap à partir de l'image qui est enregistré

Voila j'imagine que chargé l'image a partir de la mémoire du téléphone va être beaucoup moins couteux, de même pour la mémoire saturé en fonction de la résolution de tes images n'hésite pas à les redimensionner pour garder un bon rapport qualité/poids.

A+

[red112]

Merci pour ta réponse bobby51 mais en fait le téléchargement des images sur la carte sd est une fonction que j'aimerais implémenter par la suite dans l'application . Mais pour la lecture d'images j'aimerais juste améliorer l'attente du chargement d'une image c'est pourQuoi j'aurais préférer une méthode qui stock le bitmap dans la mémoire et non dans la sd si possible.

[nicroman]

La quantité de mémoire allouée à une application varie en fonction du "device", la limite basse étant 16Mo... la limite haute actuelle (gros high-end devices), je crois est de 64Mo (mais je peux me gourrer pour celle-ci)

Du coup, selon la taille des images, la limite est vite atteinte... une image de 64x64 pixels c'est 16Ko (soit une image de 0,5cm sur les terminaux récents)... on peut en stocker 1000 à tout casser....

Une image qui ferait la moitié de l'écran sur un device récent fait au minimum 256x256 pixels (256Ko) déjà, on ne peut en conserver que 60 en mémoire !

Donc l'idée est *toujours* de conserver un cache (local) des images....

Un truc genre (pseudo-code):

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
class ImageRef
{
     WeakReference<Bitmap>   memory;
     File                               cache;
     URL                               url;
     ArrayList<INotificatioN>    listeners;
 
     public Bitmap getBitmap(INotification notifier)
     {
          Bitmap  ret = (this.memory == null) ? null : this.memory.get();
          if (ret == null)
              startBitmapLoading(notifier);
          return (ret == null) ? Bitmap.LOADING : ret;
     }
 
     public void startBitmapLoading(INotification notifier)
     {
          this.listeners.add(notifier);
          if (this.loader != null) return;
          if (this.cache != null)
              this.loader = new AsyncFileLoader();
         else
              this.loader = new AsyncURLLoader();
         this.loader.execute(this);
     }
 
     public void doLoadFromURL()
     {
         // transfer from URL to File
         return doLoadFromFile();
     }
     public void doLoadFromFile()
     {
         // transfer from File to Bitmap
         this.memory = new WeakReference<Bitmap>(result);
      }
 
     public void notifyListeners()
     {
         for (INotification n : this.listeners)
             n.bitmapLoaded();
         this.listeners.clear();
     }
 
 
     static abstract class AsyncImageLoader extends AsyncTask<ImageRef,Void,ImageRef[]>
     {
          public void onPostExecute(ImageRef[] refs)
          {
              for (ImageRef r : refs)
                  r.notifyListeners();
           }
     }
 
     static class AsyncFileLoader extends AsyncImageLoader
     {
          public ImageRef[] doInBackground(ImageRef ... refs)
          {
              for (ImageRef r : refs) 
                   r.doLoadFromFile();
              return refs;
          }
      }
 
     static class AsyncURLLoader extends AsyncImageLoader
     {
          public ImageRef[] doInBackground(ImageRef ... refs)
          {
              for (ImageRef r : refs) 
                   r.doLoadFromUrl();
              return refs;
          }
      }
 
 
 
}

Après il faut optimiser l'interface...
Quand on affiche une image, conserver la précédente, et préparer la suivante... Comme ça, le temps passé par l'utilisateur à regarder/cliquer est utilisé à charger ....

[red112]

Merci, je vais essayer d'implmenter sa dans mon application.
Effectivement il faut optimiser, j'ai dejà essayer de charger une image d'avance et a chaque fois la stocker dans une arraylist.
Mais le problème c'est que si l'utilisateur appuyer plusieurs fois sur le bouton suivant, il y avait chargement de pleins d'images en fond, et rapidement la mémoire était saturée.

Est-ce que je ne risque pas de rencontrer le même problème ici ?