Introdução
     Bem, talvez você já tenha rodado bastante em busca de algo sobre sockets no Delphi, e acho que você vai gostar bastante do conteúdo encontrado neste artigo. Falando um pouco sobre mim: Meu nome é João Nelson Lima, trabalhei com Delphi em uma empresa de automação comercial durante 1 ano e seis meses. Mas antes já utilizava o Delphi, mas nada de forma profissional, vamos dizer assim. Hoje tenho 22 anos e moro em Fortaleza. Sou estudante do CEFET – CE. Meu e-mail é jnelson3@ig.com.br. E assim como você,  enfrento os mesmo problemas para encontrar conteúdos avançados de Delphi. Por isso resolvi passar meus conhecimentos para os interessados. E por favor se alguém for mudar ou publicar me comunique. Dúvidas e sugestões são bem vindas. Por fim gostaria de desejar a você, caro leitor, uma excelente leitura e um aprendizado útil e empolgante.

Instalando os compoentes no Delphi 7
 

     Para isso vá no menu Component | Install Packages... Na janela que ira surgir clique no botão Add... e procure pelo arquivo dclsockets70.bpl. De OK e pronto! Os componentes irão aparecer na palleta Internet.

Agora vamos direto ao Assunto

  TserverSocket – Este componente como o nome já diz é o SERVIDOR. Ele será responsável por receber as conexões. De quem? Dos TClientSocket! É importante perceber este conceito em que cada TclientSocket conecta a um e somente um servidor. Sempre que você quiser fazer uma comunicação usara no mínimo um Server e um Client (Vamos passar a chamá-los assim OK?) Um outro detalhe super importante é que no caso do servidor ele recebe um integer de conexões.

Configuração mínima:

O circulo maior representa o server e o quadrado pequeno é o cliente.

TclientSocket – Este componente como o nome já diz é o CLIENTE. É com ele que conectamos aos servidores. Pense nele como a janela do seu browser. Com ele podemos nos conectar em qualquer servidor. Mas para isso temos que fazer alguns ajustes que veremos a seguir. Por enquanto é importante pegar o conceito de que cada Client se liga somente e diretamente a um Server e o Server poder receber vários Clients. De cara pode surgir a seguinte duvida: Ora, se o client está ligado no servidor como faço para ele falar com outro client ??? Não tem saída meu caro! Sempre vai passar pelo servidor, não há mágica, o que vai acontecer que iremos informar ao servidor o destinatário final da mensagem quando o servidor receber e “perceber” que a mensagem deve se entregue a outro Client, ele irá enviar uma mensagem ao Client correspondente. Isso é o protocolo de comunicação, ele é pessoal e cada um vai implementar como achar melhor.

Iniciando a comunicação

     Irei primeiro explicar as conexões simples, que tem no exemplo do Delphi. Esta conexão simples serve apenas para comunicar um cliente a um servidor e vice versa.
Neste projeto iremos construir duas aplicações, uma servidora e outra cliente, com o objetivo de fazer um Chat.
     Por questões didáticas iremos começar pelo servidor que terá a medíocre missão de confirmar uma informação recebida.
     Com o Delphi aperto e um novo projeto iniciado colocaremos somente o componente TServerSocket e iremos alterar as propriedade PORT para 2255 e NAME para Servidor. Teremos:

     É claro que o número da porta pode usar outro, mas por padrão adotei este aleatoriamente.
     Agora vamos configurar os eventos. Primeiro os do componente depois o Form1. No componente TServerSocket que iremos chamar de Server ou componente Servidor, iremos programar o evento OnClientRead. Este evento é acionado sempre que chaga algo no servidor, isto é, sempre que um cliente envia algum dado.
     Como já foi dito antes nossa aplicação ira apenas confirmar que recebeu algo, então iremos deixar a procedure assim:
 

procedure TForm1.ServidorClientRead(Sender: TObject; Socket: TCustomWinSocket);
begin
  Servidor.Socket.Connections[0].SendText('Recebi algo');
end;

Isso fará com que que o servidor ao receber qualquer dado, envie uma resposta, ou seja uma string contendo “Recebi algo” para a primeira conexão.  
Para inicio precisamos agora somente ativar nosso Servidor. Então o evento OnCreate do Form deve ficar assim:

procedure TForm1.Form1Create(Sender: TObject);
begin
  Servidor.Active := True;
End;

     Agora vamos para o lado do Cliente. Para isso devemos iniciar uma nova aplicação. E colocaremos o componente TclientSocket, um memo, um Button, e um edit. O arranjo dos componentes é 100% pessoal mas o meu ficou com essa cara:
 

     Com os componentes posicionados, iremos alterar algumas propriedade básicas. De cara temos que mudar o NAME do TClientSocket para CLIENTE e iremos atribuir o mesmo valor que foi dado a propriedade Port do servido para a do cliente isso é 2255. e claro o Address(endereço) que vai ser o o IP, no nosso caso o 127.0.0.1 que é o de LOOPBACK, pois as duas aplicações rodarão na mesma maquina.
     Iremos programar os comando de envio e recebimento de mensagens no formato string =) com isso já conseguiremos fazer um chat, mas somente entre as duas aplicações, para que possamos adicionar mais pessoas teremos que modificar a maneira como o servidor vai gerenciar as conexões e isso requer mais cuidados, conceito de alocação dinâmica e ponteiros. Que veremos mais adiante.
     O Edit1 vai ser a entrada de texto que vai ser enviada o botão vai executar o procedimento para enviar e no memo guardaremos as respostas do servidor.
     Observe os códigos e veja como é simples:

Evendo OnClick do Botão:

Procedure TForm1.Button1Click(Sender: TObject);
begin
  CLIENTE.Socket.SendText(Edit1.Text);
end ;

Evento onRead do TclientSocket:

procedure TForm1.ClienteRead(Sender: TObject; Socket: TCustomWinSocket);
begin
    Memo1.Lines.Add(Socket.ReceiveText);
end;

E claro a ativação do servidor no onCreate do Form1:

procedure TForm1.FormCreate(Sender: TObject);
begin
  CLIENTE.Open;
end;

Meu caro agora você já pode rodar as duas aplicações e ver o que acontece. Lembre-se que PRIMEIRO RODE O SERVIDOR e depois o cliente. Fácil perceber o porque.

Indo alem
 
Iremos agora dar um passo a frente, vamos ver como colocar mais um cliente conectado no servidor.
Experimente rodar duas vezes o aplicativo cliente, observe que a conexão é efetivada e que você pode a partir deste segundo cliente enviar mensagens para o servidor, mas quanto ao recebimento da resposta, todos vão para o o primeiro =/ e somente vai para o segundo se o primeiro sair. Teste! Experimente.... e comprove
 
Parando pra pensar

Ficou fácil notar que aquele 0 (Zero) no comando lá em cima usado para enviar uma resposta pra o cliente se refere ao numero da conexão destino.

Servidor.Socket.Connections[0].SendText('Recebi algo');

Isso é uma contagem direta que o servidor faz começa no 0 e vai até o limite do tipo INTEGER. Quando entra um ele passa a ser o ZERO se entrar outro passa a ser o 1 e outro passa a ser o 2 e assim por diante, isso muda se alguém sair, é como uma pilha quem está em cima do que saiu cai uma posição. Assim se o que tava na posição um desconectar o ZERO não se altera mais a partir do DOIS todos caem uma posição e logo o que era 2 passa a ser o UM.
Vamos imaginar a seguinte situação, o usuário A se conectou logo então ele pegou a posição 0(zero), isso quer dizer que sempre que enviar o comando

Servidor.Socket.Connections[0].SendText(’qualquer texto aqui dentro’);
 
Esse texto então só vai para o usuário A. Agora o usuário B entra e caso nos queremos enviar uma mensagem para B temos que informar index 1 assim:

Servidor.Socket.Connections[1].SendText(’qualquer texto aqui dentro’);

Fica extremamente obvio que no caso de um usuário C entrar o index deve ser 2, logo temos uma rotina pra que o servidor envie o que receber para todos os usuários. Isso é temos o principio de um principio de programa de chat =)

Agora toda mensagem que chegar no servidor, ao invés de ser apenas confirmada vai ser retornada a todos os usuários que a ele estão conectados.

Iremos modificar o evento OnClientRead para que fique assim:

procedure TForm1.ServidorClientRead(Sender: TObject; Socket: TCustomWinSocket);
Var MsgRecebida : String;
I : integer;
begin
 
  MsgRecebida := socket.ReceiveText;  // Pega o conteúdo enviado

  For i := 0 to ServerSocket1.Socket.ActiveConnections-1 do
     Serversocket1.Socket.Connections[i].SendText(MsgRecebida);

end;

Simples não é? Pegamos o conteúdo que foi enviado, e mandamos para todos os conectados no momento. Inclusive ao usuário que mando a mensagem. Isso é... Fizemos um Chat. Sugiro que coloque mais um Edit na aplicação cliente para que sirva como um campo para o Nick dos usuários e agora no evento de clique do botão ajuste para enviar o “nick” da pessoa, por exemplo:

‘<’+Edit2.text+’> ’ +edit1.text;
 
Muito simples =) realmente sim. O problema é que normalmente temos que enviar dados específicos para cada usuário, sentimos essa necessidade logo que pensamos em fazer uns sistema com logon, em que se pede senha, teremos q confirmar se o usuário está liberado ou não. Outra necessidade é quando temos que enviar mensagem em modo privado. Isso temos que saber quem é quem nas conexões.
 
Entendeu isso? Se nosso gerenciador de conexões não coordenar direitinho quem cai quem ta na posição 0, 1, 2 e etc  podemos ter complicações serias. Se você tentar mandar mensagem para uma conexão que não existe certamente vai dar pau e se você não coordenar estas conexões de forma eficiente provavelmente uma mensagem que ia pra FULANO pode ira pra o BELTRANO.

Entendido esta etapa temos que somente agora aprender a como gerenciar isso. Vamos então criar um GC ou seja o gerenciador de conexões.

 O Primeiro passo é saber como vamos organizar as conexões. A idéia base é gerar é identificar cada conexão com um código e armazenar em uma estrutura igual a pilha de conexões do componente assim sendo quando algum cliente conectar adicionaremos a nossa estrutura o código da conexão, quando sair deletamos, caso queiramos enviar uma mensagem particular procuramos em nossa estrutura identificamos a posição, e enviaremos =)

Iniciando o gerenciador de conexões
 
Analisamos o que o Delphi nos trás, encontrei o TList que é uma estrutura pronta para gerenciar ponteiros em pilha. Para gerar os códigos iremos usar ponteiros até porque é a forma de identificarmos os usuários quando conectam, desconectam ou enviam mensagens. Através da propriedade DATA.

 Declarei a variável
 
IDConexoes : TList;


No evento onCreate  do form principal criei o IDConexoes assim:

IDConexoes := TList.Create;
IDConexoes.Clear;

No evento OnClose do form principal liberei ele da memória assim:

IDConexoes.Free;


Agora vamos a parte que requer mais atenção, iremos programar o evento On ClientConnect e o OnClientDisconnect.

Primeiro a conexão do cliente:
 

procedure TForm1.ServidorClientConnect(Sender: TObject; Socket: TCustomWinSocket);
Var IDsocket : ^byte;
begin
 New(IDSocket);
 Socket.Data := IDSocket;
 IDConexoes.Add(Socket.data);
end;


O que fiz foi simplificar ao máximo. Criei uma variável local como ponteiro, reservei um ponteiro novo para a conexão informei que o ponteiro pertence a ela e adicionei o endereço na nossa lista.

Agora o procedimento de desconexão

procedure TForm1.ServerSocket1ClientDisconnect(Sender: TObject;
Socket: TCustomWinSocket);
Var NumConex : integer;
Begin
IDConexoes.Remove(Socket.Data);
Dispose(Socket.Data);
end;


Percebeu como esse TList é show? Ele faz tudo sozinho!

Como localizar o cliente....

Para finalizar vamos ver como responder somente para o cliente que enviou a mensagem. Por exemplo, suponhamos que estejam conectados os usuários A, B e C, mas não sabemos quem está em qual posição. Mas está registrado as entradas no nosso TList (IDConexoes). E temos que enviar uma mensagem resposta para o cliente B como. Vamos admitir que sempre que ele escrever ‘HORAS?’ vamos enviar uma string com a hora atual. Ok? A pergunta que teima em pairar no ar é “Como saber o INDEX dele?” Para responder temos que voltar para o evento onClientRead, mas e antes iremos criar a função LocalizaCliente, assim:

Function TForm1.LocalizaCliente(Cli : Pointer):Integer;
Begin
Result := IDConexoes.IndexOf(Cli);
End;


Agora sim vamos ao evento :

procedure TForm1.ServerSocket1ClientRead(Sender: TObject;
Socket: TCustomWinSocket);
Var Msg : String;
IDCli : integer;
HoraStr : String;
begin
Msg := socket.ReceiveText;
If Msg = ‘HORA?’ then
  Begin    
IDCli := LocalizaCliente(Socket.Data);
  HoraStr := FormatDateTime('HH:mm:ss',Now);
     
If (IDCli >= 0) then
  Servidor.Socket.Connections[IDCli].SendText(HoraStr);
end;
end;


Moleza não? Espero que tenha ficado tudo claro.Esse assunto é muito extenso. Espero que tenha esclarecido algo. Qualquer coisa podem me encontrar por e-mail e no MSN Menssager também. Até +, forte abraço e tudo de bom,

Nelson Lima - Diretor Geral.
NeoSoft - “Seu futuro é o nosso presente”