Page web dynamique en fonction de l'ecoute d'un port

J'ai créé un objet qui étends Thread et implémente SerialPortEventListener, le but de cet objet est d'ecouter le port com et d'affecter des propriété en fonction.
J'ai ensuite une classe action qui instancie cet objet. Je souhaite que tant que cet objet isAlive() et que mes propriétés ne sont pas null que ça me renvoie ces propriétés pour que dans ma classe action je redirige vers la JSP en ajoutant ces propriétés aux attributs de la requetes.

Le problème c'est que je suis obligé de faire un return dans ma boucle while(thread.isAlive) je sort donc de ma boucle et quand il y a nouveau un changement sur le port com je ne peux plus le traiter.

Voici ma classe action

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
 
public class TestComAction extends Action {
 
	public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest req, HttpServletResponse rep) {
		ActionForward action = null;
		action = lectureCom();
		if(action.getProperty("numProg") != null && action.getProperty("numProg") != ""){
			if(action.getProperty("numSeq") != null && action.getProperty("numSeq") != ""){
				req.setAttribute("modeActive", "true");
			}
		}
		if(action == null){
			action = mapping.findForward("succes");
		}
		return action;
	}
 
 
	public ActionForward lectureCom() {
 
		ActionForward action = null;
		// Récuperation du port en argument
		String port = "COM1";
		// lancement de l'appli
		EcouteurCom ecoutCom = new EcouteurCom(port);
		ecoutCom.start();
 
		while(ecoutCom.isAlive()){
			if(ecoutCom.getAction() != null){
				if(ecoutCom.getAction().getProperty("numProg") != null && ecoutCom.getAction().getProperty("numSeq") != null){
					action = ecoutCom.getAction();
					return action;
				}
			}
		}
		// "interface utilisateur"
		System.out.println("taper q pour quitter");
		// construction flux lecture
		BufferedReader clavier = new BufferedReader(new InputStreamReader(
				System.in));
		// lecture sur le flux entrée.
		try {
			String lu = clavier.readLine();
			while (!lu.equals("q")) {
				if(ecoutCom.getAction() != null){
					action = ecoutCom.getAction();
					return action;
				}
			}
		} catch (IOException e) {
		}
		ecoutCom.stopThread();
		return action;
	}
}

Et ma classe thread

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
 
public class EcouteurCom extends Thread implements SerialPortEventListener {
 
	private CommPortIdentifier portId;
 
	private SerialPort serialPort;
 
	private BufferedReader fluxLecture;
 
	private ActionForward action;
 
	private boolean running;
 
	/**
         *
         */
	public EcouteurCom() {
		// TODO Auto-generated constructor stub
	}
 
 
	/**
         * @param name
         */
	public EcouteurCom(String port) {
 
		// initialisation du driver
		Win32Driver w32Driver = new Win32Driver();
		w32Driver.initialize();
		// récupération de l'identifiant du port
		try {
			portId = CommPortIdentifier.getPortIdentifier(port);
		} catch (NoSuchPortException e) {
		}
		// ouverture du port
		try {
			serialPort = (SerialPort) portId.open("EcouteurCom", 2000);
		} catch (PortInUseException e) {
		}
		// récupération du flux
		try {
			fluxLecture = new BufferedReader(new InputStreamReader(serialPort
					.getInputStream()));
		} catch (IOException e) {
			e.printStackTrace();
		}
		// ajout du listener
		try {
			serialPort.addEventListener(this);
		} catch (TooManyListenersException e) {
		}
		// paramétrage du port
		serialPort.notifyOnDataAvailable(true);
		try {
			serialPort.setSerialPortParams(9600, SerialPort.DATABITS_7,
					SerialPort.STOPBITS_1, SerialPort.PARITY_EVEN);
		} catch (UnsupportedCommOperationException e) {
		}
		System.out.println("port ouvert, attente de lecture");
	}
 
	// Méthode appelé quand on fait thread.start
	public void run() {
		running = true;
		while (running) {
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
			}
		}
		// fermeture du flux et port
		try {
			fluxLecture.close();
		} catch (IOException e) {
		}
		serialPort.close();
	}
 
	/*
	 * (non-Javadoc)
	 *
	 * @see javax.comm.SerialPortEventListener#serialEvent(javax.comm.SerialPortEvent)
	 */
	public void serialEvent(SerialPortEvent event) {
		// gestion des événements sur le port :
		// on ne fait rien sauf quand les données sont disponibles
		switch (event.getEventType()) {
			case SerialPortEvent.BI:
			case SerialPortEvent.OE:
			case SerialPortEvent.FE:
			case SerialPortEvent.PE:
			case SerialPortEvent.CD:
			case SerialPortEvent.CTS:
			case SerialPortEvent.DSR:
			case SerialPortEvent.RI:
			case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
				break;
			case SerialPortEvent.DATA_AVAILABLE:
				String codeBarre = new String();
				try {
					// lecture du buffer et affichage
					codeBarre = (String) fluxLecture.readLine();
					System.out.println(codeBarre);
					String[] tabCodes = codeBarre.split(";");
 
					if(tabCodes.length >= 2){
						String numProg = tabCodes[0];
						String numSeq = tabCodes[1];
						//TODO tester si le programme et la séquence existe
						this.action = new ActionForward("/accueil.do");
						this.action.setProperty("numProg", numProg);
						this.action.setProperty("numSeq", numSeq);
 
					}
				} catch (IOException e) {
				}
				break;
		}
	}
 
	/**
         * Permet l'arrêt du thread
         */
	public void stopThread() {
		running = false;
	}
 
 
	/**
         * @return the action
         */
	public ActionForward getAction() {
		return action;
	}
 
 
	/**
         * @param action the action to set
         */
	public void setAction(ActionForward action) {
		this.action = action;
	}
 
}