Пример #1
0
        /// <summary>
        /// Attempts to decode the signal in the message and convert it to the appropriate <seealso cref="vrmeeting.messages.signals.Signals"/> </summary>
        /// <param name="message"> The raw message to extract the signal from </param>
        /// <returns> Returns the <seealso cref="vrmeeting.messages.signals.Signals"/> that was encoded into the message </returns>
        /// <exception cref="InvalidMessageException"> If there is an error with the format of the message such that the signal cannot be extracted </exception>

        private static ServerSignals extractSignal(byte[] message)
        {
            int delimiterIndex = findSignalDelimiterIndex(message);

            ByteBuffer buffer       = new ByteBuffer(message);
            string     stringSignal = buffer.ReadString(delimiterIndex);

            //string messageAsString = StringHelper.NewString(message);
            //string str = System.Text.Encoding.Default.GetString(message);
            //Debug.Log(str);
            //Get the string that represents the signal


            //string stringSignal = messageAsString.Substring(0, delimiterIndex);
            //Debug.Log(stringSignal);
            try
            {
                //ServerSignals signal = ServerSignals.valueOf(stringSignal);
                //ServerSignals signal;
                ServerSignals signal = (ServerSignals)Enum.Parse(typeof(ServerSignals), stringSignal, true);
                return(signal);
            }
            catch (System.ArgumentException)
            {
                //If the string doesn't represent any of the valid signals
                throw new InvalidMessageException("Error parsing message: Unknown signal '" + stringSignal + "'");
            }
        }
Пример #2
0
        /// <summary>
        /// Parses the raw 'message' passed into the function according to the VRMeeting Messaging Protocol </summary>
        /// <param name="message"> The message to validate </param>
        /// <returns> Returns a <seealso cref="Message"/> object which represents the parsed raw message </returns>
        /// <exception cref="InvalidMessageException"> Thrown if the message is invalid </exception>
        /// <seealso cref= <a href="https://github.com/psymj1/VRMeeting-Documentation">VRMeeting Messaging Protocol</a> </seealso>

        public static Message parseMessage(byte[] message)
        {
            if (message == null)
            {
                throw new System.ArgumentException("Error parsing message: message cannot be null");
            }

            if (!(message.Length > 0))
            {
                throw new System.ArgumentException("Error parsing message: The byte array cannot be empty");
            }

            //if (message.Length > ProtocolConfig.MAX_POSSIBLE_SERIALIZED_MESSAGE_LENGTH)
            //{
            //	throw new InvalidMessageException("Error parsing message: The maximum possible message size defined by the VRMeeting Messaging Protocol is " + ProtocolConfig.MAX_POSSIBLE_SERIALIZED_MESSAGE_LENGTH + " but the message supplied is " + message.Length + " bytes long");
            //}

            ServerSignals signal = extractSignal(message);

            switch (signal)
            {
            case ServerSignals.AUDI:
                return(parseAUDIMessage(message));

            case ServerSignals.CHNG:
                return(parseCHNGMessage(message));

            case ServerSignals.END:
                return(parseENDMessage());

            //case TOKE:
            //    return parseTOKEMessage(message);
            case ServerSignals.AUTH:
                return(parseAUTHMessage());

            case ServerSignals.VAL:
                return(parseVALMessage());

            case ServerSignals.NVAL:
                return(parseNVALMessage());

            case ServerSignals.MEET:
                return(parseMEETMessage());

            case ServerSignals.UDM:
                return(parseUDMMessage(message));

            case ServerSignals.EAUD:
                return(parseEAUDMessage(message));

            case ServerSignals.LEFT:
                return(parseLEFTMessage(message));

            default:
                throw new InvalidMessageException("Warning: A " + signal.ToString() + " message should not be received by the server");
            }
        }