Discussion :

[Happpy]

Bonjour,

j'utilise JLayer (un .jar) pour lire des musiques .mp3.
J'ai implémenté cette classe et j'aimerais avoir quelques avis ^^' :

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
 
//POUR LA LECTURE D'UNE MUSIQUE .MP3
//LE TRAITEMENT EST TRES SIMPLE, CEPENDANT
//UNE FOIS QU'ON ARRETE UNE CHANSON, IL FAUT DESALLOUER L'INSTANCE MusiqueMP3 DU CODE QUI L'A
//INSTANCIE ET EN REALLOUER UNE NOUVELLE CAR ON NE PEUT PAS METTRE UNE MUSIQUE EN PAUSE
public class MusiqueMP3 {
	private String cheminFichier; 
	private boolean lireEnBoucle; //Pour savoir si la musique doit être lue en boucle ou non
	private Player lecteur; //Pour la lecture du fichier
	private Thread thread; //Thread utilisé pour la lecture de la musique
 
	public MusiqueMP3(String cheminFichier, boolean lireEnBoucle) {
		super();
		setCheminFichier(cheminFichier);
		setLireEnBoucle(lireEnBoucle);
		FileInputStream fichier = null;
		try {
			fichier = new FileInputStream(this.cheminFichier);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			lecteur = new Player(fichier);
		} catch (JavaLayerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//THREAD DE LA METHODE lire()
		initThread();
	}
 
	//INITIALISER/REINITIALISER LE THREAD DE LECTURE
	public void initThread() {
		this.thread = new Thread() { 
	        public void run() {
	        	try {
	        		lecteur.play(); //On lit la musique au moins une fois
	        		//LOOP?
	        		while(isLireEnBoucle() && lecteur.isComplete()) { //Si on termine la lecture de la musique
	        			lecteur.close();
	        			lecteur.play();
	        		}
	        	} catch (JavaLayerException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
	        }
	    };
	}
 
	//POUR LIRE LE FICHIER
	public void lire() {
	    thread.start();
	}
 
	//POUR ARRETER LA LECTURE
	public void arreter() {
		if(thread.isAlive()) {
			thread.interrupt();
			lecteur.close();
		}
	}
 
	public boolean isLireEnBoucle() {
		return lireEnBoucle;
	}
 
	public void setLireEnBoucle(boolean lireEnBoucle) {
		this.lireEnBoucle = lireEnBoucle;
	}
 
	public Thread getThread() {
		return thread;
	}
 
	public void setThread(Thread thread) {
		this.thread = thread;
	}
 
	public String getCheminFichier() {
		return cheminFichier;
	}
 
	public void setCheminFichier(String cheminFichier) {
		this.cheminFichier = cheminFichier;
	}
 
	public Player getLecteur() {
		return lecteur;
	}
 
	public void setLecteur(Player lecteur) {
		this.lecteur = lecteur;
	}
}

Le défaut ici est qu'on ne peut pas mettre la musique en pause (même si j'en aurais pas besoin pour l'utilisation que je vais en faire) et je n'arrive pas à lire la musique en boucle ^^'

J'ai entendu parler de la Java Media Framework mais je ne sais pas s'il est préférable de l'utiliser à la place de JLayer ou non...
De plus, d'après ce que j'ai vu c'est un installateur pour Windows, Linux, ... C'est donc pas un .jar...?



Merci d'avance pour vos avis... ^^'

[joel.drigo]

Salut,

Oubli JMF, c'est une vieille technologie abandonnée (et lourde à utiliser).

Avec JLayer, pause le thread :

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
public class PlayerThread extends Thread {
 
   private volatile boolean playMusic=true;
   private volatile boolean pauseMusic=false;
   private final Thread threadThis;
   public PlayerThread(String filename) {
     super("Thread playing " + filename);
      this.filename=filename;
      threadThis=this;
  }
 
  public void close() {
      playMusic=false;     
      interrupt();
  }
 
  public void pause() {
      pauseMusic=true;
  }
 
  public void resume() {
      if ( pauseMusic ) {
         pauseMusic=false;
         LockSupport.unpark(threadThis);
    }    
  }
 
  public boolean isPaused() {
     return pauseMusic;
  }
 
  public boolean isCompleted() {
     return !playMusic;
  }
 
  public void run() {
 
     try(FileInputStream inputStream = new FileInputStream(filename)) {
         Player player = new Player(inputStream);
         try {
             while (playMusic && player.play(1)) {
                if(pauseMusic) {
                   LockSupport.park();
                   if ( interrupted() {
                         playMusic=false;
                   }
                }
             }
         }
         finally {
              player.close();
         }
     }
     catch(IOException | JavaLayerException e) {
        e.printStackTrace();
     }
     playMusic=false;
 
  }
 
}

[Happpy]

Bonjour, je ne regarde le code que maintenant, je n'ai pas pu avant par manque de temps ^^'

Je regarde ça en détail !
Merci !


Edit : je ne veux pas mettre la musique en pause mais juste la lire totalement puis ou non recommencer la lecture pour un loop.
Le problème est résolu, il suffit de modifier initThread() comme ceci :

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
 
public void initThread() {
		this.thread = new Thread() { 
			public void run() {
				try {
					lecteur.play(); //On lit la musique au moins une fois
					//LOOP?
					while(true) {
						while(isLireEnBoucle() && lecteur.isComplete()) { //Si on termine la lecture de la musique
							lecteur.close();
							initLecteur(cheminFichier); //On doit forcément reseter l'objet pour
								//recommencer la lecture...
							lecteur.play();
						}
					}
				} catch (JavaLayerException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
	}

Sujet résolu, la lecture recommence bien en boucle lorsque la musique se termine.