Thread lecture audio

Version imprimable

19/02/2013, 15h48
Patrice Henrio

Thread lecture audio

Bonjour,
après avoir lu des tonnes de documentation sur EDT, les threads, SwingWorker, après avoir essayé de comprendre beaucoup d'exemples, j'en suis toujours au même point : c'est à dire que je ne sais par quel bout prendre le problème. Je pense donc que je n'ai pas vraiment compris malgré quelques réalisations qui marchent.

Mon problème est le suivant : je veux lire un fichier mp3 à l'aide de JavaZoom (si quelqu'un connait un autre lecteur de MP3 open source et simple, je suis preneur). Je veux bien entendu que mon interface graphique continue à réagir en particulier comme expliquer dans la solution de kox2ee avec qui j'ai beaucoup échangé. Il me faudrait en plus une barre de progression qui indique où l'on en est du morceau.
Ce qui me gène dans les exemples que j'ai trouvé c'est que la tache longue considéré est toujours une boucle qui effectue de nombreuses fois une opération atomique. Je ne pense pas pouvoir faire la même chose car l'opération atomique est la lecture du morceau de musique. Je ne vois comme solution que de rentrer dans le code de javazoom pour voir comment est traité le thread de lecture (j'espère ne pas dire trop de conneries).

Bonjour,
effectivement, avec la lecture d'un flux audio ou vidéo, l'exemple de gestion des Threads que j'ai donné n'est d'aucune utilité...

Si tu restes sur la solution javaZoom, tu as de quoi agir sur les évènements lors de la lecture en implémentant l'interface BasicPlayerListener :

Méthodes à implémenter avec BasicPlayerListener :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 //à l'ouverture du flux @Override public void opened(Object stream, Map properties) //pendant la lecture @Override public void progress(int bytesread, long microseconds, byte[] pcmdata, Map properties) //En cas de changement d'état @Override public void stateUpdated(BasicPlayerEvent event)
Peux tu mettre ton code de lecture, qu'on puisse voir comment utiliser ces évènements ?

Voici donc une classe test minimale. Il faudrait lui rajouter une JProgressBar mais je ne pense pas que mon incompréhension vienne de là.
La classe de test avec sa fenêtre

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
package TacheLongue;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
 
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
import test.Lecteur1;
import test.Son;
 
 
 
public class TestSon extends JFrame implements ActionListener
{
	static Son chant;
    //les actions
	private JButton lancer;
	private JButton stop;
	private JButton rejoue;
 
	public static void main(String[] args)
	{
        javax.swing.SwingUtilities.invokeLater(new Runnable() 
        {
            private TestSon fenetre;
 
			public void run() 
            {
            	fenetre = new TestSon();
                fenetre.setVisible(true);
            }
        });
	}
 
	public TestSon()
	{
		super("test son");
 
		this.setSize (516,400);
		//fenêtre centrée
        setLocationRelativeTo(null);
        //fermeture du programme
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
        Lecteur1 lecteur = new Lecteur1();
        JPanel bas = new JPanel(new FlowLayout());
 
        JPanel gauche = new JPanel(new GridBagLayout ());
        gauche.setPreferredSize (new Dimension(500, this.getHeight ()));
        gauche.setBackground (Color.CYAN);
        gauche.setBorder (BorderFactory.createLineBorder(Color.black,3));
 
 
        //lancer le programme
        lancer = new JButton("Lancement");
        lancer.addActionListener (this);
        //arrêter le programme
        stop = new JButton("Arrêt");
        stop.addActionListener (this);
        stop.setEnabled(false);
        //pause
        rejoue = new JButton("rejouer");
        rejoue.addActionListener (this);
        rejoue.setEnabled(false);
 
        //la construction de la fenêtre
        gauche.add(lecteur);
        bas.add (lancer);
        bas.add (stop);
        bas.add (rejoue);
 
        getContentPane().setLayout (new BorderLayout()) ;
        getContentPane ().add (gauche, BorderLayout.WEST);
        getContentPane ().add (bas,BorderLayout.SOUTH);
 
 
        String fichierSon = "." + File.separator + "donnees" + File.separator + "black bird - merle noir - Turdus merula.mp3";
        chant = new Son(fichierSon) ;
	}
 
	public void actionPerformed(ActionEvent arg0)
	{
        //on arrête le programme
        if (arg0.getSource () == stop) 
        {
        	arreter();
        	return;
        }
 
        if (arg0.getSource () == lancer)
        {
        	lancer();
        	return;
        }
 
        if (arg0.getSource () == rejoue)
        {
        	rejouer();
        	return;
        }
	}
 
	private void rejouer()
	{
		// TODO Auto-generated method stub
 
	}
 
	private void lancer()
	{
		chant.start();
 
	}
 
	private void arreter()
	{
		// TODO Auto-generated method stub
 
	}
}

La classe Lecteur1

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
package test;
 
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
 
import javax.swing.JPanel;
import javax.swing.JProgressBar;
 
 
 
public class Lecteur1 extends JPanel 
{
    JProgressBar barre = new JProgressBar(0,100);
    Son son; // sons
//    JButton bouton;
 
    public Lecteur1() 
    { // Constructeur
    	setPreferredSize(new Dimension(400,20));
    	setLayout(new BorderLayout());
    	barre.setStringPainted(true);
    	//barre.setPreferredSize(new Dimension(280,10));
    	add(barre,BorderLayout.CENTER);
        //ajouter un écouteur sur la barre
    	addPropertyChangeListener(new PropertyChangeListener()
        {
            public void propertyChange(PropertyChangeEvent evt) 
            {
                if("progress".equals(evt.getPropertyName())) 
                {
                    barre.setValue((Integer) evt.getNewValue());
                }
            }
        });
    }
 
 
    public void lire()
    {
    	son.start();
    }
 
    public void arret()
    {
    	son.arret();
    }
 
    public boolean fini()
    {
    	return !(son.isAlive());
    }
}

La classe pour les sons

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
package test;
 
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
 
import javax.swing.JButton;
import javax.swing.JProgressBar;
 
import javazoom.jl.decoder.Bitstream;
import javazoom.jl.decoder.Header;
import javazoom.jl.decoder.JavaLayerException;
import javazoom.jl.player.AudioDevice;
import javazoom.jl.player.FactoryRegistry;
import javazoom.jl.player.Player;
 
public class Son extends Thread
{
//    AdvancedPlayer lecteur; // lecteur
	Player lecteur;
	InputStream stream; // flux
    File fichier;
    Boolean roule;
    public float duree;
    JButton bouton;
    JProgressBar barre;
 
    public Son(String chemin)
    { // Constructeur
 
        fichier = new File(chemin); // fichier
        try
        {
            AudioDevice dev = getAudioDevice();
            stream = getInputStream();
            lecteur = new Player(stream);
			Bitstream bs = new Bitstream(stream);
			Header h = bs.readFrame();
			duree = h.total_ms((int) fichier.length());
        }
        catch(Exception e ){e.printStackTrace();}
    }
 
    public Player getLecteur()
    {
		return lecteur;
    }
 
    public float getDuree()
    {
		return duree;
    }
 
 
    public void setBarre(JProgressBar barre)
    {
    	this.barre = barre;
    }
 
    protected AudioDevice getAudioDevice() throws JavaLayerException
    {
        return FactoryRegistry.systemRegistry().createAudioDevice();
    }
 
    protected InputStream getInputStream() throws IOException
    {
//        System.out.println(fichier) ;
        FileInputStream fin = new FileInputStream(fichier);
        BufferedInputStream bin = new BufferedInputStream(fin);
        return bin;
    }
 
    public void arret()
    {
    	roule = false;
    	lecteur.close();
    }
 
	public void run()
    {
				try
				{
					lecteur.play();
				}
				catch (JavaLayerException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
    } 
}

Pour le moment la barre de progression ne bouge pas car je ne sais pas comment récupérer dans le thread main le temps écoulé du chant qui je pense doit s'exécuter dans un autre thread (chant je crois).

En fait je patauge largement

19/02/2013, 20h01
kox2ee

JavaZoom propose déjà une classe utilisant les Threads, c'est BasicPlayer...
Mais ça n'est pas celle que tu utilises pour l'instant.

Ce sera plus simple à mon avis...

La lib complète est accessible depuis javaZoom

Et c'est sur BasicPlayer que tu vas pouvoir utiliser BasicPlayerListener en suivant cet exemple (en bas de la page)
19/02/2013, 20h56
Patrice Henrio

Citation:

Envoyé par kox2ee

JavaZoom propose déjà une classe utilisant les Threads, c'est BasicPlayer...
Mais ça n'est pas celle que tu utilises pour l'instant.

Ce sera plus simple à mon avis...

La lib complète est accessible depuis javaZoom

Et c'est sur BasicPlayer que tu vas pouvoir utiliser BasicPlayerListener en suivant cet exemple (en bas de la page)

OK Merci j'avais bien vu quelque chose de ce genre mais j'étais resté sur JLP. Je vais regarder.
19/02/2013, 22h54
Patrice Henrio

J'ai réussi à tout récupérer de BasicPlayer et l'exemple marche. Il n'y a plus qu'à l'adapter à mes besoins et ça se corse.

Donc j'ai un fichier son. Je dois créer un BasicPlayer pour l'entendre : ma première question est faudra-t-il recréer un BasicPlayer chaque fois que je changerai de fichier ou puis-je utiliser le même en changeant le flux d'entrée ?
19/02/2013, 23h08
kox2ee

Je pense que le mieux est de créer une classe gérant la lecture et dont un membre est une instance de BasicPlayer
19/02/2013, 23h13
Patrice Henrio

Citation:

Envoyé par kox2ee

Je pense que le mieux est de créer une classe gérant la lecture et dont un membre est une instance de BasicPlayer

C'est ce que je pensais faire. Un JPanel avec des boutons, une barre et BasicPlayer qui lit les morceaux.
19/02/2013, 23h34
kox2ee

Citation:

Envoyé par Patrice Henrio

C'est ce que je pensais faire. Un JPanel avec des boutons, une barre et BasicPlayer qui lit les morceaux.

Avec peut-être une classe de Lecture à part (indépendante de l'interface) si tu veux l'utiliser pour mettre de la musique dans une autre appli...

Citation:

Envoyé par kox2ee

Avec peut-être une classe de Lecture à part (indépendante de l'interface) si tu veux l'utiliser pour mettre de la musique dans une autre appli...

Donc j'ai créé une classe PlayerMP3 largement inspirée de TestBasicPLayer, une interface graphique (un panneau) JlecteurMP3 pour le côté visuel. Ma fenêtre principale n'a donc pas connaissance de PlayerMP3 et tout passe par le panneau.
Au démarrage je crée ma fenêtre avec bouton lancement. Tant que l'utilisateur n'a pas appuyé sur le bouton lancement un chant d'oiseau passe en boucle.
Pour cette phase là l'interface graphique du lecteur n'intervient pas : faut-il cependant faire passer la commande de lecture en boucle par JLecteurMP3 (mais il n'y aura pas d'affichage correspondant, seule sa capacité à communiquer avec PLayerMP3 est utilisée) ou faut-il déclarer un PLayerMP3 dans la classe de la fenêtre principale. ce questionnement en entraîne un nouveau.
A priori ma fenêtre est créée dans l'EDT et le lancement du chant (même en boucle) se fait dans un thread à part. Est-il licite, conseillé, de bonnes pratiques de démarrer un thread à partir de l'EDT, ou au contraire c'est quelque chose qu'il faut éviter.
J'espère avoir été assez clair.
Voici les classes concernées expurgées de tout ce qui ne concerne par cette question.
la classe principale qui lance le programme dans l'EDT (création de la fenêtre)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public class Main
{
	public static void main(String[] args)
	{
        javax.swing.SwingUtilities.invokeLater(new Runnable() 
        {
			public void run() 
            {
            	Fenetre fenetre = new Fenetre();
            }
        });
	}
}

Ne vaudrait-il pas mieux séparer la fenêtre des données proprement dites ? La fenêtre a cependant besoin de ces données pour se construire et celles-ci ne prennent pas beaucoup de temps processeur à s'initialiser.
Maintenant la classe de la fenêtre elle-même

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
 
public class Fenetre extends JFrame implements ActionListener, ComponentListener
{
 
	//les données et leur gestion
	private GestionDonnees gd;
	//la liste pour mélanger les oiseaux
	private ListeAMelanger lam;
 
	//le numéro de la bonne réponse, le nombre de bonnes réponses et de questions
	private int bonneReponse, nbBonnesReponses, nbQuestions;
        //le nombre de réponses possibles
        private int nbBoutons = 10;
	//Les dimensions minimales de la JFrame
	private static int largeurMin, hauteurMin;
	//la dimension des images
	private int largeurImage = 250;
	//Le texte d'informations (aide)
	private String informations = "";
 
	//Les composants
	private JPanel gauche,bas,centre;
	private Box droite, fenetre;
 
	//un panneau pour le lecteur
    private JLecteurMP3 lecteur;
    //une image d'oiseau et son chant en introduction
    private Cartouche cartouche;
 
    //les boutons de réponse
    private JButton[] boutons;
    //les boutons d'actions
    private JButton lancer, stop, langue, rejoue, aide, sonotheque, galerie;
	//un FlowLayout
	private FlowLayout fl = new FlowLayout();
 
	public Fenetre() 
	{
        //initialisation des paramètres
		gd = new GestionDonnees();
		lam = new ListeAMelanger(gd.getNbDonnees());
		lecteur = new JLecteurMP3();
	//les dimensions des composants
        .../...
    	//les composants en commençant par les plus intérieurs
        .../....
        //le cartouche dans le panneau central au démarrage 
    	//au démarrage, on affiche un cartouche d'oiseau et on entend son chant
    	lam.melanger();
    	int n = lam.getElement(0);
    	ImageChant imageChant = new ImageChant(gd.getNom(0),gd.getFichierSon(0),gd.getFichierImage(0), largeurImage);
 
 
		//les boutons portant le nom d'un oiseau dans le panneau droit (invisible au démarrage)
         .../...
 
	  	//les boutons d'actions (non focusables)
        //lancer le programme
        lancer = new JButton("Lancement");
        lancer.addActionListener (this);
	 	lancer.setFocusable(false);
	  	lancer.setToolTipText("lancement du jeu");
         //les autres boutons
          .../...	  	
	  //l'installation des composants dans la fenêtre	
          .../...
	//le panneau central qui contient gauche et droite 
        //invisibles au démarrage et une image d'oiseau 
	centre = new JPanel(fl);
	centre.setPreferredSize(new Dimension(largeurCentre, hauteurCentre));
	centre.add(gauche);
	centre.add(droite);
	centre.add(imageChant);
 
	//le panneau du bas qui contient les boutons d'action
	bas = new JPanel(fl);
	bas.setPreferredSize(new Dimension(largeurBas,hauteurBas));
	bas.add (lancer);
        .../...
        //La fenêtre
        fenetre = new Box(BoxLayout.Y_AXIS);
        fenetre.setPreferredSize(new Dimension(largeurFenetre,hauteurFenetre));
        fenetre.add (centre);
        fenetre.add (bas);
 
        //le JFrame
	getContentPane().setLayout (new GridBagLayout()) ;
	getContentPane ().add(fenetre); 
	//le titre
        setTitle("Programme de mémorisation des chants d'oiseau") ;
        setSize(largeurMin,hauteurMin);
        setLocationRelativeTo(null);
        //fermeture du programme
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	//rendre la fenetre visible
	setVisible(true);
 
    	lecteur.enBoucle(true);
    	lecteur.joue(gd.getFichierSon(0));
	}
        //méthodes de ActionListener et ComponentListener
        //méthodes liées au clic sur un des boutons
}

On aura bien compris que ma question porte sur

Code:

1
2
3
4
        //initialisation des paramètres
		gd = new GestionDonnees();
		lam = new ListeAMelanger(gd.getNbDonnees());
		lecteur = new JLecteurMP3();

au début du constructeur de la fenêtre et sur

Code:

1
2
3
 
    	lecteur.enBoucle(true);
    	lecteur.joue(gd.getFichierSon(0));

à la fin de la construction.

Faut-il déclarer ce qui ne concerne pas directement les composants graphiques dans une classe à part ou non ?

20/02/2013, 22h44
Patrice Henrio

Pour le moment les évènements passent du BasicPlayer vers le PlayerMP3 (voir réponse précédente). Comment faire passer ceux ci ensuite vers le composant graphique ?

Le composant graphique comporte une barre de progression qui doit se mettre à jour au fur et à mesure du morceau, un JSlider pour le volume, trois boutons pour le commander : run, pause, stop.
20/02/2013, 23h56
kox2ee

Bonjour,
je ne suis pas certain d'avoir tout saisi, notamment la première partie de l'explication, où tu parles de JlecteurMP3 et PLayerMP3.
Mais je tente quand même des réponses, qui risquent d'être un peu à côté...

Je ne ferai pas passer le chant en boucle par le lecteur MP3, si le lecteur est visuel, et destiné à être piloté par l'utilisateur.
Le chant en boucle peut par exemple être désactivé dans les options de l'application.

Par rapport au Thread, je n'ai pas connaissance qu'il soit interdit d'en démarrer à partir de l'EDT, l'essentiel est qu'il respecte la mise à jour de l'interface en passant par le invokeLater.

Sinon, je pense qu'il est normal que l'interface fasse référence à des instances qu'elle va permettre de piloter (1 lecteur, une gestion de données). L'essentiel est qu'à l’inverse, les classes correspondant à ces instances ne connaissent pas l'interface.

Les seules données dont la déclaration est suspecte sont celles là :

Citation:

private int bonneReponse, nbBonnesReponses, nbQuestions;

On peut se demander pourquoi c'est l'interface qui les déclare, alors que ce sont des "données métier" (relatives à ce qu'il y a à gérer)
21/02/2013, 03h02
Patrice Henrio

Citation:

Envoyé par kox2ee

Bonjour,
je ne suis pas certain d'avoir tout saisi, notamment la première partie de l'explication, où tu parles de JlecteurMP3 et PLayerMP3.
Mais je tente quand même des réponses, qui risquent d'être un peu à côté...

JLecteurMP3 est le côté interface graphique (le visuel), PLayerMP3 est le "métier"

Citation:

Je ne ferai pas passer le chant en boucle par le lecteur MP3, si le lecteur est visuel, et destiné à être piloté par l'utilisateur.
Le chant en boucle peut par exemple être désactivé dans les options de l'application.

comment ferais-tu dans le principe. Pour moi la suppression du chant en boucle devrait revenir au JLecteurMP3 qui est aussi une Interface graphique réagissant aux actions de l'utilisateur (boutons play, stop et pause, on peut même rajouter un bouton boucle)

Citation:

Par rapport au Thread, je n'ai pas connaissance qu'il soit interdit d'en démarrer à partir de l'EDT, l'essentiel est qu'il respecte la mise à jour de l'interface en passant par le invokeLater.

Sinon, je pense qu'il est normal que l'interface fasse référence à des instances qu'elle va permettre de piloter (1 lecteur, une gestion de données). L'essentiel est qu'à l’inverse, les classes correspondant à ces instances ne connaissent pas l'interface.

ça c'est OK

Citation:

Les seules données dont la déclaration est suspecte sont celles là :
private int bonneReponse, nbBonnesReponses, nbQuestions;
On peut se demander pourquoi c'est l'interface qui les déclare, alors que ce sont des "données métier" (relatives à ce qu'il y a à gérer)

[/QUOTE]
parce qu'elles ne sont utilisées que dans l'interface : l'appui sur un bouton de réponse augmente le nombre de réponses et si on a trouvé la bonne réponse on augmente en plus les bonnes réponses. L'appui sur le bouton arrêt (de la fenêtre pas du lecteur) déclenche l'affichage du résultat sous forme d'un pourcentage de bonnes réponses.
Quant à bonne réponse c'est le numéro de la bonne réponse parmi les 10 proposées.
21/02/2013, 03h40
kox2ee

Citation:

Envoyé par Patrice Henrio

comment ferais-tu dans le principe. Pour moi la suppression du chant en boucle devrait revenir au JLecteurMP3 qui est aussi une Interface graphique réagissant aux actions de l'utilisateur (boutons play, stop et pause, on peut même rajouter un bouton boucle)

Oui, tu connais mieux tes spécifications que moi

Citation:

Envoyé par Patrice Henrio

parce qu'elles ne sont utilisées que dans l'interface : l'appui sur un bouton de réponse augmente le nombre de réponses et si on a trouvé la bonne réponse on augmente en plus les bonnes réponses. L'appui sur le bouton arrêt (de la fenêtre pas du lecteur) déclenche l'affichage du résultat sous forme d'un pourcentage de bonnes réponses.
Quant à bonne réponse c'est le numéro de la bonne réponse parmi les 10 proposées.

Même chose, je ne connais pas assez ton sujet pour être aussi affirmatif que toi.
La question est : et si tu devais maintenant faire une version de ton programme pour le faire fonctionner avec une autre interface (en mode console par exemple), n'aurais tu pas à refaire une partie de sa logique métier ? ce que je veux dire, c'est que même s'il n'y a plus de boutons ou de fenêtre, il doit rester les questions, les bonnes réponses et tout ce qui va avec.
21/02/2013, 08h37
Patrice Henrio

Je trouve qu'en général mes programmes ne prennent pas assez en compte ce découpage en MVC.
Si possible. quand ce sera fini, je serai bien intéressé par une critique sous cet angle du résultat.
21/02/2013, 23h12
Patrice Henrio

Citation:

Envoyé par kox2ee

La question est : et si tu devais maintenant faire une version de ton programme pour le faire fonctionner avec une autre interface (en mode console par exemple), n'aurais tu pas à refaire une partie de sa logique métier ? ce que je veux dire, c'est que même s'il n'y a plus de boutons ou de fenêtre, il doit rester les questions, les bonnes réponses et tout ce qui va avec.

Justement la question se pose actuellement puisque j'ai fait le programme avec des images d'oiseaux et donc une certaine interface et maintenant avec les chants d'oiseaux et je m'aperçois qu'il faut que je change pas mal de choses. En fait j'ai beaucoup de mal à faire des choses réutilisables en l'état. Je dois toujours changer quelque chose.
22/02/2013, 13h24
kox2ee

Bonjour,
oui, même sur de petits projets, il faudrait toujours se contraindre à faire une petite analyse avant de commencer à coder, puis à implémenter toutes les classes métiers (avec tests unitaires) avant d'interfacer quoique ce soit...
Mais il y a la théorie, et la pratique.