Discussion :

[Fused]

Bonjour,

Je début en AS3, j'ai déjà de grosses connaissances en java, C#, ... donc pas de mal !

Je cherche une solution entièrement AS3 pour tester la vitesse de téléchargement du client.
Ça me permet par exemple de charger des images et swf de tailles adaptées.

J'ai fais mes recherches, apparemment une solution souvent proposée et le test de téléchargement de fichiers, déduire une moyenne... En javascript tout le temps. Il faut que je m'en passe.

Y a t'il des fonctions sous AS3 pour faire tout ça ?

Avez vous d'autres idées ?

Merci

[Lorenzo77]

salut,

tu peux le faire en AS3 sans probleme, suffit de telecharger un fichier de taille connu avec la classe URLLoader ou Loader + getTimer(), a la fin tu connais la vitesse moyenne.

je n'ai jamais mis en place ce genre de systeme car on ne peut pas savoir ce que fait le client avec sa connexion au moment ou le test est fait ... il peut trés bien être en plein telechargement.

[Fused]

C'est vrai, c'est pour ça que j'étudie un peu plus quelque chose comme ça.

Je viens de voir pour le URL Loader, ça correspond à ce que je veux faire.

Mais comme tu le dis, si à la seconde où on fait le test, sa connexion rame pour x raison, ça serait con de lui pénaliser l'affichage pour rien.

C'est pour un devoir donc j'aimerai bien trouver une solution audacieuse. J'ai pensé à des probabilités (réseaux bayésiens par exemple), mais là encore ça risque de pénaliser les performances de l'application pour au final pas grand chose.

Mais pour avoir visité pas mal de sites en flex, ça m'arrive de me lasser de la longueur de chargement de chaque page à cause d'objets swf sûrement trop volumineux.

Merci pour ta réponse et si vous avez d'autres idées, je suis preneur !

[Fused]

Bonjour,

Je reviens sur mon sujet :

J'ai écrit une classe qui permet de calculer la vitesse de téléchargement du client.

Cette vitesse dépend bien sûr de beaucoup de paramètres que nous n'allons pas discuter ici. C'est pour l'exercice.

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
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
package connexion
{
	import flash.display.Loader;
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.events.ProgressEvent;
	import flash.net.URLRequest;
	import flash.utils.Timer;
 
	/**
	 * Classe ConnexionTest
	 * Possède des fonctions de calcul de vitesse de connexion
	 * Ces tests reposent sur la vitesse de chargement de fichiers
	 */
	public class ConnexionSpeed
	{
		private var chargeur : Loader;
		private var urlRequest : URLRequest;
		private var timeStart : int;
		private var timeStop : int;
		private var timer : Timer;
		private var tailleFichier : int;
		private var chargementFini : Boolean;
 
		/**
		 * Constructeur
		 */			
		public function ConnexionSpeed (fichier : String) {
			chargementFini = Boolean(false);
			chargeur = new Loader();
			timer = new Timer(10);
			urlRequest = new URLRequest(fichier);
			// on définit les évenements sur la propriété contentLoaderInfo de l'objet loader.
			chargeur.contentLoaderInfo.addEventListener(Event.INIT, debutChargement);
			chargeur.contentLoaderInfo.addEventListener(Event.COMPLETE, finDuChargement);
			chargeur.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, avancement);
			chargeur.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, indiquerErreur);
		}
 
		/**
		 * Démarrage du chargement du fichier
		 */	
		public function demarrer () : void {
			trace("démarrer !");
			chargeur.load(urlRequest);	// début du chargement
		}
 
		/**
		 * On définit la fonction debutChargement, executée par l'évenement INIT  : 
		 */			
		private function debutChargement ( event : Event ) : void {
			trace("Début chargement !");	
			tailleFichier = event.target.bytesTotal;	// récupération de la taille du fichier					
			timer.start();	// départ du timer
		}
 
		/**
		 * On définit la fonction finDuChargement, executée par l'évenement COMPLETE  : 
		 */		 
		private function finDuChargement ( event : Event ) : void {
			timer.stop();	// arrêt du timer
			trace("Chargement terminé ! Temps : " + getTempsChargement());
			trace("Taille du fichier : " + tailleFichier);			
			trace("Vitesse de connexion calculée : " + getVitesseConnexion() + " byte/ms");
			chargementFini = true;
		}
 
		/**
		 * Fonction indiquant l'avancement du chargement
		 */	
		private function avancement ( event : Event ) : void {
			trace(event.target.bytesLoaded + " chargés sur " + event.target.bytesTotal + " - " + getTempsChargement());
		}
 
		/**
		 * Fonction indiquant si une erreur de chargmement survient  : 
		 */		
		public function indiquerErreur( event : Event ) : void {
			trace(event);
		}
 
		/**
		 * Fonction retournant le temps de chargement en cours
		 */
		public function getTempsChargement () : int {
			return flash.utils.getTimer();
		}
 
		/**
		 * Fonction calculant la vitesse de connexion
		 * Retourne une vitesse de connexion en byte/ms
		 */
		public function getVitesseConnexion () : Number {
			return (tailleFichier / getTempsChargement());
		}
 
		/**
		 * Détermine l'état du chargement
		 * Retourne vrai si le chargement du fichier est terminé, faux sinon
		 */
		public function getEtatChargement () : Boolean {
			return (chargementFini.valueOf());
		}
	}
}

Tout ceci fonctionne bien.

Je souhaite ensuite gérer ceci par un "manager". Ce manager doit proposer d'utiliser la classe précédente pour tester la vitesse de connexion sous plusieurs angles (puis gérer les déconnexions et les problèmes).

Je veux faire deux tests pour affiner la précision de la vitesse.

Voilà en j'en suis :

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
package manager
{
	import connexion.ConnexionSpeed;
 
	/** 
	 * Classe ConnexionTest
	 * Possède des fonctions de calcul de vitesse de connexion
	 * Ces tests reposent sur la vitesse de chargement d'images
	 */
	public class LoadManager
	{
		private var fichier1:String = "http://legraverend.fr/documents/test.jpg";
		private var fichier2:String = "http://legraverend.fr/documents/test.jpg";
		private var connexionSpeed1:ConnexionSpeed;
		private var connexionSpeed2:ConnexionSpeed;
 
		/**
		 * 
		 */
		public function LoadManager()
		{
			connexionSpeed1 = new ConnexionSpeed(fichier1);
			connexionSpeed2 = new ConnexionSpeed(fichier2);
		}
 
		public function calculerVitesseConnexion() : Number {
 
			connexionSpeed1.demarrer();
 
			/*while (connexionSpeed1.getEtatChargement() != true) {
 
			}*/
 
			connexionSpeed2.demarrer();
			/*while (connexionSpeed2.getEtatChargement() == new Boolean(false)) {
				trace("Attente test 2");
			}*/
			trace("Vitesse de connexion 1: " + connexionSpeed1.getVitesseConnexion());
			trace("Vitesse de connexion 2: " + connexionSpeed2.getVitesseConnexion());
			trace("Vitesse de connexion moyenne: " + (connexionSpeed1.getVitesseConnexion() + connexionSpeed2.getVitesseConnexion()) / 2);
			return (connexionSpeed1.getVitesseConnexion() + connexionSpeed2.getVitesseConnexion()) / 2;
		}
 
	}
}

Mon problème principal à présent : comment attendre que ces tests soient réalisés ?
J'ai pensé aux boucles while (commentés) mais le programme tourne en boucle et j'imagine que la machine virtuelle reste bloquée dessus plutôt que de s'occuper du chargement. Du coup, getEtatChargement() ne passe jamais à "vrai".

Dur à exploiter du coup...

Auriez vous des idées pour contrer ce problème ?

Pour la suite, je souhaite pour avoir utiliser ceci dans une application flex. En appelant cette fonction dans le MXML, peut-être avec la fonction applicationComplete="init()". Fonction qui servira à déterminer la vitesse de connexion du client et d'utiliser tel ou tel dossier de documents, plus ou moins volumineux en fonction de sa vitesse de connexion.

Merci de votre aide, je débarque dans ce monde là !