Migrate All Communication to TCP

qController.Standard/Classes/Cell/QSelectedCueOptionsCell.cs

@@ -61,7 +61,7 @@ namespace qController
             };
             mainSlider.ValueChanged += (sender, args) =>
             {
-                qController.qSender.sendArgs("/cue/selected/sliderLevel/0", (float)args.NewValue);
+                qController.qClient.sendArgs("/cue/selected/sliderLevel/0", (float)args.NewValue);
             };
 
             leftSlider = new Slider
@@ -71,7 +71,7 @@ namespace qController
             };
             leftSlider.ValueChanged += (sender, args) =>
             {
-                qController.qSender.sendArgs("/cue/selected/sliderLevel/1", (float)args.NewValue);
+                qController.qClient.sendArgs("/cue/selected/sliderLevel/1", (float)args.NewValue);
             };
 
             rightSlider = new Slider
@@ -81,7 +81,7 @@ namespace qController
             };
             rightSlider.ValueChanged += (sender, args) =>
             {
-                qController.qSender.sendArgs("/cue/selected/sliderLevel/2", (float)args.NewValue);
+                qController.qClient.sendArgs("/cue/selected/sliderLevel/2", (float)args.NewValue);
             };
             mainG.Children.Add(mainSlider, 1, 0);
             mainG.Children.Add(leftSlider, 1, 1);

qController.Standard/Classes/Communication/QClient.cs

@@ -0,0 +1,45 @@
+using System;
+using SharpOSC;
+using Newtonsoft.Json;
+namespace qController
+{
+    public class QClient
+    {
+        TCPSender tcpSender;
+        UDPSender udpSender;
+
+        public QClient(string address, int port)
+        {
+            tcpSender = new TCPSender(address, port);
+            udpSender = new UDPSender(address, port);
+        }
+
+        public void sendString(string address)
+        {
+            tcpSender.Send(new OscMessage(address));
+        }
+
+        public OscMessage sendAndReceiveString(string address)
+        {
+            return tcpSender.SendAndReceive(new OscMessage(address));
+        }
+
+        public OscMessage sendAndReceiveStringArgs(string address, params object[] args)
+        {
+            return tcpSender.SendAndReceive(new OscMessage(address, args));
+        }
+
+        public void sendStringUDP(string address)
+        {
+            udpSender.Send(new OscMessage(address));
+        }
+        public void sendArgs(string address, object args)
+        {
+            tcpSender.Send(new OscMessage(address, args));
+        }
+        public void sendArgsUDP(string address, object args)
+        {
+            udpSender.Send(new OscMessage(address, args));
+        }
+    }
+}

qController.Standard/Classes/Communication/QController.cs

@@ -8,33 +8,32 @@ namespace qController
     public class QController
     {
 
-		public QSender qSender;
-		QReceiver qReceiver;
         QUpdater qUpdater;
         public QParser qParser;
         QCue selectedCue;
-
+        public QClient qClient;
+        QWorkSpace qWorkspace;
 		public QController(string address, int port)
         {
-            
+            qClient = new QClient(address, port);
-			qSender = new QSender(address, port);
+
-            qReceiver = new QReceiver(port+1, this);
             qParser = new QParser();
             qUpdater = new QUpdater(this);
             qUpdater.Start();
 
             qParser.SelectedCueUpdated += this.OnSelectedCueUpdated;
-            qReceiver.MessageReceived += qParser.OnMessageReceived;
+            qParser.WorkspaceUpdated += this.OnWorkspaceUpdated;
+
 
         }
 
         public void sendCommand(string cmd){
-            qSender.sendString(cmd);
+            qClient.sendString(cmd);
         }
 
         public void sendCommandUDP(string cmd)
         {
-            qSender.sendStringUDP(cmd);
+            qClient.sendStringUDP(cmd);
         }
         public void updateCueValue(QCue cue, string property, object newValue){
            // qSender.sendArgs("/cue_id/"+cue.uniqueID+"/"+property, newValue);
@@ -46,8 +45,13 @@ namespace qController
             //Console.WriteLine("Selected Cue Updated: Name=" + selectedCue.listName);
         }
 
+        public void OnWorkspaceUpdated(object source, WorkspaceEventArgs args)
+        {
+
+            qWorkspace = args.UpdatedWorkspace;
+
+        }
         public void Kill(){
-            qReceiver.Close();
             qUpdater.Kill();
         }
     }

qController.Standard/Classes/Communication/QParser.cs

@@ -1,6 +1,7 @@
 using System;
 using SharpOSC;
 using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
 
 namespace qController
 {
@@ -21,7 +22,14 @@ namespace qController
             set;
         }
     }
-
+    public class WorkspaceEventArgs : EventArgs
+    {
+        public QWorkSpace UpdatedWorkspace
+        {
+            get;
+            set;
+        }
+    }
     public class QParser
     {
         public QParser()
@@ -31,9 +39,11 @@ namespace qController
 
         public delegate void SelectedCueUpdatedHandler(object source, CueEventArgs args);
         public delegate void AudioLevelsUpdatedHandler(object source, AudioLevelArgs args);
+        public delegate void WorkspaceUpdatedHandler(object source, WorkspaceEventArgs args);
 
         public event SelectedCueUpdatedHandler SelectedCueUpdated;
         public event AudioLevelsUpdatedHandler AudioLevelsUpdated;
+        public event WorkspaceUpdatedHandler WorkspaceUpdated;
 
         public void ParseMessage(OscMessage msg){
             if (msg.Address.Contains("selectedCues"))
@@ -42,19 +52,16 @@ namespace qController
                 ParseNoteInfo(msg);
             else if (msg.Address.Contains("levels"))
                 ParseLevelInfo(msg);
-
+            else if (msg.Address.Contains("cueLists"))
+                ParseWorkspaceInfo(msg);
+            else
+                Console.WriteLine(msg.Address);
         }
-
-        public void OnMessageReceived(object source, MessageEventArgs args){
-            //Console.WriteLine("Packet Received");
-            ParseMessage(args.Message);
-        }
-
         public void ParseSelectedCueInfo(OscMessage msg){
             JArray selectedCues = (JArray)OSC2JSON(msg);
-            if(selectedCues.Count > 0){
+            if (selectedCues.Count > 0){
                 foreach(JObject item in selectedCues){
-                    QCue parsedCue = new QCue(item);
+                    QCue parsedCue = JsonConvert.DeserializeObject<QCue>(item.ToString());
                     OnSelectedCueUpdated(parsedCue);
                 }
 
@@ -72,11 +79,25 @@ namespace qController
             OnAudioLevelsUpdated(levels);
         }
 
+        public void ParseWorkspaceInfo(OscMessage msg)
+        {
+            if (msg.Arguments.Count > 0)
+            {
+                QWorkSpace workspace = JsonConvert.DeserializeObject<QWorkSpace>(msg.Arguments[0].ToString());
+                OnWorkspaceUpdated(workspace);
+            }
+        }
+
         public JToken OSC2JSON(OscMessage Msg){
             JObject json = JObject.Parse(Msg.Arguments.ToArray()[0].ToString());
             return json.GetValue("data");
         }
 
+        protected virtual void OnWorkspaceUpdated(QWorkSpace workspace)
+        {
+            if (WorkspaceUpdated != null)
+                WorkspaceUpdated(this, new WorkspaceEventArgs() { UpdatedWorkspace = workspace });
+        }
         protected virtual void OnSelectedCueUpdated(QCue cue)
         {
             if (SelectedCueUpdated != null)

qController.Standard/Classes/Communication/QReceiver.cs

@@ -44,9 +44,8 @@ namespace qController
                     messageReceived = (OscMessage)udpListener.Receive();
                     Thread.Sleep(1);
                 }
-                Console.WriteLine("Received a message!");
-                Console.WriteLine(messageReceived.Address);
                 OnMessageReceived(messageReceived);
+                
             }
 
             Console.WriteLine("Loop Ended");
@@ -59,6 +58,7 @@ namespace qController
         }
 
         protected virtual void OnMessageReceived(OscMessage msg){
+            Console.WriteLine("Message Received");
             if (MessageReceived != null)
                 MessageReceived(this, new MessageEventArgs(){Message = msg});
         }

qController.Standard/Classes/Communication/QUpdater.cs

@@ -1,5 +1,6 @@
 using System;
 using Xamarin.Forms;
+using SharpOSC;
 namespace qController
 {
     public class QUpdater
@@ -14,10 +15,21 @@ namespace qController
         public void Start(){
             active = true;
             Device.StartTimer(TimeSpan.FromSeconds(0.01), () => {
-                qController.sendCommandUDP("/selectedCues");
+                //qController.sendCommandUDP("/selectedCues");
-                qController.sendCommandUDP("/cue/selected/levels");
+                UpdateSelected();
+                UpdateLevels();
                 return active;
             });
+
+        }
+
+        public void UpdateSelected()
+        {
+            qController.qParser.ParseMessage(qController.qClient.sendAndReceiveString("/selectedCues"));
+        }
+        public void UpdateLevels()
+        {
+            qController.qParser.ParseMessage(qController.qClient.sendAndReceiveString("/cue/selected/levels"));
         }
 
         public void Kill(){

qController.Standard/Classes/Communication/SharpOSC/TCPSender.cs

@@ -3,9 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Net.Sockets;
-using System.Net;
 using System.Threading;
-using System.IO;
 
 namespace SharpOSC
 {
@@ -22,8 +20,8 @@ namespace SharpOSC
             get { return _address; }
         }
         string _address;
-
         TcpClient client;
+        Thread receivingThread;
 
         byte END = 0xc0;
         byte ESC = 0xdb;
@@ -35,70 +33,106 @@ namespace SharpOSC
         {
             _port = port;
             _address = address;
-
         }
 
         public void Send(byte[] message)
         {
             client = new TcpClient(Address, Port);
-            Console.WriteLine("Available: " + client.Available);
+            byte[] slipData = SlipEncode(message);
-            Console.WriteLine("Connected: " + client.Connected);
-            List<byte> slipData= new List<byte>();
-
-            byte[] esc_end = { ESC, ESC_END };
-            byte[] esc_esc = { ESC, ESC_ESC };
-            byte[] end = { END };
-
-            int length = message.Length;
-            for (int i = 0; i < length; i++)
-            {
-                if (message[i] == END)
-                {
-                    slipData.AddRange(esc_end);
-                } else if (message[i] == ESC)
-                {
-                    slipData.AddRange(esc_esc);
-                }
-                else
-                {
-                    slipData.Add(message[i]);
-                }
-            }
-            slipData.AddRange(end);
             NetworkStream netStream = client.GetStream();
             netStream.Write(slipData.ToArray(), 0, slipData.ToArray().Length);
             netStream.Close();
             client.Close();
         }
 
-        public void Receive()
+        public OscMessage Receive()
         {
-            NetworkStream netStream = client.GetStream();
+            OscMessage response = new OscMessage("/null");
-            List<byte> responseData = new List<byte>();
+            try
-            if (netStream.CanRead)
             {
-                byte[] buffer = new byte[512];
+                NetworkStream netStream = client.GetStream();
-
+                netStream.ReadTimeout = 250;
-                int bytesRead = 0;
+                List<byte> responseData = new List<byte>();
-                do
+                if (netStream.CanRead)
                 {
-                    bytesRead = netStream.Read(buffer, 0, buffer.Length);
+                    byte[] buffer = new byte[1024];
-                    responseData.AddRange(buffer);
 
-                } while (netStream.DataAvailable);
+                    int bytesRead = 0;
-                OscMessage response = (OscMessage)OscPacket.GetPacket(responseData.Skip(1).ToArray());
+                    do
+                    {
+                        bytesRead = netStream.Read(buffer, 0, buffer.Length);
+                        responseData.AddRange(buffer);
+                    } while (netStream.DataAvailable);
+                    response = (OscMessage)OscPacket.GetPacket(responseData.Skip(1).ToArray());
+                    netStream.Close();
+                    client.Close();
+                }
+            } catch(Exception e)
+            {
+                Console.WriteLine(e.ToString());
             }
-            netStream.Close();
+            return response;
         }
+
+        public OscMessage SendAndReceive(byte[] message)
+        {
+            client = new TcpClient(Address, Port);
+            byte[] slipData = SlipEncode(message);
+            NetworkStream netStream = client.GetStream();
+            netStream.Write(slipData.ToArray(), 0, slipData.ToArray().Length);
+            OscMessage response = Receive();
+            return response;
+        }
+
+        public OscMessage SendAndReceive(OscPacket packet)
+        {
+            byte[] data = packet.GetBytes();
+            OscMessage response = SendAndReceive(data);
+            return response;
+        }
+        public void StartReceiving()
+        {
+            receivingThread.Start();
+        }
+
         public void Send(OscPacket packet)
         {
             byte[] data = packet.GetBytes();
             Send(data);
         }
 
+        public byte[] SlipEncode(byte[] data)
+        {
+            List<byte> slipData = new List<byte>();
+
+            byte[] esc_end = { ESC, ESC_END };
+            byte[] esc_esc = { ESC, ESC_ESC };
+            byte[] end = { END };
+
+            int length = data.Length;
+            for (int i = 0; i < length; i++)
+            {
+                if (data[i] == END)
+                {
+                    slipData.AddRange(esc_end);
+                }
+                else if (data[i] == ESC)
+                {
+                    slipData.AddRange(esc_esc);
+                }
+                else
+                {
+                    slipData.Add(data[i]);
+                }
+            }
+            slipData.AddRange(end);
+            return slipData.ToArray();
+        }
+
         public void Close()
         {
             client.GetStream().Close();
+            receivingThread.Abort();
             client.Close();
         }
     }

qController.Standard/Classes/Cues/QCue.cs

@@ -4,26 +4,13 @@ namespace qController
 {
     public class QCue
     {
-        public string number;
+        public string number { get; set; }
-        public string uniqueID;
+        public string uniqueID { get; set; }
-        public bool flagged;
+        public bool flagged { get; set; }
-        public string listName;
+        public string listName { get; set; }
-        public string type;
+        public string type { get; set; }
-        public string colorName;
+        public string colorName { get; set; }
-        public string name;
+        public string name { get; set; }
-        public bool armed;
+        public bool armed { get; set; }
-
-        public QCue(JObject json){
-            //Console.WriteLine(json);
-            number = (string)json.GetValue("number");
-            uniqueID = (string)json.GetValue("uniqueID");
-            flagged = (bool)json.GetValue("flagged");
-            listName = (string)json.GetValue("listName");
-            type = (string)json.GetValue("type");
-            colorName = (string)json.GetValue("colorName");
-            name = (string)json.GetValue("name");
-            armed = (bool)json.GetValue("armed");
-        }
-
     }
 }

qController.Standard/Classes/Cues/QCueList.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+
+namespace qController
+{
+    public class QCueList
+    {
+        public string number { get; set; }
+        public string uniqueID { get; set; }
+        public List<QCue> cues { get; set; }
+        public bool flagged { get; set; }
+        public string listName { get; set; }
+        public string type { get; set; }
+        public string colorName { get; set; }
+        public string name { get; set; }
+        public bool armed { get; set; }
+    }
+}

qController.Standard/Classes/Cues/QDefinitions.cs

@@ -0,0 +1,10 @@
+using System;
+namespace qController.Classes.Cues
+{
+    public class QDefinitions
+    {
+        public QDefinitions()
+        {
+        }
+    }
+}

qController.Standard/Classes/Cues/QGroupCue.cs

@@ -1,12 +0,0 @@
-using Newtonsoft.Json.Linq;
-namespace qController
-{
-    public class QGroupCue : QCue
-    {
-        
-        public QGroupCue(JObject json) : base(json)
-        {
-            
-        }
-    }
-}

qController.Standard/Classes/Cues/QWorkSpace.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+
+namespace qController
+{
+    public class QWorkSpace
+    {
+        public string status { get; set; }
+        public List<QCueList> data { get; set; }
+        public string workspace_id { get; set; }
+        public string address { get; set; }
+    }
+}

qController.Standard/Pages/ControlPage.xaml.cs

@@ -18,6 +18,9 @@ namespace qController
 
             qController = new QController(address, 53000);
             qController.qParser.SelectedCueUpdated += SelectedCueUpdated;
+            qController.qParser.WorkspaceUpdated += WorkspaceUpdated;
+
+            qController.qParser.ParseWorkspaceInfo(qController.qClient.sendAndReceiveString("/cueLists"));
             NavigationPage.SetHasNavigationBar(this, false);
             instanceName.Text = name;
 
@@ -145,6 +148,18 @@ namespace qController
             });
         }
 
+        public void WorkspaceUpdated(object sender, WorkspaceEventArgs e)
+        {
+            if(e.UpdatedWorkspace.data.Count > 0)
+            {
+                Device.BeginInvokeOnMainThread(() =>
+                {
+                    //
+                });
+                Console.WriteLine("Workspace Updated: " + e.UpdatedWorkspace.workspace_id);
+            }
+        }
+
         protected override void OnDisappearing()
         {
             base.OnDisappearing();

qController.Standard/qController.csproj

@@ -35,6 +35,8 @@
     <Compile Remove="Bespoke.Net\Net\UdpServer.cs" />
     <Compile Remove="Bespoke.Net\Properties\AssemblyInfo.cs" />
     <Compile Remove="Classes\QButton.cs" />
+    <Compile Remove="Classes\Cues\QDefinitions.cs" />
+    <Compile Remove="Classes\Communication\QReceiver.cs" />
   </ItemGroup>
   <ItemGroup>
     <Compile Update="App.xaml.cs">