KeyReleased et MouseReleased

1/ Déjà revenons a l'essentiel :

Code:

1
2
3
4
for (int i = 0; i < buttons.length; i++) {
            buttons[i].setOnMousePressed(event -> System.out.println("Mouse pressed"));
            buttons[i].setOnMouseReleased(event -> System.out.println("Mouse released"));
}

Même en laissant le doigt appuyé sur le bouton de la souris, on a juste un événement de chaque et la sortie est :

Code:

1
2
Mouse pressed
Mouse released

Coté clavier :

Code:

1
2
        titledPanes[0].setOnKeyPressed(event -> System.out.println("Key pressed"));
        titledPanes[0].setOnKeyReleased(event -> System.out.println("Key released"));

C'est un peu différent :

Code:

1
2
3
4
5
6
7
8
9
10
Key pressed
Key pressed
Key pressed
Key pressed
Key pressed
Key pressed
[...]
Key pressed
Key pressed
Key released

Donc déjà ta boucle et la méthode startNote() vont être invoquées de nombreuses fois même si au final une même note n'est insérée qu'une seule fois.
Après, j'ai bien événement Key released qui est envoyé mais de la a savoir s'il fonctionne comme prévu...

2/ Au niveau structuration, je pense qu'il faut que tu revoie un peu ta méthode d’interaction avec le Player et sa liste de notes. Notamment il ne me semble pas normal que la synchronisation sur la liste des notes soit fait dans App alors que ça devrait être fait dans le Player lui-même en interne.

Je pense notamment a un truc du genre (et je peux totalement me planter par rapport a ce que tu veux faire) :

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
 private List<Note> currentNotes;
    private List<Note> currentNotesReadOnly;
 
[...]
        currentNotes = Collections.synchronizedList(new ArrayList<>());
        currentNotesReadOnly = Collections.unmodifiableList(currentNotes);
[...]
 
    public List<Note> getCurrentNotes() {
        return currentNotesReadOnly;
    }
 
    public void addNote(Note note) {
        synchronized (currentNotes) {
            currentNotes.add(note);
        }
        note.play();
    }
 
     public void stopNote(int tone) {
        synchronized (currentNotes) {
            final List<Note> toRemove = currentNotes.stream()
                    .filter(note -> note.getTone() == tone)
                    .collect(Collectors.toList());
            currentNotes.removeAll(toRemove);
            toRemove.stream()
                    .forEach(Note::stop);
            System.out.printf("Removed %d note(s)", toRemove.size());
        }
    }
 
    public void playCurrentNotes() {
        synchronized (currentNotes) {
            total = 0.0;
            currentNotes.forEach(note -> {
                        if (!note.isFinish()) {
                            double noteTime = note.getTimer().getTimeElapsed();
 
                            double positionRatioPerSecond = note.getPositionNIncr() / 44100.0;
 
                            double angle = positionRatioPerSecond * soundProductionSystem.calculateNoteFrequency(note.getTone()) * 2.0 * Math.PI;
 
                            facteurAmpl = note.getEnveloppe().getVolume(noteTime);
 
                            double ampl = 32767f * facteurAmpl;
 
                            switch (note.getWaveform()) {
                                case SIN: // SIN
                                    total += (Math.sin(angle) * ampl);  //32767 - max value for sample to take (-32767 to 32767)
                                    break;
                                case RECT: // RECT
                                    total += (Math.signum(Math.sin(angle)) * ampl);  //32767 - max value for sample to take (-32767 to 32767)
                                case SAWTOOTH: // SAWTOOTH LINEAR
                                    total += ((1 - angle / 2 * Math.PI) * ampl);  //32767 - max value for sample to take (-32767 to 32767)
                                case TRI: // TRIANGLE LINEAR
                                    total += ((1 - Math.abs(angle / 2 * Math.PI) * ampl));  //32767 - max value for sample to take (-32767 to 32767)
                                default: // SIN
                                    total += (Math.sin(angle) * ampl);  //32767 - max value for sample to take (-32767 to 32767)
                                    break;
 
                            }
                        }
                    }
            );
            total /= currentNotes.size() > 0 ? currentNotes.size() : 1;
 
            if (currentNotes.size() > 0) {
 
                audioViewer.sendDouble(total);
                audioViewer.sendDouble(total);
 
                short amplitude = (short) (total * volume / 100.0);
                //System.out.println(amplitude);
 
                playBuffer(amplitude);
            } else {
                //audioViewer.sendDouble(0.0);
                //audioViewer.sendDouble(0.0);
            }
        }
    }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    private void playNote(Button source) {
        System.out.println("Tone:  " + getTone(source) + "  Note :"
                + ((Button) source).getText() + "  "
                + "Octave: " + (int) slider.getValue());
        Note note = noteMap.get(getTone(source));
        assert note != null;
        note.setWaveform(player.getForm());
        assert note != null;
        if (!player.getCurrentNotes().contains(note)) {
            Platform.runLater(() -> player.addNote(note));
        }
    }
 
    private void stopNote(Button source) {
        Note note = noteMap.get(getTone(source));
        assert note != null;
        System.out.println(note.getTimer().getTimeElapsed());
        Platform.runLater(() -> player.stopNote(note.getTone()));
        System.out.println("Key pressed: " + player.getCurrentNotes().size());
    }

3/ Quand la gestion du touch, si tu veux unifier avec la souris tu peux peut-être aussi directement tenter de faire :

Code:

1
2
3
4
5
6
7
8
9
10
for (int i = 0; i < buttons.length; i++) {
            final Button button = buttons[i];
            buttons[i].armedProperty().addListener((observable, oldValuem, newValue) -> {
                if (newValue) {
                    playNote(button);
                } else {
                    stopNote(button);
                }
            });
        }

Mais oui il faudrait aussi confirmer que ça fonctionne correctement sur un vrai touch screen car je ne suis pas sur que ce soit le cas !

4/ au niveau fonctionnel, je peux juste donner un avis sur la boucle run() du Player qui bouffe 100% du temps CPU. J'ai essaye de ménager un temps de repos dans cette boucle mais ça semble gêner la sortie sonore (encore une fois je ne suis pas sur si la manière dont je m'y prend est correcte par rapport a ce que tu veux faire).

Il faudrait peut-être déclarer la variable playing en volatile puisqu'elle va être accédée depuis plusieurs threads (en gros c'est comme si on mettait un bloc synchronized autour de chacun de ses accès). Sinon mettre le setter et le getter de cette variable en synchronized.

Code:

private volatile boolean playing;

Et il me semble qu'il serait bon de nettoyer la liste après avoir invoque playCurrentNotes() histoire de retirer les notes qui sont terminées.

Code:

1
2
3
4
while (isPlaying() {
    playCurrentNotes();
    removeFinishedNotes();
}