Subversion Repositories Code-Repo

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
90 Kevin 1 
package ioio.debugger;
2 
 
3 
import java.util.List;
4 
 
5 
import ioio.debugger.NetworkIOIOProtocol.Message;
6 
import ioio.debugger.NetworkIOIOProtocol.Message.Builder;
7 
import ioio.debugger.NetworkIOIOProtocol.TrackingMessage;
8 
 
9 
import org.jboss.netty.channel.Channel;
10 
 
11 
import android.os.Handler;
12 
 
13 
public class NetworkClientConnectionHandler implements NetworkMessageHandler<TrackingMessage> {
14 
 
15 
	// Message handler for sending messages to server
16 
	private NetworkClientHandler<NetworkIOIOProtocol.TrackingMessage> msgHandler_;
17 
 
18 
	private Boolean connected_ = false;
19 
	private boolean connectionOk_ = false;
20 
	private long reconnectInterval_ = 3000;
21 
	private boolean autoReconnect_ = false;
22 
	private String server_;
23 
	private int port_;
24 
	private IOIODebuggerActivity parent_;
25 
	private Thread connection_;
26 
	private Handler handler_ = new Handler();
27 
 
28 
	public NetworkClientConnectionHandler(IOIODebuggerActivity parent) {
29 
		parent_ = parent;
30 
		connection_ = new Thread();
31 
	}
32 
 
33 
	public void setConnectionSettings(final String server, final int port, final boolean autoReconnect, final long reconnectInterval) {
34 
		handler_.post(new Runnable() {
35 
 
36 
			@Override
37 
			public void run() {
38 
				server_ = server;
39 
				port_ = port;
40 
				autoReconnect_ = autoReconnect;
41 
				reconnectInterval_ = reconnectInterval;
42 
			}
43 
		});
44 
	}
45 
 
46 
	@Override
47 
	public void channelException(Throwable e) {
48 
		synchronized (connected_) {
49 
			parent_.updateServerStatus("Exception occured contacting server");
50 
			connected_ = false;
51 
			connectionOk_ = false;
52 
		}
53 
	}
54 
 
55 
	@Override
56 
	public void channelClosed(Channel c) {
57 
		synchronized (connected_) {
58 
			parent_.updateServerStatus("Connection to server closed");
59 
			connected_ = false;
60 
			connectionOk_ = false;
61 
		}
62 
	}
63 
 
64 
	@Override
65 
	public void received(final TrackingMessage msg) {
66 
		handler_.post(new Runnable() {
67 
 
68 
			@Override
69 
			public void run() {
70 
				List<Message> messageList;
71 
				switch(msg.getType()) {
72 
				case 11:
73 
					parent_.updateServerStatus("Connected to server  [ " + server_ + " :: " + port_ + " ]");
74 
					connectionOk_ = true;
75 
					parent_.sendAllData();
76 
					break;
77 
				case 12:
78 
					parent_.updateServerStatus("Connection to server rejected. Try again?");
79 
					disconnectFromServer();
80 
					break;
81 
				case 13:
82 
					parent_.hardReset();
83 
					break;
84 
				case 50:
85 
					messageList = msg.getMessageList();
86 
					for (Message message : messageList) {
87 
						String type = message.getType();
88 
						if (type.compareTo("InAnalog") == 0) {
89 
							CreateWidget.addIA(message.getPin(), message.getFreq());
90 
							parent_.processAddWidget(IOIODebuggerActivity.ACTIVITY_INPUT_ANALOG);
91 
						} else if (type.compareTo("InDigital") == 0) {
92 
							CreateWidget.addID(message.getPin(), message.getFreq(), message.getMode());
93 
							parent_.processAddWidget(IOIODebuggerActivity.ACTIVITY_INPUT_DIGITAL);
94 
						} else if (type.compareTo("OutDigital") == 0) {
95 
							CreateWidget.addOD(message.getPin(), message.getMode(), message.getBoolean());
96 
							parent_.processAddWidget(IOIODebuggerActivity.ACTIVITY_OUTPUT_DIGITAL);
97 
						}
98 
					}
99 
					break;
100 
				case 51:
101 
					messageList = msg.getMessageList();
102 
					for (Message message : messageList) {
103 
						parent_.stopViewWidget(message.getPin());
104 
					}
105 
					break;
106 
				case 52:
107 
					messageList = msg.getMessageList();
108 
					for (Message message : messageList) {
109 
						parent_.removeViewWidget(message.getPin());
110 
					}
111 
				}
112 
			}
113 
		});
114 
	}
115 
 
116 
	@SuppressWarnings("unchecked")
117 
	public boolean connectToServer() {
118 
 
119 
		try {
120 
			synchronized (connected_) {
121 
				if (connected_)
122 
					return true;
123 
 
124 
				parent_.updateServerStatus("Connecting to server...");
125 
 
126 
				msgHandler_ = NetworkClient.connect(server_, port_);
127 
				msgHandler_.setListener(this);
128 
				connected_ = true;
129 
 
130 
				// Wait a bit for the connection to finish initialization
131 
				Thread.sleep(500);
132 
 
133 
				// Queries if connection is ok
134 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
135 
						.setId(0)
136 
						.setType(10)
137 
						.build();
138 
 
139 
				msgHandler_.send(newMsg);
140 
			}
141 
			return true;
142 
		} catch (Exception e) {
143 
			parent_.updateServerStatus("Unable to connect to server");
144 
			return false;
145 
		}
146 
 
147 
	}
148 
 
149 
	private class ConnectWorker implements Runnable {
150 
 
151 
		public void run() {
152 
			doConnect();
153 
		}
154 
 
155 
		public void doConnect() {
156 
			try {
157 
				if (!connectToServer()) {
158 
					while (autoReconnect_ && !connectToServer()) {
159 
						parent_.updateServerStatus("Waiting to reconnect to server...");
160 
						Thread.sleep(reconnectInterval_);
161 
					}
162 
				}
163 
			} catch (Exception e) {
164 
				doConnect();
165 
			}
166 
		}
167 
	}
168 
 
169 
	public void startConnect() {
170 
		handler_.post(new Runnable() {
171 
 
172 
			@Override
173 
			public void run() {
174 
				ConnectWorker w = new ConnectWorker();
175 
				connection_ = new Thread(w);
176 
				connection_.start();
177 
			}
178 
		});
179 
	}
180 
 
181 
	public void stopAutoReconnect() {
182 
		autoReconnect_ = false;
183 
	}
184 
 
185 
	public void disconnectFromServer() {
186 
		synchronized (connected_) {
187 
			connected_ = false;
188 
			connectionOk_ = false;
189 
			autoReconnect_ = false;
190 
			msgHandler_.disconnect();
191 
			parent_.updateServerStatus("Disconnected from server");
192 
		}
193 
	}
194 
 
195 
	public Boolean isConnected() {
196 
		return connected_;
197 
	}
198 
 
199 
	public boolean connectedOk() {
200 
		return connectionOk_;
201 
	}
202 
 
203 
 
204 
	public void notifyACK_Success() {
205 
		handler_.post(new Runnable() {
206 
 
207 
			@Override
208 
			public void run() {
209 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
210 
						.setId(0)
211 
						.setType(1)
212 
						.build();
213 
 
214 
				msgHandler_.send(newMsg);
215 
			}
216 
		});
217 
	}
218 
 
219 
	public void notifyACK_Failure() {
220 
		handler_.post(new Runnable() {
221 
 
222 
			@Override
223 
			public void run() {
224 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
225 
						.setId(0)
226 
						.setType(2)
227 
						.build();
228 
 
229 
				msgHandler_.send(newMsg);
230 
			}
231 
		});
232 
	}
233 
 
234 
	public void notifyStartIA(final int pin, final long freq) {
235 
		handler_.post(new Runnable() {
236 
 
237 
			@Override
238 
			public void run() {
239 
				Builder message = Message.newBuilder()
240 
						.setPin(pin)
241 
						.setFreq(freq)
242 
						.setType("InAnalog");
243 
 
244 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
245 
						.setId(0)
246 
						.setType(50)
247 
						.addMessage(message)
248 
						.build();
249 
 
250 
				msgHandler_.send(newMsg);
251 
			}
252 
		});
253 
	}
254 
 
255 
	public void notifyStartID(final int pin, final long freq, final String mode) {
256 
		handler_.post(new Runnable() {
257 
 
258 
			@Override
259 
			public void run() {
260 
				Builder message = Message.newBuilder()
261 
						.setPin(pin)
262 
						.setFreq(freq)
263 
						.setMode(mode)
264 
						.setType("InDigital");
265 
 
266 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
267 
						.setId(0)
268 
						.setType(50)
269 
						.addMessage(message)
270 
						.build();
271 
 
272 
				msgHandler_.send(newMsg);
273 
			}
274 
		});
275 
	}
276 
 
277 
	public void notifyStartOD(final int pin, final String state, final boolean openDrain) {
278 
		handler_.post(new Runnable() {
279 
 
280 
			@Override
281 
			public void run() {
282 
				Builder message = Message.newBuilder()
283 
						.setPin(pin)
284 
						.setState(state)
285 
						.setBoolean(openDrain)
286 
						.setType("OutDigital");
287 
 
288 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
289 
						.setId(0)
290 
						.setType(50)
291 
						.addMessage(message)
292 
						.build();
293 
 
294 
				msgHandler_.send(newMsg);
295 
			}
296 
		});
297 
	}
298 
 
299 
	public void notifyStopPin(final int pin) {
300 
		handler_.post(new Runnable() {
301 
 
302 
			@Override
303 
			public void run() {
304 
				Builder message = Message.newBuilder()
305 
						.setPin(pin);
306 
 
307 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
308 
						.setId(0)
309 
						.setType(51)
310 
						.addMessage(message)
311 
						.build();
312 
 
313 
				msgHandler_.send(newMsg);
314 
			}
315 
		});
316 
	}
317 
 
318 
	public void notifyRemovePin(final int pin) {
319 
		handler_.post(new Runnable() {
320 
 
321 
			@Override
322 
			public void run() {
323 
				Builder message = Message.newBuilder()
324 
						.setPin(pin);
325 
 
326 
				TrackingMessage newMsg = TrackingMessage.newBuilder()
327 
						.setId(0)
328 
						.setType(52)
329 
						.addMessage(message)
330 
						.build();
331 
 
332 
				msgHandler_.send(newMsg);
333 
			}
334 
		});
335 
	}
336 
 
337 
	public void sendData(final int pin, final Double[] data) {
338 
		handler_.post(new Runnable() {
339 
 
340 
			@Override
341 
			public void run() {
342 
				ioio.debugger.NetworkIOIOProtocol.TrackingMessage.Builder newMsg = TrackingMessage.newBuilder()
343 
						.setId(0)
344 
						.setType(70);
345 
 
346 
				Builder message = Message.newBuilder().setPin(pin);
347 
				for (double d : data) {
348 
					message.addData(d);
349 
				}
350 
 
351 
				newMsg.addMessage(message);
352 
				msgHandler_.send(newMsg.build());
353 
			}
354 
		});
355 
	}
356 
}