Ejemplo n.º 1
0
        // O construtor da classe recebe uma conexão TCP e um pacote.
        public Conexao(TcpClient tcpCon, Pacote pacoteRecebido)
        {
            this.tcpCliente = tcpCon;

            this.pacoteRecebido = pacoteRecebido;

            // Instancia a thread que irá receber o cliente e aguarda por mensagens
            thrSender = new Thread(AceitaCliente);

            // A própria thread chama o método AceitaCliente()
            thrSender.Start();
        }
Ejemplo n.º 2
0
        // Ocorre quando o novo cliente é aceito
        private void AceitaCliente()
        {
            this.srRecebe = new StreamReader(tcpCliente.GetStream());
            this.swEnvia = new StreamWriter(tcpCliente.GetStream());

            // Se o pacote ja existe e o comando dele é de Conectar então não preciso fazer nada, do contrário devo ler a informação que vier
            if (this.pacoteRecebido != null && this.pacoteRecebido.Comando == Comando.Conectar)
            {

            }
            else
            {
                // Lê as informações de conta que vieram do cliente
                string conteudoRecebido = this.srRecebe.ReadLine();

                // Limpo o pacote atual, caso dê alguma treta não vai seguir adiante com o pacote velho
                this.pacoteRecebido = null;

                if (conteudoRecebido != null)
                {
                    this.pacoteRecebido = JsonConvert.DeserializeObject<Pacote>(conteudoRecebido);
                }
            }

            // Se tem pacote vou trabalhar com ele
            if (this.pacoteRecebido != null)
            {
                this.UsuarioConexao = pacoteRecebido.Usuario;

                Pacote pacoteEnviar = new Pacote();
                pacoteEnviar.Usuario = "Administrator";

                // Se é um pacote para parar a escuta, então paro!
                if (pacoteRecebido.Comando == Comando.PararEscuta)
                {
                    FechaConexao();
                    return;
                }
                else if (this.UsuarioConexao != "" && pacoteRecebido.Comando == Comando.Conectar) // Se esta conexão não tem usuário e o comando é pedindo para conectar...
                {
                    // Verifica se o nome do usuário ja não existe na lista de usuários
                    if (ChatServer.htUsuarios.Contains(this.UsuarioConexao) == true)
                    {
                        // Comando é que este nome ja está sendo utilizado
                        pacoteEnviar.Comando = Comando.NomeReservado;
                        pacoteEnviar.Mensagem = "Este nome ja está sendo utilizado.";
                        string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                        this.swEnvia.WriteLine(objEnviar);
                        this.swEnvia.Flush();
                        FechaConexao();
                        return;
                    }
                    // Se o nome do usuário malandro é igual ao nome do administrador
                    else if (this.UsuarioConexao == "Administrator")
                    {
                        // Comando é que este nome de usuário não pode ser utilizado
                        pacoteEnviar.Comando = Comando.NomeReservado;
                        pacoteEnviar.Mensagem = "Este nome é reservado.";
                        string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                        this.swEnvia.WriteLine(objEnviar);
                        this.swEnvia.Flush();
                        FechaConexao();
                        return;
                    }
                    else
                    {
                        // Comando é que foi conectado com sucesso
                        pacoteEnviar.Comando = Comando.ConectadoComSucesso;
                        pacoteEnviar.Mensagem = "";
                        string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                        this.swEnvia.WriteLine(objEnviar);
                        this.swEnvia.Flush();

                        // Adiciona o usuário na lista e começa a escutar as mensagem vindas dele
                        ChatServer.AdicionaUsuario(tcpCliente, this.UsuarioConexao);
                    }
                }
                else
                {
                    FechaConexao();
                    return;
                }

                try
                {
                    // Continua aguardando por uma mensagem enviada pelo usuário
                    while ((strResposta = this.srRecebe.ReadLine()) != "")
                    {
                        // Se o conteúdo enviado e null então removo o usupário da lista
                        if (strResposta == null)
                        {
                            ChatServer.RemoveUsuario(tcpCliente);
                        }
                        else
                        {
                            // Agora vou tratar as próximas requisições
                            pacoteRecebido = JsonConvert.DeserializeObject<Pacote>(strResposta);

                            switch (pacoteRecebido.Comando)
                            {
                                case Comando.NomeReservado:
                                    // Ele está de brincadeira com este comando, vou remover este engraçadinho
                                    ChatServer.RemoveUsuario(tcpCliente);
                                    break;

                                case Comando.ConectadoComSucesso:
                                    // Ele está de brincadeira com este comando, vou remover este engraçadinho
                                    ChatServer.RemoveUsuario(tcpCliente);
                                    break;

                                case Comando.ListaDeUsuarios:
                                    // Ele está de brincadeira com este comando, vou remover este engraçadinho
                                    ChatServer.RemoveUsuario(tcpCliente);
                                    break;

                                case Comando.Mensagem:
                                    // Envia mensagem normal para todos os outros usuários
                                    ChatServer.EnviaMensagem(pacoteRecebido);
                                    break;

                                case Comando.MensagemPrivada:
                                    // Envia a mensagem apenas para o usuário determinado
                                    ChatServer.EnviaMensagemPrivada(pacoteRecebido);
                                    break;

                                case Comando.EnviarArquivo:
                                    // Envia a mensagem dizendo que um usuário deseja enviar um arquivo para o outro
                                    ChatServer.EnviarArquivo(pacoteRecebido);
                                    break;

                                case Comando.AceiteDoArquivo:
                                    ChatServer.AceiteDoArquivo(pacoteRecebido);
                                    break;

                                case Comando.EnviandoArquivo:
                                    ChatServer.EnviandoArquivo(pacoteRecebido);
                                    break;

                                case Comando.ArquivoRecusado:
                                    ChatServer.ArquivoRecusado(pacoteRecebido);
                                    break;

                                case Comando.Conectar:
                                    // Ele está de brincadeira com este comando, vou remover este engraçadinho
                                    ChatServer.RemoveUsuario(tcpCliente);
                                    break;

                                default:
                                    // Ele está de brincadeira, vou remover este engraçadinho
                                    ChatServer.RemoveUsuario(tcpCliente);
                                    break;
                            }
                        }
                    }
                }
                catch
                {
                    // Se algo está errado com este usuário, disconecto o mesmo.
                    ChatServer.RemoveUsuario(tcpCliente);
                }
            }
        }
Ejemplo n.º 3
0
        public void ParaAEscuta()
        {
            this.ServidorRodando = false;

            TcpClient tcpc = new TcpClient();
            tcpc.Connect(this.EnderecoIP, this.porta);

            StreamWriter swSenderSender = new StreamWriter(tcpc.GetStream());
            Pacote pacoteEnviar = new Pacote();
            pacoteEnviar.Comando = Comando.PararEscuta;
            pacoteEnviar.Usuario = ChatServer.NomeAdministrador;
            pacoteEnviar.Mensagem = ChatServer.IDAdministrador;
            string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
            swSenderSender.WriteLine(objEnviar);
            swSenderSender.Flush();
            swSenderSender = null;
            tcpc.Close();

            //ChatServer.tlsClient.Stop();
            //this.thrListener.Abort();
        }
Ejemplo n.º 4
0
        // Envia mensagens administrativas
        public static void EnviaMensagemDeAdministrador(string mensagem)
        {
            // Primeiro de tudo, exibe na aplicação quem diz o que
            e = new StatusChangedEventArgs(ChatServer.NomeAdministrador + ": " + mensagem);
            OnStatusChanged(e);

            // Cria um array de clientes TCP, o tamanho é o número de usuários que nós temos nas tabelas hash
            TcpClient[] tcpClientes = new TcpClient[ChatServer.htUsuarios.Count];

            // Copia os objetos TcpClient para um array
            ChatServer.htUsuarios.Values.CopyTo(tcpClientes, 0);

            // Stream que irá enviar a mensagem para cada usuário
            StreamWriter swEnviador;

            // Laço sobre a lista de clientes TCP
            for (int i = 0; i < tcpClientes.Length; i++)
            {
                // Tentando enviar a mensagem para cada
                try
                {
                    // Se a mensagem está vazia ou a conexão é null, cai fora
                    if (mensagem.Trim() == "" || tcpClientes[i] == null)
                    {
                        continue;
                    }

                    // Envia a mensagem para o atual usuário do loop
                    swEnviador = new StreamWriter(tcpClientes[i].GetStream());

                    // Criando o pacote para enviar
                    Pacote pacoteEnviar = new Pacote();
                    pacoteEnviar.Comando = Comando.MensagemAdministrador;
                    pacoteEnviar.Usuario = ChatServer.NomeAdministrador;
                    pacoteEnviar.Mensagem = ChatServer.NomeAdministrador + ": " + mensagem;

                    // Serializa o pacote
                    string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);

                    swEnviador.WriteLine(objEnviar);
                    swEnviador.Flush();
                    swEnviador = null;
                }
                catch // Se ocorreu algum problema o usuário não está mais conectado. Vou remover ele
                {
                    RemoveUsuario(tcpClientes[i]);
                }
            }
        }
Ejemplo n.º 5
0
        // Quando o Usuario envia uma mensagem dizendo que deseja enviar um arquivo para o UsuarioDestino
        public static void EnviarArquivo(Pacote pacote)
        {
            StreamWriter swEnviar;

            // Exibe na aplicação quem quer enviar o arquivo e para quem
            e = new StatusChangedEventArgs(pacote.Usuario + " quer enviar o arquivo " + pacote.NomeArquivo + " arquivo para " + pacote.UsuarioDestino);
            OnStatusChanged(e);

            TcpClient clienteTCPOrigem = null;
            TcpClient clienteTCPDestino = null;
            try
            {
                // Busca o cliente pela própria chave da hash table, não precisa de laço for e tal...
                if ((clienteTCPDestino = (TcpClient)ChatServer.htUsuarios[pacote.UsuarioDestino]) != null)
                {
                    // Envia a mensagem para o usuário específico
                    swEnviar = new StreamWriter(clienteTCPDestino.GetStream());
                    Pacote pacoteEnviar = new Pacote();
                    pacoteEnviar.Comando = Comando.EnviarArquivo;
                    pacoteEnviar.Mensagem = pacote.Usuario + " deseja lhe enviar o arquivo " + pacote.NomeArquivo;
                    pacoteEnviar.Usuario = pacote.Usuario;
                    pacoteEnviar.UsuarioDestino = pacote.UsuarioDestino;
                    pacoteEnviar.NomeArquivo = pacote.NomeArquivo;
                    pacoteEnviar.TamanhoArquivo = pacote.TamanhoArquivo;
                    pacoteEnviar.ConteudoArquivo = pacote.ConteudoArquivo;
                    string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                    swEnviar.WriteLine(objEnviar);
                    swEnviar.Flush();
                    swEnviar = null;
                }
                // Busca o cliente pela própria chave da hash table, não precisa de laço for e tal...
                if ((clienteTCPOrigem = (TcpClient)ChatServer.htUsuarios[pacote.Usuario]) != null)
                {
                    // Envia a mensagem para o usuário específico
                    swEnviar = new StreamWriter(clienteTCPOrigem.GetStream());
                    Pacote pacoteEnviar = new Pacote();
                    pacoteEnviar.Comando = Comando.MensagemPrivada;
                    pacoteEnviar.Mensagem = "Você deseja enviar o arquivo " + pacote.NomeArquivo + " para " + pacote.UsuarioDestino;
                    pacoteEnviar.Usuario = pacote.Usuario;
                    pacoteEnviar.UsuarioDestino = pacote.UsuarioDestino;
                    pacoteEnviar.NomeArquivo = pacote.NomeArquivo;
                    pacoteEnviar.TamanhoArquivo = pacote.TamanhoArquivo;
                    pacoteEnviar.ConteudoArquivo = pacote.ConteudoArquivo;
                    string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                    swEnviar.WriteLine(objEnviar);
                    swEnviar.Flush();
                    swEnviar = null;
                }
            }
            catch // Se tiver algum problema provavelmente o usuário não está mais conectado, vou remover ele da lista
            {
                RemoveUsuario(clienteTCPDestino);
            }
        }
Ejemplo n.º 6
0
        // Envia a lista de usuário atualizada para todos os usuários conectados
        public static void EnviaListaDeUsuariosAtualizada()
        {
            Hashtable listaDeUsuariosAtualizadaEnviar = new Hashtable();
            foreach (DictionaryEntry entry in ChatServer.htUsuarios)
            {
                // Cria lista valor/valor
                listaDeUsuariosAtualizadaEnviar.Add(entry.Key, entry.Key);
            }

            StreamWriter swSenderSender;

            // Create an array of TCP clients, the size of the number of users we have
            TcpClient[] tcpClients = new TcpClient[ChatServer.htUsuarios.Count];

            // Copy the TcpClient objects into the array
            ChatServer.htUsuarios.Values.CopyTo(tcpClients, 0);

            // Loop through the list of TCP clients
            for (int i = 0; i < tcpClients.Length; i++)
            {
                // Try sending a message to each
                try
                {
                    // If the message is blank or the connection is null, break out
                    if (tcpClients[i] == null)
                    {
                        continue;
                    }

                    // Send the message to the current user in the loop
                    swSenderSender = new StreamWriter(tcpClients[i].GetStream());

                    Pacote pacoteEnviar = new Pacote();
                    pacoteEnviar.Comando = Comando.ListaDeUsuarios;
                    pacoteEnviar.Usuario = ChatServer.NomeAdministrador;
                    pacoteEnviar.ListaDeUsuarios = listaDeUsuariosAtualizadaEnviar;
                    string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);

                    swSenderSender.WriteLine(objEnviar);
                    swSenderSender.Flush();
                    swSenderSender = null;
                }
                catch (Exception ex) // If there was a problem, the user is not there anymore, remove him
                {
                    RemoveUsuario(tcpClients[i]);
                    throw ex;
                }
            }
        }
Ejemplo n.º 7
0
        // Envia mensagens de um usuário para todos os outros
        public static void EnviaMensagem(Pacote pacote)
        {
            StreamWriter swSenderSender;

            // First of all, show in our application who says what
            e = new StatusChangedEventArgs(pacote.Usuario + " disse: " + pacote.Mensagem);
            OnStatusChanged(e);

            // Create an array of TCP clients, the size of the number of users we have
            TcpClient[] tcpClients = new TcpClient[ChatServer.htUsuarios.Count];
            // Copy the TcpClient objects into the array
            ChatServer.htUsuarios.Values.CopyTo(tcpClients, 0);
            // Loop through the list of TCP clients
            for (int i = 0; i < tcpClients.Length; i++)
            {
                // Try sending a message to each
                try
                {
                    // If the message is blank or the connection is null, break out
                    if (pacote.Mensagem.Trim() == "" || tcpClients[i] == null)
                    {
                        continue;
                    }
                    // Send the message to the current user in the loop
                    swSenderSender = new StreamWriter(tcpClients[i].GetStream());

                    Pacote pacoteEnviar = new Pacote();
                    pacoteEnviar.Comando = Comando.Mensagem;
                    pacoteEnviar.Mensagem = pacote.Usuario + " disse: " + pacote.Mensagem;
                    string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);

                    swSenderSender.WriteLine(objEnviar);
                    swSenderSender.Flush();
                    swSenderSender = null;
                }
                catch // If there was a problem, the user is not there anymore, remove him
                {
                    RemoveUsuario(tcpClients[i]);
                }
            }
        }
Ejemplo n.º 8
0
 // Este método é chamado de uma thread diferente e serve para atualizar o textbox de log do chat
 private void UpdateLog(Pacote pacote)
 {
     // Adiciona a linha e rola o texto para baixo
     txtLog.AppendText(pacote.Mensagem + "\r\n");
 }
Ejemplo n.º 9
0
        private void tsmi_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                // Guarda o path do arquivo
                PathArquivo = ofd.FileName;

                FileInfo fi = new FileInfo(ofd.FileName);

                // Enviando para o Servidor->UsuarioDestino a mensagem dizendo que eu quero enviar um arquivo
                pacoteEnviar = new Pacote();
                pacoteEnviar.Comando = Comando.EnviarArquivo;
                pacoteEnviar.Usuario = this.Usuario;
                pacoteEnviar.UsuarioDestino = lbUsuarios.Text;
                pacoteEnviar.Mensagem = null;
                pacoteEnviar.NomeArquivo = Path.GetFileName(ofd.FileName);
                pacoteEnviar.TamanhoArquivo = fi.Length.ToString();
                pacoteEnviar.ConteudoArquivo = null;
                string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                swEnviar.WriteLine(objEnviar);
                swEnviar.Flush();
                txtMensagem.Lines = null;
            }
        }
Ejemplo n.º 10
0
        // Responsável por gerenciar as mensagens
        private void RecebeMensagens()
        {
            // Recebe os pacotes do servidor
            srReceber = new StreamReader(tcpServidor.GetStream());

            // Lê o pacote recebido
            string retorno = srReceber.ReadLine();

            pacoteRecebido = JsonConvert.DeserializeObject<Pacote>(retorno);

            // Conforme o comando recebido vejo o que aconteceu
            if (pacoteRecebido.Comando == Comando.ConectadoComSucesso)
            {
                // Atualiza o form para informar que se conectou
                this.Invoke(new UpdateLogCallback(this.UpdateLog), new object[] { "Conectado com sucesso!" });
            }
            else // Como o comando não foi de conectado, então qualquer outro comando neste momento é porque não se conectou
            {
                string motivo = "Não conectado: " + pacoteRecebido.Mensagem;

                // Atualiza o form com o motivo de porque não pode se conectar
                this.Invoke(new CloseConnectionCallback(this.FinalizaConexao), new object[] { motivo });

                // Sai do método
                return;
            }

            // Enquanto estiver conectado lê as linhas que vierem do servidor
            while (Conectado)
            {
                try
                {
                    string conteudoRecebido = srReceber.ReadLine();

                    if (conteudoRecebido != null)
                    {
                        pacoteRecebido = JsonConvert.DeserializeObject<Pacote>(conteudoRecebido);

                        if (pacoteRecebido.Comando == Comando.ListaDeUsuarios)
                        {
                            this.Invoke(new UpdateListaUsuariosCallback(this.UpdateLista), new object[] { pacoteRecebido.ListaDeUsuarios });
                        }
                        else if (pacoteRecebido.Comando == Comando.EnviarArquivo ||
                                pacoteRecebido.Comando == Comando.AceiteDoArquivo ||
                                pacoteRecebido.Comando == Comando.ArquivoRecusado ||
                                pacoteRecebido.Comando == Comando.EnviandoArquivo)
                        {
                            // Estão querendo me enviar um arquivo
                            if (pacoteRecebido.Comando == Comando.EnviarArquivo && RecebendoArquivo == false)
                            {
                                if (MessageBox.Show(this.Usuario + " você deseja receber o arquivo: " + pacoteRecebido.NomeArquivo + " de " + pacoteRecebido.Usuario + "?", "Receber arquivo", MessageBoxButtons.YesNo) == DialogResult.Yes)
                                {
                                    RecebendoArquivo = true;
                                    // Criando novo pacote
                                    pacoteEnviar = new Pacote();
                                    pacoteEnviar.Comando = Comando.AceiteDoArquivo;
                                    pacoteEnviar.Usuario = this.Usuario;
                                    pacoteEnviar.Mensagem = pacoteRecebido.Mensagem;
                                    pacoteEnviar.NomeArquivo = pacoteRecebido.NomeArquivo;
                                    pacoteEnviar.TamanhoArquivo = pacoteRecebido.TamanhoArquivo;
                                    pacoteEnviar.ConteudoArquivo = null;
                                    pacoteEnviar.UsuarioDestino = pacoteRecebido.Usuario;
                                    string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                                    swEnviar.WriteLine(objEnviar);
                                    swEnviar.Flush();
                                }
                            }
                            else if (pacoteRecebido.Comando == Comando.AceiteDoArquivo) // Aceitou o arquivo, vou enviar ele agora
                            {
                                // Lê o arquivo de forma binária
                                FileStream fsr = new FileStream(PathArquivo, FileMode.Open);
                                byte[] bufferRead = new byte[fsr.Length];
                                BinaryReader br = new BinaryReader(fsr);
                                br.Read(bufferRead, 0, (int)fsr.Length);
                                br.Close();

                                // Converte o arquivo em base64 para poder enviar como string
                                string arquivoConvertido = Convert.ToBase64String(bufferRead);

                                // Criando novo pacote
                                pacoteEnviar = new Pacote();
                                pacoteEnviar.Comando = Comando.EnviandoArquivo;
                                pacoteEnviar.Usuario = this.Usuario;
                                pacoteEnviar.Mensagem = null;
                                pacoteEnviar.UsuarioDestino = pacoteRecebido.Usuario;
                                pacoteEnviar.NomeArquivo = Path.GetFileName(this.PathArquivo);
                                pacoteEnviar.TamanhoArquivo = bufferRead.LongLength.ToString();
                                pacoteEnviar.ConteudoArquivo = arquivoConvertido;
                                string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                                swEnviar.WriteLine(objEnviar);
                                swEnviar.Flush();
                            }
                            else if (pacoteRecebido.Comando == Comando.EnviandoArquivo && RecebendoArquivo) // O arquivo foi aceito e estou recebendo ele agora
                            {
                                SaveFileDialog sfd = new SaveFileDialog();
                                sfd.RestoreDirectory = true;
                                sfd.FileName = pacoteRecebido.NomeArquivo;
                                if (sfd.ShowDialog() == DialogResult.OK)
                                {
                                    byte[] bufferFromBase4 = Convert.FromBase64String(pacoteRecebido.ConteudoArquivo);
                                    FileStream fsw2 = new FileStream(sfd.FileName, FileMode.Create);
                                    BinaryWriter bw2 = new BinaryWriter(fsw2);
                                    bw2.Write(bufferFromBase4);
                                    bw2.Close();
                                    RecebendoArquivo = false;
                                }
                            }
                            else
                            {
                                // Criando novo pacote
                                pacoteEnviar = new Pacote();
                                pacoteEnviar.Comando = Comando.ArquivoRecusado;
                                pacoteEnviar.Usuario = this.Usuario;
                                pacoteEnviar.UsuarioDestino = pacoteRecebido.Usuario;
                                pacoteEnviar.Mensagem = pacoteRecebido.Mensagem;
                                pacoteEnviar.NomeArquivo = pacoteRecebido.NomeArquivo;
                                pacoteEnviar.TamanhoArquivo = pacoteRecebido.TamanhoArquivo;
                                pacoteEnviar.ConteudoArquivo = null;
                                string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
                                swEnviar.WriteLine(objEnviar);
                                swEnviar.Flush();
                            }
                        }
                        else
                        {
                            this.Invoke(new UpdateLogCallback(this.UpdateLog), new object[] { pacoteRecebido.Mensagem });
                        }
                    }
                }
                catch (SocketException SocketEx)
                {
                    Conectado = false;
                    //throw SocketEx;
                }
                catch (Exception ex)
                {
                    Conectado = false;
                    //throw ex;
                }
            }
        }
Ejemplo n.º 11
0
        // Inicia a conexão
        private void IniciaConexao()
        {
            endereçoIP = IPAddress.Parse(txtIp.Text);

            // Inicia a conexão com o servidor do chat
            tcpServidor = new TcpClient();
            tcpServidor.Connect(endereçoIP, (int)nudPorta.Value);

            // Define que está conectado
            Conectado = true;

            Usuario = txtUsuario.Text;

            // Desabilita e habilita os devidos campos
            txtIp.Enabled = false;
            txtUsuario.Enabled = false;
            nudPorta.Enabled = false;
            txtMensagem.Enabled = true;
            btnEnviar.Enabled = true;
            btnConectar.Text = "Desconectar";

            // Stream para envio de pacotes para o servidor
            swEnviar = new StreamWriter(tcpServidor.GetStream());

            // Criando novo pacote
            pacoteEnviar = new Pacote();
            pacoteEnviar.Comando = Comando.Conectar;
            pacoteEnviar.Usuario = this.Usuario;
            pacoteEnviar.Mensagem = "entrando no chat...";
            string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
            swEnviar.WriteLine(objEnviar);
            swEnviar.Flush();

            // Inicia a thread para receber pacotes do servidor e novas comunicações do mesmo
            threadMensagens = new Thread(new ThreadStart(RecebeMensagens));
            threadMensagens.SetApartmentState(ApartmentState.STA);
            threadMensagens.Start();
        }
Ejemplo n.º 12
0
 // Envia a mensagem digitada para o servidor
 private void EnviaMensagem()
 {
     if (txtMensagem.Lines.Length >= 1)
     {
         if (lbUsuarios.Text != null && lbUsuarios.Text != "" && lbUsuarios.Text != this.Usuario)
         {
             pacoteEnviar = new Pacote();
             pacoteEnviar.Comando = Comando.MensagemPrivada;
             pacoteEnviar.Usuario = this.Usuario;
             pacoteEnviar.UsuarioDestino = lbUsuarios.Text;
             pacoteEnviar.Mensagem = txtMensagem.Text;
             string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
             //var resposta = Encoding.ASCII.GetBytes(objEnviar);
             swEnviar.WriteLine(objEnviar);
             swEnviar.Flush();
             txtMensagem.Lines = null;
         }
         else
         {
             pacoteEnviar = new Pacote();
             pacoteEnviar.Comando = Comando.Mensagem;
             pacoteEnviar.Usuario = this.Usuario;
             pacoteEnviar.Mensagem = txtMensagem.Text;
             string objEnviar = JsonConvert.SerializeObject(pacoteEnviar);
             //var resposta = Encoding.ASCII.GetBytes(objEnviar);
             swEnviar.WriteLine(objEnviar);
             swEnviar.Flush();
             txtMensagem.Lines = null;
         }
     }
     txtMensagem.Text = "";
 }