public void Add(uint sequenceNumber, CommandCompletion completion)
        {
            lock (sequenceNumberLock)
            {
                if (messagesInFlight.ContainsKey(sequenceNumber))
                {
                    throw new InvalidOperationException("Internal Error - duplicate messages in flight");
                }

                //Debug.WriteLine("Adding sequenceNumber - " + sequenceNumber);
                messagesInFlight.Add(sequenceNumber, new CiiMessageTracker(completion));
            }
        }
        private bool SendCommand(   byte[] type,
                                    uint subcommand,
                                    byte[] data,
                                    CommandCompletion completion,
                                    out uint sequenceNumber)
        {
            if (connectionState != ConnectionState.Connected)
            {
                Debug.WriteLine("Failing SendCommand() - not connected!");
                sequenceNumber = 0;
                return false;
            }

            uint newSequenceNumber = messagesInFlight.SequenceNumber;
            byte[] sequenceBytes = BitConverter.GetBytes(newSequenceNumber);
            byte[] subcommandBytes = BitConverter.GetBytes(subcommand);
            byte[] SendBuffer;

            sequenceNumber = newSequenceNumber;

            //
            //  Can't optimize this, we need a single buffer to send.
            //  We have to do the memcpy.
            //
            if (data != null)
            {
                SendBuffer = new byte[type.Length +
                                        sequenceBytes.Length +
                                        subcommandBytes.Length +
                                        data.Length];
            }
            else
            {
                SendBuffer = new byte[type.Length +
                                        sequenceBytes.Length +
                                        subcommandBytes.Length];
            }

            int destIndex = 0;

            Array.Copy(type, 0, SendBuffer, destIndex, type.Length);
            destIndex += type.Length;

            Array.Copy(sequenceBytes, 0, SendBuffer, destIndex, sequenceBytes.Length);
            destIndex += sequenceBytes.Length;

            Array.Copy(subcommandBytes, 0, SendBuffer, destIndex, subcommandBytes.Length);

            if (data != null)
            {
                destIndex += subcommandBytes.Length;
                Array.Copy(data, 0, SendBuffer, destIndex, data.Length);
            }

            logger.Log("COMMAND", SendBuffer, SendBuffer.Length);

            messagesInFlight.Add(newSequenceNumber, completion);

            bool Success = backEndManager.SendMessage(SendBuffer);

            if (!Success)
            {
                messagesInFlight.Delete(newSequenceNumber);
                sequenceNumber = 0;
            }

            return Success;
        }
 public bool SendGetCommand(uint subcommand,
                                 byte[] data,
                                 CommandCompletion completion)
 {
     uint sequenceNumber;
     return SendGetCommand(subcommand, data, completion, out sequenceNumber);
 }
 public bool SendGetCommand(uint subcommand,
                                 byte[] data,
                                 CommandCompletion completion,
                                 out uint sequenceNumber)
 {
     return SendCommand(MessageTypeGet, subcommand, data, completion, out sequenceNumber);
 }
 public bool SendActionCommand(  uint subcommand,
                                 byte[] data,
                                 CommandCompletion completion,
                                 out uint sequenceNumber)
 {
     if ((grantedAccess == CiiAccessLevel.AlEngineering) ||
         (grantedAccess == CiiAccessLevel.AlMaster) ||
         (grantedAccess == CiiAccessLevel.AlLocalUI))
     {
         return SendCommand(MessageTypeAction, subcommand, data, completion, out sequenceNumber);
     }
     else
     {
         sequenceNumber = 0;
         return false;
     }
 }
 public CiiMessageTracker(CommandCompletion completion)
 {
     ackReceived = false;
     this.completion = completion;
 }