예제 #1
0
        /// <summary>
        /// Event handler to be executed when send button is clicked.
        /// 
        /// New outbound message is constructed using the configured chat name and
        /// chat message from the message input field. Message is send to the other device.
        /// </summary>
        private async void sendButton_Click(object sender, RoutedEventArgs e)
        {
            Message m = new Message()
            {
                Name = _dataContext.Settings.Name,
                Text = messageInput.Text,
                Direction = Message.DirectionValue.Out
            };

            messageInput.Text = "";

            _dataContext.Messages.Add(m);

            await _dataContext.Communication.SendMessageAsync(m);

            scrollToLast();
        }
예제 #2
0
        /// <summary>
        /// Listens to incoming transmissions.
        /// 
        /// PeerName property is updates if a chat name is received from the other device.
        /// MessageReceived action will be invoked when a message from another device has been received.
        /// ConnectionInterrupted action will be invoked if connection to another device breaks.
        /// </summary>
        private async Task ListenAsync()
        {
            try
            {
                while (true)
                {
                    await GuaranteedLoadAsync(sizeof(UInt32));
                    uint version = _reader.ReadUInt32();

                    if (version == 0)
                    {
                        await GuaranteedLoadAsync(sizeof(UInt32));
                        uint operation = _reader.ReadUInt32();

                        switch (operation)
                        {
                            case 0: // name
                                {
                                    await GuaranteedLoadAsync(sizeof(UInt32));
                                    uint length = _reader.ReadUInt32();
                                    await GuaranteedLoadAsync(length);
                                    string name = _reader.ReadString(length);

                                    PeerName = name;
                                }
                                break;

                            case 1: // message
                                {
                                    await GuaranteedLoadAsync(sizeof(UInt32));
                                    uint length = _reader.ReadUInt32();

                                    await GuaranteedLoadAsync(length);
                                    string text = _reader.ReadString(length);

                                    Message m = new Message()
                                    {
                                        Name = PeerName,
                                        Text = text,
                                        Direction = Message.DirectionValue.In
                                    };

                                    if (MessageReceived != null)
                                    {
                                        MessageReceived(m);
                                    }
                                }
                                break;
                        }
                    }
                    else
                    {
                        throw new Exception("Protocol version mismatch");
                    }
                }
            }
            catch (Exception ex)
            {
                if (ConnectionInterrupted != null)
                {
                    ConnectionInterrupted();
                }
            }
        }
예제 #3
0
 /// <summary>
 /// Event handler to be executed when a new inbound message has been received.
 /// 
 /// Message is stored to the DataContext.Messages.
 /// </summary>
 /// <param name="m"></param>
 private void MessageReceived(Message m)
 {
     Deployment.Current.Dispatcher.BeginInvoke(() =>
     {
         _dataContext.Messages.Add(m);
     });
 }
예제 #4
0
        /// <summary>
        /// Sends a chat message to the other device.
        /// </summary>
        /// <param name="m">Message to send</param>
        public async Task SendMessageAsync(Message m)
        {
            try
            {
                if (m.Text.Length > 0)
                {
                    _writer.WriteUInt32(0); // protocol version
                    _writer.WriteUInt32(1); // operation identifier

                    uint length = _writer.MeasureString(m.Text);
                    _writer.WriteUInt32(length);
                    _writer.WriteString(m.Text);

                    await _writer.StoreAsync();
                }
            }
            catch (Exception)
            {
                if (ConnectionInterrupted != null)
                {
                    ConnectionInterrupted();
                }
            }
        }
        /// <summary>
        /// Event handler to be executed when send button is clicked.
        /// 
        /// New outbound message is constructed using the configured chat name and
        /// chat message from the message input field. Message is send to the other device.
        /// </summary>
        private async void sendButton_Click(object sender, EventArgs e)
        {
            Message m = new Message()
            {
                Name = _dataContext.Settings.Name,
                Text = messageInput.Text,
                Direction = Message.DirectionValue.Out
            };

            // If we are transferring an image, load it into the message from the temporary image file
            if (m_ImageReadyToTransfer)
            {
                m.ImageName = string.Format("{0}.jpg", Guid.NewGuid()); // assign a unique image name
                await m.ConvertImageToByteArrayAsync(m_TempImageName); // load up the temporary image into the message's byte array
                await m.SaveByteArrayImageToFileSystemAsync(false); // save a local copy of the image, and do not clean up the byte array
            }

            // Clean up input values
            messageInput.Text = "";
            messageImage.Source = null;
            messageImage.Visibility = System.Windows.Visibility.Collapsed;
            m_ImageReadyToTransfer = false;

            _dataContext.Messages.Add(m);

            await _dataContext.Communication.SendMessageAsync(m);

            scrollToLast();
        }
        /// <summary>
        /// Event handler to be executed when a new inbound message has been received.
        /// 
        /// Message is stored to the DataContext.Messages.
        /// </summary>
        /// <param name="m"></param>
        private void MessageReceived(Message m)
        {
            Deployment.Current.Dispatcher.BeginInvoke(async () =>
            {
                await m.SaveByteArrayImageToFileSystemAsync();

                _dataContext.Messages.Add(m);
            });
        }
        /// <summary>
        /// Sends a chat message to the other device.
        /// </summary>
        /// <param name="m">Message to send</param>
        public async Task SendMessageAsync(Message m)
        {
            try
            {
                //if (m.Text.Length > 0)
                if (m != null)
                {
                    _writer.WriteUInt32(0); // protocol version
                    _writer.WriteUInt32(1); // operation identifier

                    //uint length = _writer.MeasureString(m.Text);
                    //_writer.WriteUInt32(length);
                    //_writer.WriteString(m.Text);
                    IBuffer buf = ConvertMessageToByteArray(m).AsBuffer();
                    _writer.WriteUInt32(buf.Length);
                    _writer.WriteBuffer(buf);

                    await _writer.StoreAsync();
                }
            }
            catch (Exception)
            {
                if (ConnectionInterrupted != null)
                {
                    ConnectionInterrupted();
                }
            }
        }
        private byte[] ConvertMessageToByteArray(Message msg)
        {
            if (msg == null)
            {
                return null;
            }

            using (MemoryStream ms = new MemoryStream())
            {
                Serializer.Serialize<Message>(ms, msg);
                return ms.ToArray();
            }
        }