Optimisation : hashmaps

Version imprimable

Salut à tous,
Je viens de changer une bonne partie de mon code et y ai ajouter des hashmap, le problème c'est que c'est aps du tout optimisé et ca se sent :aie:

Voici un bout de code :

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
public static enum datas{ALLAPPS, SMS, CONTACTS, BROWSER, PHONE, WPP};
 
	private static HashMap<Object, Bitmap> DicoDataBmp = new HashMap<Object, Bitmap>(){{
		put(datas.ALLAPPS, null);
		put(datas.SMS, null);
		put(datas.CONTACTS, null);
		put(datas.BROWSER, null);
		put(datas.PHONE, null);
		put(datas.WPP, null);
	}};
 
	private static HashMap<Object, String> DicoDataFilename = new HashMap<Object, String>(){{
		put(datas.ALLAPPS, "file_allapps.jpg");
		put(datas.SMS, "file_sms.jpg");
		put(datas.CONTACTS, "file_contacts.jpg");
		put(datas.BROWSER, "file_browser.jpg");
		put(datas.PHONE, "file_phone.jpg");
		put(datas.WPP, "file_wpp.jpg");
	}};
 
	private static HashMap<Object, Integer> DicoDataDefaultDrawable = new HashMap<Object, Integer>(){{
		put(datas.ALLAPPS, R.drawable.ic_allapps);
		put(datas.SMS, R.drawable.sms);
		put(datas.CONTACTS, R.drawable.contacts);
		put(datas.BROWSER, R.drawable.web);
		put(datas.PHONE, R.drawable.phone);
		put(datas.WPP, R.drawable.wallpaper_01);
	}};
 
public static void blabla(Context context){
		// Load images from sdcard
		File sdcard = Environment.getExternalStorageDirectory();
		String file;
		Bitmap bmp;
		Object key;
 
		for(Entry<Object, String> dico : DicoDataFilename.entrySet()){
			key = dico.getKey();
			file = new File(sdcard + File.separator + dico.getValue()).getAbsolutePath();
			bmp = BitmapFactory.decodeFile(file);
			if(bmp == null){
				DicoDataBmp.put(key, BitmapFactory.decodeResource(context.getResources(), DicoDataDefaultDrawable.get(key)));
			}else{
				DicoDataBmp.put(key, bmp);
			}
		}
 
 
	}

Et la les gens qui ont plus l'habitude que moi de faire du Java sur Android sautent certainement au plafond :mouarf:
Déjà je comprend pas bien pourquoi je ne peut pas faire passer mes "datas" pour des int comme en C++ ... ca me parmettrait d'utiliser des ParseArray.

Bref, auriez vous une idée de comment je pourrais optimiser ca ?
Merci d'avance.

Edit :
J'ai changer un peu le code, mais ca reste lent :

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
	private static final int ALLAPPS = 0;
	private static final int SMS = 1;
	private static final int CONTACTS = 2;
	private static final int BROWSER = 3;
	private static final int PHONE = 4;
	private static final int WPP = 5;
	private static SparseArray<Bitmap> DicoDataBmp = new SparseArray<Bitmap>(){{
		append(ALLAPPS, null);
		append(SMS, null);
		append(CONTACTS, null);
		append(BROWSER, null);
		append(PHONE, null);
		append(WPP, null);
	}};
 
	private static SparseArray<String> DicoDataFilename = new SparseArray<String>(){{
		append(ALLAPPS, "file_allapps.jpg");
		append(SMS, "file_sms.jpg");
		append(CONTACTS, "file_contacts.jpg");
		append(BROWSER, "file_browser.jpg");
		append(PHONE, "file_phone.jpg");
		append(WPP, "file_wpp.jpg");
	}};
 
	private static SparseIntArray DicoDataDefaultDrawable = new SparseIntArray(){{
		append(ALLAPPS, R.drawable.ic_allapps);
		append(SMS, R.drawable.sms);
		append(CONTACTS, R.drawable.contacts);
		append(BROWSER, R.drawable.web);
		append(PHONE, R.drawable.phone);
		append(WPP, R.drawable.wallpaper_01);
	}};

29/08/2013, 18h58
Hizin

Première question : pourquoi ce besoin ?
Deuxième question : pourquoi passer par des Map, List... ?
Troisième question : pourquoi 3 maps ?

J'imagine que tu as souvent besoin de ces images si tu es parti dans ce genre d'optimisation.
Android est optimisé pour la création rapide d'image avec un système de cache pour éviter de régénérer X fois la même image. Tu peux en créer un local à ton application, qui sera plus performant (appel application - application contre application - système - cache - système - application), mais pour indiquer des pistes, il faudrait savoir ce que tu souhaites réaliser, et pourquoi tu pars dans cette direction :)
29/08/2013, 20h29
atha2

Pour récupérer un int à partir d'un data, tu as la méthode ordinal() :

Code:

int index = datas.ALLAPPS.ordinal();

à noter que pour récupérer une enum à partir d'un entier tu peux faire :

Code:

datas enumValue = datas.values()[index];

Ensuite pour l'optimisation, je doute que charger seulement 6 images en mémoire, peux importe la manière, soit une opération couteuse. Si tu veux mon avis ton problème est ailleurs...
Par exemple es-tu sur de ne pas rappeler blabla() plusieurs fois dans ton programme ? Autre chose, Je dis ça par hasard vu qu'on n'a pas le reste du code mais il vaut mieux éviter de charger tes images dans le thread graphique (celui par défaut). Tu peux pour cela utilser un nouveau Thread ou une AsyncTask.

Merci pour vos réponses :ccool:

Hizin :
Je l'ai fait par ce que avant je faisais plusieurs fois les mêmes opérations, et plutot que faire autant d'appel de fonctions je trouvais plus fun de faire une boucle qui fasse tout toute seule.
C'est à dire au lieu de faire 6 fois ChargerImage, MettreImageDansLaBonneVar, SaveImageDansMobile j'ai voulu faire une boucle qui peut aller chercher toutes les infos dont elle a besoin (surtout que dans le futurs ils est possible que ces appels passe de 6 à 12 ou plus).
D'où mon choix de Map, grace a un indice, je peux get/set la variable corresponde, le nom de fichier et la valeur par défaut de cette variable (3infos, 3maps).

Atha2 :
Super merci pour l'info sur les enums, je vais plutot utiliser des tableaux du coup ^^ (et je lance en effet le code dans un new Thread()).

Je met le code complet si ca vous parle plus. (y'a une balise "secret" su ce forum, que se soit plus buvable ?)

Cette classe permet de changer le theme du mobile, en l'occurence ici les 5 docks icons de bases et le wallpaper(wpp). L'application est plus grande que ca, je télécharge les infos des thèmes depuis une base de donnée (résultat en JSON), les affiches dans des bouttons, quand je clique sur un bouton je télécharge un JSON qui me donne les url vers les images dont j'ai besoin.
Je set les images dans le themes manager et appelle "ApplyTheme(Context context)".

Toute la partie telechargement et JSON va plutot rapidement (selon la connexion), c'est depuis que j'ai mis ces Map que ca met plus de temps.
[SECRET]

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
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
public class ThemeManager {	
 
	private static final int ALLAPPS = 0;
	private static final int SMS = 1;
	private static final int CONTACTS = 2;
	private static final int BROWSER = 3;
	private static final int PHONE = 4;
	private static final int WPP = 5;
        // Le launcher utilise les img de cet Array pour set les dockIcon
	private static SparseArray<Bitmap> DicoDataBmp = new SparseArray<Bitmap>(){{
		append(ALLAPPS, null);
		append(SMS, null);
		append(CONTACTS, null);
		append(BROWSER, null);
		append(PHONE, null);
		append(WPP, null);
	}};
 
        // Les fichiers qui serviront à save les images en local
	private static SparseArray<String> DicoDataFilename = new SparseArray<String>(){{
		append(ALLAPPS, "file_allapps.jpg");
		append(SMS, "file_sms.jpg");
		append(CONTACTS, "file_contacts.jpg");
		append(BROWSER, "file_browser.jpg");
		append(PHONE, "file_phone.jpg");
		append(WPP, "file_wpp.jpg");
	}};
 
        // Les images par défauts du launcher
	private static SparseIntArray DicoDataDefaultDrawable = new SparseIntArray(){{
		append(ALLAPPS, R.drawable.ic_allapps);
		append(SMS, R.drawable.sms);
		append(CONTACTS, R.drawable.contacts);
		append(BROWSER, R.drawable.web);
		append(PHONE, R.drawable.phone);
		append(WPP, R.drawable.wallpaper_01);
	}};
 
 
	private final static String CURRENT_THEME_PCKG = "currentThemePackage";
 
	public static void ApplyTheme(Context context){
		// Calls to tell the launcher to set the dock icons 
		HelperUI.SetCustomDockToolbar(context,true);
		final ArrayList<ApplicationInfo> list = (ArrayList<ApplicationInfo>) LauncherModel.sWorkspaceItems.clone();
	    HelperUI.SetAppList(list,true);
 
            // Set wpp
	    if(DicoDataBmp.get(WPP) != null){
		    try {
		    	WallpaperManager.getInstance(context).setBitmap(DicoDataBmp.get(WPP));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	    }
	}
 
        // Cette fonction est applée au démarrage du launcher
	public static void SetTheme(Context context){
		// Load images from sdcard
		File sdcard = Environment.getExternalStorageDirectory();
		String file;
		Bitmap bmp;
		int key;
 
		for(int i=0 ; i<DicoDataFilename.size() ; i++){
			key = DicoDataFilename.keyAt(i);
			file = new File(sdcard + File.separator + DicoDataFilename.get(key)).getAbsolutePath();
			bmp = BitmapFactory.decodeFile(file);
			if(bmp == null){
				DicoDataBmp.put(key, BitmapFactory.decodeResource(context.getResources(), DicoDataDefaultDrawable.get(key)));
			}else{
				DicoDataBmp.put(key, bmp);
			}
		}
 
		ApplyTheme(context);
 
	}
 
	public static void SetDefaultTheme(Context context){
		File sdcard = Environment.getExternalStorageDirectory();
		File file;
		FileOutputStream fos;
		int key;
		try {
 
			for(int i=0 ; i<DicoDataFilename.size() ; i++){
				key = DicoDataFilename.keyAt(i);
				file = new File(sdcard + File.separator + DicoDataFilename.get(key));
				fos = new FileOutputStream(file);
				fos.write(0);
 
				DicoDataBmp.put(key, BitmapFactory.decodeResource(context.getResources(), DicoDataDefaultDrawable.get(key)));
			}
 
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
		ApplyTheme(context);
	}
 
	// Get/Set
 
	// TODO:
	// If set null, set default
	public static Bitmap getIcoBrowser() {
		return DicoDataBmp.get(BROWSER);
	}
 
	public static Bitmap getIcoPhone() {
		return DicoDataBmp.get(PHONE);
	}
 
	public static Bitmap getIcoContacts() {
		return DicoDataBmp.get(CONTACTS);
	}
 
	public static Bitmap getIcoSms() {
		return DicoDataBmp.get(SMS);
	}
 
	public static Bitmap getIcoAllApps() {
		return DicoDataBmp.get(ALLAPPS);
	}
 
	public static Bitmap getWpp(){
		return DicoDataBmp.get(WPP);
	}
 
	public static void setIcoBrowser(Bitmap bmp) {
		DicoDataBmp.put(BROWSER, bmp);
		saveImageToSD(bmp, BROWSER);
	}
 
	public static void setIcoPhone(Bitmap bmp) {
		DicoDataBmp.put(PHONE, bmp);
		saveImageToSD(bmp, PHONE);
	}
 
	public static void setIcoContacts(Bitmap bmp) {
		DicoDataBmp.put(CONTACTS, bmp);
		saveImageToSD(bmp, CONTACTS);
	}
 
	public static void setIcoSms(Bitmap bmp) {
		DicoDataBmp.put(SMS, bmp);
		saveImageToSD(bmp, SMS);
	}
 
	public static void setIcoAllApps(Bitmap bmp) {
		DicoDataBmp.put(ALLAPPS, bmp);
		saveImageToSD(bmp, ALLAPPS);
	}
 
	public static void setWpp(Bitmap bmp){
		DicoDataBmp.put(WPP, bmp);
		saveImageToSD(bmp, WPP);
	}
 
	public static void setIcoBrowser(String url) {
		Bitmap bmp = getBitmapFromURL(url);
		DicoDataBmp.put(BROWSER, bmp );
		saveImageToSD(bmp, BROWSER);
	}
 
	public static void setIcoPhone(String url) {
		Bitmap bmp = getBitmapFromURL(url);
		DicoDataBmp.put(PHONE, bmp );
		saveImageToSD(bmp, PHONE);
	}
 
	public static void setIcoContacts(String url) {
		Bitmap bmp = getBitmapFromURL(url);
		DicoDataBmp.put(CONTACTS, bmp );
		saveImageToSD(bmp, CONTACTS);
	}
 
	public static void setIcoSms(String url) {
		Bitmap bmp = getBitmapFromURL(url);
		DicoDataBmp.put(SMS, bmp );
		saveImageToSD(bmp, SMS);
	}
 
	public static void setIcoAllApps(String url) {
		Bitmap bmp = getBitmapFromURL(url);
		DicoDataBmp.put(ALLAPPS, bmp );
		saveImageToSD(bmp, ALLAPPS);
	}
 
	public static void setWpp(String url){
		Bitmap bmp = getBitmapFromURL(url);
		DicoDataBmp.put(WPP, bmp );
		saveImageToSD(bmp, WPP);
	}
 
	public static Bitmap getBitmapFromURL(String src) {
	    try {
	        URL url = new URL(src);
	        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
	        connection.setDoInput(true);
	        connection.connect();
	        InputStream input = connection.getInputStream();
	        Bitmap myBitmap = BitmapFactory.decodeStream(input);
	        return myBitmap;
	    } catch (IOException e) {
	        e.printStackTrace();
	        return null;
	    }
	}
 
	private static void saveImageToSD(Bitmap toSave, int data) {
 
	    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
 
	    toSave.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
 
	    File file = new File(Environment.getExternalStorageDirectory()
	            + File.separator + DicoDataFilename.get(data));
	    try {
	        file.createNewFile();
	    } catch (IOException e) {
	        e.printStackTrace();
	    }
 
	    FileOutputStream fos = null;
	    try {
	        fos = new FileOutputStream(file);
	    } catch (FileNotFoundException e) {
	        e.printStackTrace();
	    }
	    try {
	        fos.write(bytes.toByteArray());
	        fos.close();
	    } catch (IOException e) {
	        e.printStackTrace();
	    }
	}
 
 
}

[/SECRET]

30/08/2013, 15h54
Hizin

Ah, un sujet qui sort de l'habitude, j'étais plutôt dans une optique "ListView".

Citation:

Envoyé par faucheuse

D'où mon choix de Map, grace a un indice, je peux get/set la variable corresponde, le nom de fichier et la valeur par défaut de cette variable (3infos, 3maps).

Une Map sert à réaliser un lien clé/valeur. Pour un lien position/valeur (ou entier/valeur), tu peux simplement te diriger vers une List, ou vers un Sparse.

As-tu besoin de toutes ces images en même temps ?
Tu pourrais mettre un système de lazy loading chargeant l'image uniquement à la demande.

Tu vérifies si l'image est chargée, si ce n'est pas le cas, tu la charges, dans les 2 cas, tu la renvois.

Les maps ne jouent pas sur la lenteur, comme déjà dit.

Par contre le code est assez lourds. Il y a moyen de fortement réduire ça!

D'abord, les Enum, ça peux stocker des propriété (ben oui); donc les constantes, on peux les stocker directement dedans (à supposer que les valeurs soient connues à la compilation et constantes):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public static enum Datas{ ALLAPPS(R.drawable.ic_allapps,"file_allapps.jpg"), SMS( R.drawable.sms,"file_sms.jpg"), CONTACTS(R.drawable.contacts,"file_contacts.jpg"), BROWSER(R.drawable.web,"file_browser.jpg"), PHONE(R.drawable.phone,"file_phone.jpg"), WPP(R.drawable.wallpaper_01,"file_wpp.jpg"); Datas(int drawable, String file){ this.file=file; this.drawable = drawable; } public int getDrawable(){return drawable;} public int getFile(){return file;} }
Enfin, pour la HashMap qu'il te reste, il existe des EnumMap, bien plus performantes quand les clés sont des enums:

Code:

private static Map<Datas,Bitmap> DicoDataBmp = new EnumMap<Datas, Bitmap>(); // pourquoi mettre des null au fait?

Ce qui ramènerait ta boucle initiale à
Code:

1 2 3 4 5 6 7 8 9 for(Datas data: Datas.values()){ file = new File(sdcard + File.separator + data.getFile()).getAbsolutePath(); bmp = BitmapFactory.decodeFile(file); if(bmp == null){ DicoDataBmp.put(data, BitmapFactory.decodeResource(context.getResources(), data.getDrawable())); }else{ DicoDataBmp.put(data, bmp); } }

30/08/2013, 17h03
faucheuse

Super ! Merci beaucoup, je vais regarder tous ca ^^