diff --git a/ClientApp/App.xaml b/ClientApp/App.xaml
new file mode 100644
index 0000000..1400927
--- /dev/null
+++ b/ClientApp/App.xaml
@@ -0,0 +1,18 @@
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ClientApp/App.xaml.cs b/ClientApp/App.xaml.cs
new file mode 100644
index 0000000..03d8e97
--- /dev/null
+++ b/ClientApp/App.xaml.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace ClientApp
+{
+ ///
+ /// Interaction logic for App.xaml
+ ///
+ public partial class App : Application
+ {
+ }
+}
diff --git a/ClientApp/AssemblyInfo.cs b/ClientApp/AssemblyInfo.cs
new file mode 100644
index 0000000..8b5504e
--- /dev/null
+++ b/ClientApp/AssemblyInfo.cs
@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+ ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
+ //(used if a resource is not found in the page,
+ // or application resource dictionaries)
+ ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
+ //(used if a resource is not found in the page,
+ // app, or any theme specific resource dictionaries)
+)]
diff --git a/ClientApp/ClientApp.csproj b/ClientApp/ClientApp.csproj
new file mode 100644
index 0000000..d8ae036
--- /dev/null
+++ b/ClientApp/ClientApp.csproj
@@ -0,0 +1,23 @@
+
+
+
+ WinExe
+ netcoreapp3.1
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/ClientApp/FodyWeavers.xml b/ClientApp/FodyWeavers.xml
new file mode 100644
index 0000000..d5abfed
--- /dev/null
+++ b/ClientApp/FodyWeavers.xml
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/ClientApp/FodyWeavers.xsd b/ClientApp/FodyWeavers.xsd
new file mode 100644
index 0000000..69dbe48
--- /dev/null
+++ b/ClientApp/FodyWeavers.xsd
@@ -0,0 +1,74 @@
+
+
+
+
+
+
+
+
+
+
+ Used to control if the On_PropertyName_Changed feature is enabled.
+
+
+
+
+ Used to control if the Dependent properties feature is enabled.
+
+
+
+
+ Used to control if the IsChanged property feature is enabled.
+
+
+
+
+ Used to change the name of the method that fires the notify event. This is a string that accepts multiple values in a comma separated form.
+
+
+
+
+ Used to control if equality checks should be inserted. If false, equality checking will be disabled for the project.
+
+
+
+
+ Used to control if equality checks should use the Equals method resolved from the base class.
+
+
+
+
+ Used to control if equality checks should use the static Equals method resolved from the base class.
+
+
+
+
+ Used to turn off build warnings from this weaver.
+
+
+
+
+ Used to turn off build warnings about mismatched On_PropertyName_Changed methods.
+
+
+
+
+
+
+
+ 'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed.
+
+
+
+
+ A comma-separated list of error codes that can be safely ignored in assembly verification.
+
+
+
+
+ 'false' to turn off automatic generation of the XML Schema file.
+
+
+
+
+
\ No newline at end of file
diff --git a/ClientApp/Models/Info.cs b/ClientApp/Models/Info.cs
new file mode 100644
index 0000000..e976bda
--- /dev/null
+++ b/ClientApp/Models/Info.cs
@@ -0,0 +1,14 @@
+using ClientApp.Utils;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ClientApp.Models
+{
+ class Info : ObservableObject
+ {
+ public bool ConnectedToServer { get; set; }
+ public bool ConnectedToVREngine { get; set; }
+ public bool DoctorConnected { get; set; }
+ }
+}
diff --git a/ClientApp/Utils/Client.cs b/ClientApp/Utils/Client.cs
new file mode 100644
index 0000000..8dd0ad1
--- /dev/null
+++ b/ClientApp/Utils/Client.cs
@@ -0,0 +1,291 @@
+using System;
+using System.Linq;
+using System.Net.Sockets;
+using System.Text;
+using ClientApp.ViewModels;
+using ProftaakRH;
+
+namespace ClientApp.Utils
+{
+ public class Client : IDataReceiver
+ {
+ private TcpClient client;
+ private NetworkStream stream;
+ private byte[] buffer = new byte[1024];
+ private bool connected;
+ private byte[] totalBuffer = new byte[1024];
+ private int totalBufferReceived = 0;
+ private EngineConnection engineConnection;
+ private bool sessionRunning = false;
+ private IHandler handler = null;
+ private LoginViewModel LoginViewModel;
+
+
+ public Client() : this("localhost", 5555)
+ {
+
+ }
+
+ public Client(string adress, int port)
+ {
+ this.client = new TcpClient();
+ this.connected = false;
+ client.BeginConnect(adress, port, new AsyncCallback(OnConnect), null);
+ }
+
+ ///
+ /// initializes the VR engine and sets the callbacks
+ ///
+ private void initEngine()
+ {
+ engineConnection = EngineConnection.INSTANCE;
+ engineConnection.OnNoTunnelId = retryEngineConnection;
+ engineConnection.OnSuccessFullConnection = engineConnected;
+ if (!engineConnection.Connected) engineConnection.Connect();
+ }
+
+ ///
+ /// retries to connect to the VR engine if no tunnel id was found
+ ///
+ private void retryEngineConnection()
+ {
+ Console.WriteLine("-- Could not connect to the VR engine. Please make sure you are running the simulation!");
+ Console.WriteLine("-- Press ENTER to retry connecting to the VR engine.");
+ Console.WriteLine("-- Press 'q' and then ENTER to not connect to the VR engine");
+ string input = Console.ReadLine();
+ if (input == string.Empty) engineConnection.CreateConnection();
+ else
+ {
+ Console.WriteLine("Skipping connecting to VR engine...");
+ engineConnection.Stop();
+ }
+
+ }
+
+ private void engineConnected()
+ {
+ Console.WriteLine("successfully connected to VR engine");
+ engineConnection.initScene();
+ if (engineConnection.Connected && sessionRunning && !engineConnection.FollowingRoute) engineConnection.StartRouteFollow();
+ }
+
+ ///
+ /// callback method for when the TCP client is connected
+ ///
+ /// the result of the async read
+ private void OnConnect(IAsyncResult ar)
+ {
+ this.client.EndConnect(ar);
+ Console.WriteLine("TCP client Verbonden!");
+
+
+ this.stream = this.client.GetStream();
+
+ this.stream.BeginRead(this.buffer, 0, this.buffer.Length, new AsyncCallback(OnRead), null);
+ }
+
+ ///
+ /// callback method for when there is a message read
+ ///
+ /// the result of the async read
+ private void OnRead(IAsyncResult ar)
+ {
+ int receivedBytes = this.stream.EndRead(ar);
+
+ if (totalBufferReceived + receivedBytes > 1024)
+ {
+ throw new OutOfMemoryException("buffer too small");
+ }
+ Array.Copy(buffer, 0, totalBuffer, totalBufferReceived, receivedBytes);
+ totalBufferReceived += receivedBytes;
+
+ int expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
+ while (totalBufferReceived >= expectedMessageLength)
+ {
+ //volledig packet binnen
+ byte[] messageBytes = new byte[expectedMessageLength];
+ Array.Copy(totalBuffer, 0, messageBytes, 0, expectedMessageLength);
+
+
+ byte[] payloadbytes = new byte[BitConverter.ToInt32(messageBytes, 0) - 5];
+
+ Array.Copy(messageBytes, 5, payloadbytes, 0, payloadbytes.Length);
+
+ string identifier;
+ bool isJson = DataParser.getJsonIdentifier(messageBytes, out identifier);
+ if (isJson)
+ {
+ switch (identifier)
+ {
+ case DataParser.LOGIN_RESPONSE:
+ string responseStatus = DataParser.getResponseStatus(payloadbytes);
+ if (responseStatus == "OK")
+ {
+ Console.WriteLine("Username and password correct!");
+ this.LoginViewModel.setLoginStatus(true);
+ this.connected = true;
+ initEngine();
+ }
+ else
+ {
+ Console.WriteLine($"login failed \"{responseStatus}\"");
+ }
+ break;
+ case DataParser.START_SESSION:
+ Console.WriteLine("Session started!");
+ this.sessionRunning = true;
+ if (engineConnection.Connected && !engineConnection.FollowingRoute) engineConnection.StartRouteFollow();
+ sendMessage(DataParser.getStartSessionJson());
+ break;
+ case DataParser.STOP_SESSION:
+ Console.WriteLine("Stop session identifier");
+ this.sessionRunning = false;
+ sendMessage(DataParser.getStopSessionJson());
+ break;
+ case DataParser.SET_RESISTANCE:
+ Console.WriteLine("Set resistance identifier");
+ if (this.handler == null)
+ {
+ Console.WriteLine("handler is null");
+ sendMessage(DataParser.getSetResistanceResponseJson(false));
+ }
+ else
+ {
+ this.handler.setResistance(DataParser.getResistanceFromJson(payloadbytes));
+ sendMessage(DataParser.getSetResistanceResponseJson(true));
+ }
+ break;
+ default:
+ Console.WriteLine($"Received json with identifier {identifier}:\n{Encoding.ASCII.GetString(payloadbytes)}");
+ break;
+ }
+ }
+ else if (DataParser.isRawData(messageBytes))
+ {
+ Console.WriteLine($"Received data: {BitConverter.ToString(payloadbytes)}");
+ }
+
+ totalBufferReceived -= expectedMessageLength;
+ expectedMessageLength = BitConverter.ToInt32(totalBuffer, 0);
+ }
+
+ this.stream.BeginRead(this.buffer, 0, this.buffer.Length, new AsyncCallback(OnRead), null);
+
+ }
+
+ ///
+ /// starts sending a message to the server
+ ///
+ /// the message to send
+ private void sendMessage(byte[] message)
+ {
+ stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
+ }
+
+ ///
+ /// callback method for when a message is fully written to the server
+ ///
+ /// the async result representing the asynchronous call
+ private void OnWrite(IAsyncResult ar)
+ {
+ this.stream.EndWrite(ar);
+ }
+
+ #region interface
+ //maybe move this to other place
+ ///
+ /// bpm method for receiving the BPM value from the bluetooth bike or the simulation
+ ///
+ /// the message
+ public void BPM(byte[] bytes)
+ {
+ if (!sessionRunning)
+ {
+ return;
+ }
+ if (bytes == null)
+ {
+ throw new ArgumentNullException("no bytes");
+ }
+ byte[] message = DataParser.GetRawDataMessage(bytes);
+
+ if (engineConnection.Connected && engineConnection.FollowingRoute)
+ {
+ engineConnection.BikeBPM = bytes[1];
+ engineConnection.UpdateInfoPanel();
+ }
+
+
+ this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
+ }
+
+ ///
+ /// method for receiving the bike message from the bluetooth bike or the simulation
+ ///
+ /// the message
+ public void Bike(byte[] bytes)
+ {
+ if (!sessionRunning)
+ {
+ return;
+ }
+ if (bytes == null)
+ {
+ throw new ArgumentNullException("no bytes");
+ }
+ byte[] message = DataParser.GetRawDataMessage(bytes);
+ switch (bytes[0])
+ {
+ case 0x10:
+
+ engineConnection.BikeSpeed = (bytes[4] | (bytes[5] << 8)) * 0.01f;
+ break;
+ case 0x19:
+ engineConnection.BikePower = (bytes[5]) | (bytes[6] & 0b00001111) << 8;
+ break;
+ }
+ if (engineConnection.Connected && engineConnection.FollowingRoute)
+ engineConnection.UpdateInfoPanel();
+
+ this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
+ }
+
+ #endregion
+
+ ///
+ /// wether or not the client stream is connected
+ ///
+ /// true if it's connected, false if not
+ public bool IsConnected()
+ {
+ return this.connected;
+ }
+ ///
+ /// tries to log in to the server by asking for a username and password
+ ///
+ public void tryLogin(string username, string password)
+ {
+ string hashUser = Hashing.Hasher.HashString(username);
+ string hashPassword = Hashing.Hasher.HashString(password);
+
+ byte[] message = DataParser.getJsonMessage(DataParser.GetLoginJson(hashUser, hashPassword));
+
+
+ this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
+ }
+
+ ///
+ /// sets the handler for the client, so either the bike simulator or the bluetooth bike handler
+ ///
+ ///
+ public void SetHandler(IHandler handler)
+ {
+ this.handler = handler;
+ }
+
+ internal void SetLoginViewModel(LoginViewModel loginViewModel)
+ {
+ this.LoginViewModel = loginViewModel;
+ }
+ }
+}
diff --git a/ClientApp/Utils/DataParser.cs b/ClientApp/Utils/DataParser.cs
new file mode 100644
index 0000000..6c1e4b7
--- /dev/null
+++ b/ClientApp/Utils/DataParser.cs
@@ -0,0 +1,206 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Text;
+
+namespace ClientApp.Utils
+{
+ public class DataParser
+ {
+ public const string LOGIN = "LOGIN";
+ public const string LOGIN_RESPONSE = "LOGIN RESPONSE";
+ public const string START_SESSION = "START SESSION";
+ public const string STOP_SESSION = "STOP SESSION";
+ public const string SET_RESISTANCE = "SET RESISTANCE";
+ ///
+ /// makes the json object with LOGIN identifier and username and password
+ ///
+ /// username
+ /// password
+ /// json object to ASCII to bytes
+ public static byte[] GetLoginJson(string mUsername, string mPassword)
+ {
+ dynamic json = new
+ {
+ identifier = LOGIN,
+ data = new
+ {
+ username = mUsername,
+ password = mPassword,
+ }
+ };
+
+ return Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(json));
+ }
+
+ public static bool GetUsernamePassword(byte[] jsonbytes, out string username, out string password)
+ {
+ dynamic json = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(jsonbytes));
+ try
+ {
+ username = json.data.username;
+ password = json.data.password;
+ return true;
+ }
+ catch
+ {
+ username = null;
+ password = null;
+ return false;
+ }
+ }
+
+ private static byte[] getJsonMessage(string mIdentifier, dynamic data)
+ {
+ dynamic json = new
+ {
+ identifier = mIdentifier,
+ data
+ };
+ return getMessage(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(json)), 0x01);
+ }
+
+ private static byte[] getJsonMessage(string mIdentifier)
+ {
+ dynamic json = new
+ {
+ identifier = mIdentifier,
+ };
+ return getMessage(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(json)), 0x01);
+ }
+
+ public static byte[] getLoginResponse(string mStatus)
+ {
+ return getJsonMessage(LOGIN_RESPONSE, new { status = mStatus });
+ }
+
+ public static string getResponseStatus(byte[] json)
+ {
+ return ((dynamic)JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json))).data.status;
+ }
+
+ ///
+ /// get the identifier from json
+ ///
+ /// json in ASCII
+ /// gets the identifier
+ /// if it sucseeded
+ public static bool getJsonIdentifier(byte[] bytes, out string identifier)
+ {
+ if (bytes.Length <= 5)
+ {
+ throw new ArgumentException("bytes to short");
+ }
+ byte messageId = bytes[4];
+
+ if (messageId == 0x01)
+ {
+ dynamic json = JsonConvert.DeserializeObject(Encoding.ASCII.GetString(bytes.Skip(5).ToArray()));
+ identifier = json.identifier;
+ return true;
+ }
+ else
+ {
+ identifier = "";
+ return false;
+ }
+ }
+
+ ///
+ /// checks if the de message is raw data according to the protocol
+ ///
+ /// message
+ /// if message contains raw data
+ public static bool isRawData(byte[] bytes)
+ {
+ if (bytes.Length <= 5)
+ {
+ throw new ArgumentException("bytes to short");
+ }
+ return bytes[4] == 0x02;
+ }
+
+ ///
+ /// constructs a message with the payload, messageId and clientId
+ ///
+ ///
+ ///
+ ///
+ /// the message ready for sending
+ private static byte[] getMessage(byte[] payload, byte messageId)
+ {
+ byte[] res = new byte[payload.Length + 5];
+
+ Array.Copy(BitConverter.GetBytes(payload.Length + 5), 0, res, 0, 4);
+ res[4] = messageId;
+ Array.Copy(payload, 0, res, 5, payload.Length);
+
+ return res;
+ }
+
+ ///
+ /// constructs a message with the payload and clientId and assumes the payload is raw data
+ ///
+ ///
+ ///
+ /// the message ready for sending
+ public static byte[] GetRawDataMessage(byte[] payload)
+ {
+ return getMessage(payload, 0x02);
+ }
+
+ ///
+ /// constructs a message with the payload and clientId and assumes the payload is json
+ ///
+ ///
+ ///
+ /// the message ready for sending
+ public static byte[] getJsonMessage(byte[] payload)
+ {
+ return getMessage(payload, 0x01);
+ }
+
+ public static byte[] getStartSessionJson()
+ {
+ return getJsonMessage(START_SESSION);
+ }
+
+ public static byte[] getStopSessionJson()
+ {
+ return getJsonMessage(STOP_SESSION);
+ }
+
+ public static byte[] getSetResistanceJson(float mResistance)
+ {
+ dynamic data = new
+ {
+ resistance = mResistance
+ };
+ return getJsonMessage(SET_RESISTANCE, data);
+ }
+
+ public static byte[] getSetResistanceResponseJson(bool mWorked)
+ {
+ dynamic data = new
+ {
+ worked = mWorked
+ };
+ return getJsonMessage(SET_RESISTANCE, data);
+ }
+
+ public static float getResistanceFromJson(byte[] json)
+ {
+ return ((dynamic)JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json))).data.resistance;
+ }
+
+ public static bool getResistanceFromResponseJson(byte[] json)
+ {
+ return ((dynamic)JsonConvert.DeserializeObject(Encoding.ASCII.GetString(json))).data.worked;
+ }
+
+
+ }
+}
diff --git a/ClientApp/Utils/EngineConnection.cs b/ClientApp/Utils/EngineConnection.cs
new file mode 100644
index 0000000..a4dd657
--- /dev/null
+++ b/ClientApp/Utils/EngineConnection.cs
@@ -0,0 +1,315 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using RH_Engine;
+using System.Net.Sockets;
+
+namespace ClientApp.Utils
+{
+ public delegate void HandleSerial(string message);
+ public delegate void HandleNoTunnelId();
+ public delegate void OnSuccessfullConnection();
+
+ public sealed class EngineConnection
+ {
+ private static EngineConnection instance = null;
+ private static readonly object padlock = new object();
+ public HandleNoTunnelId OnNoTunnelId;
+ public OnSuccessfullConnection OnSuccessFullConnection;
+
+
+ private static PC[] PCs = {
+ //new PC("DESKTOP-M2CIH87", "Fabian"),
+ //new PC("T470S", "Shinichi"),
+ //new PC("DESKTOP-DHS478C", "semme"),
+ new PC("HP-ZBOOK-SEM", "Sem")
+ //new PC("DESKTOP-TV73FKO", "Wouter"),
+ //new PC("DESKTOP-SINMKT1", "Ralf van Aert"),
+ //new PC("NA", "Bart")
+ };
+
+ private static ServerResponseReader serverResponseReader;
+ private static string sessionId = string.Empty;
+ private static string tunnelId = string.Empty;
+ private static string cameraId = string.Empty;
+ private static string routeId = string.Empty;
+ private static string panelId = string.Empty;
+ private static string bikeId = string.Empty;
+ private static string headId = string.Empty;
+
+ public float BikeSpeed { get; set; }
+ public float BikePower { get; set; }
+ public float BikeBPM { get; set; }
+ public float BikeResistance { get; set; }
+
+ public bool FollowingRoute = false;
+
+ private static NetworkStream stream;
+
+ private static Dictionary serialResponses = new Dictionary();
+ private Command mainCommand;
+
+ public bool Connected = false;
+
+ EngineConnection()
+ {
+ BikeSpeed = 0;
+ BikePower = 0;
+ BikeBPM = 0;
+ BikeResistance = 50;
+ }
+
+ ///
+ /// Singleton constructor
+ ///
+ public static EngineConnection INSTANCE
+ {
+ get
+ {
+ lock (padlock)
+ {
+ if (instance == null)
+ {
+ instance = new EngineConnection();
+ }
+ }
+ return instance;
+ }
+ }
+
+
+
+ ///
+ /// connects to the vr engine and initalizes the serverResponseReader
+ ///
+ public void Connect()
+ {
+ TcpClient client = new TcpClient("145.48.6.10", 6666);
+ stream = client.GetStream();
+ initReader();
+ CreateConnection();
+ }
+
+ ///
+ /// initializes and starts the reading of the responses from the vr server
+ ///
+ /// the networkstream
+ private void initReader()
+ {
+ serverResponseReader = new ServerResponseReader(stream);
+ serverResponseReader.callback = HandleResponse;
+ serverResponseReader.StartRead();
+ }
+
+ #region VR Message traffic
+ ///
+ /// connects to the server and creates the tunnel
+ ///
+ /// the network stream to use
+ public void CreateConnection()
+ {
+
+ WriteTextMessage("{\r\n\"id\" : \"session/list\",\r\n\"serial\" : \"list\"\r\n}");
+
+ // wait until we have got a sessionId
+ while (sessionId == string.Empty) { }
+
+ string tunnelCreate = "{\"id\" : \"tunnel/create\", \"data\" : {\"session\" : \"" + sessionId + "\"}}";
+
+ WriteTextMessage(tunnelCreate);
+
+
+ }
+
+ ///
+ /// callback method that handles responses from the server
+ ///
+ /// the response message from the server
+ public void HandleResponse(string message)
+ {
+ string id = JSONParser.GetID(message);
+
+ // because the first messages don't have a serial, we need to check on the id
+ if (id == "session/list")
+ {
+ sessionId = JSONParser.GetSessionID(message, PCs);
+ }
+ else if (id == "tunnel/create")
+ {
+ tunnelId = JSONParser.GetTunnelID(message);
+ Console.WriteLine("set tunnel id to " + tunnelId);
+ if (tunnelId == null)
+ {
+ Write("could not find a valid tunnel id!");
+ OnNoTunnelId?.Invoke();
+ Connected = false;
+ FollowingRoute = false;
+ return;
+ }
+ else
+ {
+ Write("got tunnel id! " + tunnelId);
+ Connected = true;
+ OnSuccessFullConnection?.Invoke();
+ }
+ }
+
+ if (message.Contains("serial"))
+ {
+ //Console.WriteLine("GOT MESSAGE WITH SERIAL: " + message + "\n\n\n");
+ string serial = JSONParser.GetSerial(message);
+ //Console.WriteLine("Got serial " + serial);
+ if (serialResponses.ContainsKey(serial)) serialResponses[serial].Invoke(message);
+ }
+ }
+
+ public void initScene()
+ {
+ Write("initializing scene...");
+ mainCommand = new Command(tunnelId);
+
+ // reset the scene
+ WriteTextMessage(mainCommand.ResetScene());
+
+ //Get sceneinfo and set the id's
+ SendMessageAndOnResponse(mainCommand.GetSceneInfoCommand("sceneinfo"), "sceneinfo",
+ (message) =>
+ {
+ //Console.WriteLine("\r\n\r\n\r\nscene info" + message);
+ cameraId = JSONParser.GetIdSceneInfoChild(message, "Camera");
+ string headId = JSONParser.GetIdSceneInfoChild(message, "Head");
+ string handLeftId = JSONParser.GetIdSceneInfoChild(message, "LeftHand");
+ string handRightId = JSONParser.GetIdSceneInfoChild(message, "RightHand");
+
+ //Force(stream, mainCommand.DeleteNode(handLeftId, "deleteHandL"), "deleteHandL", (message) => Console.WriteLine("Left hand deleted"));
+ //Force(stream, mainCommand.DeleteNode(handRightId, "deleteHandR"), "deleteHandR", (message) => Console.WriteLine("Right hand deleted"));
+ });
+ // add the route and set the route id
+ SendMessageAndOnResponse(mainCommand.RouteCommand("routeID"), "routeID", (message) => routeId = JSONParser.GetResponseUuid(message));
+ }
+
+ internal void StartRouteFollow()
+ {
+ Write("Starting route follow...");
+ FollowingRoute = true;
+
+ SendMessageAndOnResponse(mainCommand.AddBikeModel("bikeID"), "bikeID",
+ (message) =>
+ {
+ bikeId = JSONParser.GetResponseUuid(message);
+ SendMessageAndOnResponse(mainCommand.addPanel("panelAdd", bikeId), "panelAdd",
+ (message) =>
+ {
+
+ panelId = JSONParser.getPanelID(message);
+
+ WriteTextMessage(mainCommand.ColorPanel(panelId));
+ UpdateInfoPanel();
+
+ while (cameraId == string.Empty) { }
+ SetFollowSpeed(5.0f);
+ });
+ });
+ }
+
+ public void UpdateInfoPanel()
+ {
+ ShowPanel(BikeSpeed, (int)BikeBPM, (int)BikePower, (int)BikeResistance);
+ WriteTextMessage(mainCommand.RouteSpeed(BikeSpeed, bikeId));
+ WriteTextMessage(mainCommand.RouteSpeed(BikeSpeed, cameraId));
+ }
+
+ public void ShowPanel(double bikeSpeed, int bpm, int power, int resistance)
+ {
+ WriteTextMessage(mainCommand.ClearPanel(panelId));
+
+ SendMessageAndOnResponse(mainCommand.showBikespeed(panelId, "bikeSpeed", bikeSpeed), "bikeSpeed",
+ (message) =>
+ {
+ // TODO check if is drawn
+ });
+ SendMessageAndOnResponse(mainCommand.showHeartrate(panelId, "bpm", bpm), "bpm",
+ (message) =>
+ {
+ // TODO check if is drawn
+ });
+ SendMessageAndOnResponse(mainCommand.showPower(panelId, "power", power), "power",
+ (message) =>
+ {
+ // TODO check if is drawn
+ });
+ SendMessageAndOnResponse(mainCommand.showResistance(panelId, "resistance", resistance), "resistance",
+ (message) =>
+ {
+ // TODO check if is drawn
+ });
+
+ // Check if every text is drawn!
+
+ WriteTextMessage(mainCommand.SwapPanel(panelId));
+ }
+
+ private void SetFollowSpeed(float speed)
+ {
+ WriteTextMessage(mainCommand.RouteFollow(routeId, bikeId, speed, new float[] { 0, -(float)Math.PI / 2f, 0 }, new float[] { 0, 0, 0 }));
+ WriteTextMessage(mainCommand.RouteFollow(routeId, cameraId, speed));
+ }
+
+ #endregion
+
+ #region message send/receive
+
+ ///
+ /// method that sends the speciefied message with the specified serial, and executes the given action upon receivind a reply from the server with this serial.
+ ///
+ /// the networkstream to use
+ /// the message to send
+ /// the serial to check for
+ /// the code to be executed upon reveiving a reply from the server with the specified serial
+ public void SendMessageAndOnResponse(string message, string serial, HandleSerial action)
+ {
+ if (serialResponses.ContainsKey(serial))
+ {
+ serialResponses[serial] = action;
+ }
+ else
+ {
+ serialResponses.Add(serial, action);
+ }
+ WriteTextMessage(message);
+ }
+
+ ///
+ /// writes a message to the server
+ ///
+ /// the network stream to use
+ /// the message to send
+ public void WriteTextMessage(string message)
+ {
+ byte[] msg = Encoding.ASCII.GetBytes(message);
+ byte[] res = new byte[msg.Length + 4];
+
+ Array.Copy(BitConverter.GetBytes(msg.Length), 0, res, 0, 4);
+ Array.Copy(msg, 0, res, 4, msg.Length);
+
+ stream.Write(res);
+
+ //Write("sent message " + message);
+ }
+
+ #endregion
+
+ public void Stop()
+ {
+ serverResponseReader.Stop();
+
+ }
+ public void Write(string msg)
+ {
+ Console.WriteLine("[ENGINECONNECT] " + msg);
+ }
+
+ }
+
+
+}
diff --git a/ClientApp/Utils/ObservableObject.cs b/ClientApp/Utils/ObservableObject.cs
new file mode 100644
index 0000000..3809fa1
--- /dev/null
+++ b/ClientApp/Utils/ObservableObject.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+
+namespace ClientApp.Utils
+{
+ public abstract class ObservableObject : INotifyPropertyChanged
+ {
+ public event PropertyChangedEventHandler PropertyChanged;
+ }
+}
diff --git a/ClientApp/Utils/Program.cs b/ClientApp/Utils/Program.cs
new file mode 100644
index 0000000..ecab577
--- /dev/null
+++ b/ClientApp/Utils/Program.cs
@@ -0,0 +1,42 @@
+using System;
+using Hardware;
+using Hardware.Simulators;
+using RH_Engine;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace ClientApp.Utils
+{
+ class Program
+ {
+ //static void Main(string[] args)
+ //{
+ // Console.WriteLine("// Connecting... //");
+ // //connect fiets?
+
+ // Client client = new Client();
+
+
+ // while (!client.IsConnected())
+ // {
+
+ // }
+ // //BLEHandler bLEHandler = new BLEHandler(client);
+
+ // //bLEHandler.Connect();
+
+ // //client.setHandler(bLEHandler);
+
+
+ // BikeSimulator bikeSimulator = new BikeSimulator(client);
+
+ // bikeSimulator.StartSimulation();
+
+ // client.setHandler(bikeSimulator);
+
+ // while (true)
+ // {
+ // }
+ //}
+ }
+}
diff --git a/ClientApp/ViewModels/LoginViewModel.cs b/ClientApp/ViewModels/LoginViewModel.cs
new file mode 100644
index 0000000..c714b3c
--- /dev/null
+++ b/ClientApp/ViewModels/LoginViewModel.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+using System.Windows.Input;
+using ClientApp.Utils;
+using GalaSoft.MvvmLight.Command;
+
+namespace ClientApp.ViewModels
+{
+ class LoginViewModel : ObservableObject
+ {
+ public string Username { get; set; }
+ private MainWindowViewModel mainWindowViewModel;
+ public LoginViewModel(MainWindowViewModel mainWindowViewModel)
+ {
+ this.mainWindowViewModel = mainWindowViewModel;
+ LoginCommand = new RelayCommand