Newsgroup: it.comp.lang.delphi
Titolo: Chat in delphi 7 problemi

Come da oggetto vorrei realizzare una chat con i componenti standard di 
delphi 7 clientsocket e serversocket.
l'applicativo che devo realizzare deve poter inviare dal form client un 
messaggio testuale al form server il quale volendo puo anche rispondere.
potreste inviarmi degli esempi, sono accetti tutti i suggerimenti
vi premetto che odio i componenti indy con i quali mi sono gia imbattuto 
senza ottenere nessun risultato.
vi ringrazio anticipatamente
...:::LORDMASTER:::...

Odi gli Indy?...
Sai che ho fatto con gli Indy io?...dopo aver reversato il protocollo di uno
strafamosissimo messenger (non quello di MS), mi sono rifatot il client
proprio con le indy...ed e stato un gioco da ragazzi gestire le
comunicazioni.
Il mio e solo un consiglio...prova con le Indy...sono fenomenali! (guardati
gli esempi scaricabili dal sito).
MichelinoK

 ha scritto nel messaggio
news:FpYVd.1002958$35.37...@news4.tin.it...


 comunicazioni.
[..]
Mi associo al giudizio MichelinoK.
Ho scaricato ed installato gli Indy10 (li puoi installare gią da Delphi 5)
per realizzare un client di servizi web, devo dire che la quantita' di
componenti che mettono a disposizione e' veramente notevole.
Ciao
Alf.

 senza ottenere nessun risultato.
Peccato, perchè sono senz'altro più "quotati" dei componenti che hai 
citato, che se non ricordo male sono pure dichiarati obsoleti. :-)
Ciao!
-- 
Marco «Alka» Breveglieri
  (marco [@] abls [.] it)
  ABLS Team S.n.c. - Software & Web
  42019 Scandiano (Reggio Emilia)
 
http://www.abls.it

Anche per me i componenti Indy sono troppo complessi, anche se ammetto che 
siano molto completi...
Tuttavia sono un'implementazione (seppur avanzata) degli stessi 
TServerSocket e TClientSocket...
TClientSocket e TClientSocket sono le astrazioni di base su cui si poggiano 
tutte le applicazioni di rete in senso lato...
Esiste una cosa detta Standard OSI secondo cui e possibile scomporre una 
applicazione in livelli logici: ai livelli piu bassi c'e l'hardware ovvero i 
file/cavi che realizzano fisicamente la rete, a livelli piu alti i 
protocolli di trasmissione dati come ad esempio TCP/IP fino ad arrivare ai 
livelli altissimi che sono i protocolli di trasmissione che l'applicazione 
usa per interagire... I Socket stanno a meta strada circa, e fanno da "tres 
d'union" tra gli algoritmi dell'applicazione ed il TCP/IP... Chiaramente in 
quest'ottica i componenti Indy stanno un livello sopra i Sockets: usano i 
Sockets (e mascherano il loro utilizzo ai livelli superiori) ma non si 
fermano alla semplice instaurazione di una connessione tra due macchine in 
rete ma definiscono anche tutto il "vocabolario" (cioe tutte le cose che si 
possono dire, ovvero il protocollo di trasmissione) e lo usano per 
dialogare...
Quali siano meglio non lo so, la risposta migliore da dare in questi casi e 
sempre "dipende"... Se devi realizzare qualcosa di snello e/o di complessita 
facilemnte gestibile mi sento di consigliarti i Sockets, se devi realizzare 
qualcosa di complesso o vuoi riusare codice gia pronto (o meglio non doverne 
riscrivere una copia tua partendo da zero) ti conviene imparare a usare gli 
Indy che ci metti di sicuro meno tempo...
Ad ogni modo, se cerchi informazioni in questo senso, ti consiglio di 
cercare in Goggle "Reti di Calcolatori" o stringhe di ricerca simili... in 
quell'esame universitario si discute di questi argomenti esaustivamente, 
anche da un punto di vista pratico, con molti esempi di programmazione... 
sfortunatamente Delphi sembra essere un linguaggio difficilmente usato o 
comunque snobbato in ambito universitario e quindi e piu probabile che trovi 
codice in c, java o .NET, ma se sai programmare non ti dovrebbe essere 
difficile migrare da un linguaggio ad un altro... Ti posso dire per 
esperienza personale che con Java/C l'uso delle Sockets e molto piu 
immediato che in Delphi, con .NET non ti so dire...
Spero d'esserti stato d'aiuto,
   Ste 


Il messenger che ho "ricostruito ed abbellito con moltissime funzioni" non
posso dirlo per motivi di "legalitą" (reversare un protocollo č illegale!),
per le indy, ho usato le 9 (e non le ultime).
Ho iniziato piazzando il componente tcp/ip server su una form e il tcp/ip
client su un'altra ed a farli dialogare (trovi esempi nelle demos di indy),
in seguito ho iniziato a reversare il protocollo con uno sniffer (se non ne
hai mai usato nessuno,č una tragedia).
Tutto qua :)

[...] ho iniziato a reversare il protocollo con uno sniffer [...].
che sniffer utilizzi?
	Ciao
	MassimoB
 
---------------------------
http://www.massimobeschi.it/

vi ringrazio moltissimo per i consigli
ringrazio particolarmente stefano bragaglia per la sua esaustiva 
spiegazione anche se conosco molto bene l'architettura iso/osi
e riconosco che ha pienamente ragione su quello che dice
però il mio problema era piu alto cioe la difficolta nello scrivere un 
programma che permettesse di scambiare messaggi testuali.per quanto 
riguarda i componenti indy ho visto degli esempi e devo dire che non ci 
capisco molto sono troppo complessi e per quello che serve a me penso 
che basterebbero i componenti standard.
ho visto degli esempi di chat fatti con gli indy e devo dire che per 
scambiare solo messaggi di testo fanno un casino vero e proprio.
con gli indy ci si complica troppo la vita a me serve solo scambiare 
testo tra un client e un server.
quindi se avete realizzato gia programmi simili vi chiedo la cortesia di 
darmi una mano per realizzarne uno anche io, anche perche mi servirebbe 
come inizio per realizzare un applicativo (piu completo e carino) di 
comunicazione tra due utenti all'interno di una lan con l'inserimento 
anche di database con elenchi di utenti ecc...ecc...,tutto questo lo 
porterei come progetto per gli esami di maturita.
grazie mille
...:::LORDMASTER:::...

lo devi fare proprio in Delphi o va bene anche java?
due miei amici hanno fatto un programma di chat per l'esame di Reti di 
Calcolatori, se vuoi ti do l'indirizzo...
c'è spiegato tutto per filo e per segno... ma è in java appunto...
Io sto facendo una cosa simile per dare l'esame, ma non so in quanto tempo 
sarà pronto...
Ciao,
  Ste 

www.ethereal.com

 log...
Teoricamente dovrebbe funzionare...dovresti provare...cmq lo sniffer che uso
(
www.ethereal.com
) è MOLTO completo (comprende un'analizzatore di
protocolli...in pratica durante la sniffatura [uhm...ihihihih] si accorge se
è un protocollo noto o no , se lo riconosce ti fà anche i dettagli dei
comandi etc...) e devi prima installare un driver di sistema (lavora ad un
livello molto basso del s.o.).
E' fenomenale!

 ha scritto nel messaggio
news:HKdWd.5558$WC1...@tornado.fastwebnet.it...

Posteresti l'indirizzo? Sono interessato all'implementazione Java :)

 
sarebbe meglio in delphi cmq Sempre se vuoi mi farebbe piacere vedere 
(anche per farmi un'idea)il lavoro che ha fatto il tuo amico.

aaahhhh!
ma lavora a livello di driver!!! ora mi spiego tutto!!!
già perchè i sistemi operativi hanno la memoria protetta cioè ogni cosa 
eseguita sulla macchina (un processo) non può andare a "sporcare" i dati di 
altri processi in esecuzione... eccetto un driver! il driver viene eseguito 
in un modo che può andare a pescare i dati da leggere dove vuole e quindi 
anche su una porta già in uso!!!
comunque gli darò un'occhiata sono cose che è sempre bene imparare! ;-)
ciao e grazie
  Ste 

http://lia.deis.unibo.it/Courses/RetiDiCalcolatori/Progetti.htm
questa č l'home page dei progetti... di roba da spulciare ce n'č...
il progetto dei miei amici (breve ma intenso) č quello di 
Carloni/Castellari...
Ciao
  Ste 

http://lia.deis.unibo.it/Courses/RetiDiCalcolatori/Progetti.htm
questa e l'home page dei progetti... di roba da spulciare ce n'e...
il progetto dei miei amici (breve ma intenso) e quello di
Carloni/Castellari...
Ciao
  Ste
PS... i poteri del copia e incolla! B-) 

mbuahahahahahahahahahah... il mondo èmmmmmiooooooooo!!!
volevo solo comunicare che sono riuscito a scrivere lo snifferino personale 
e che funziona!!!
è una sciocchezza, ma mi sento molto realizzato, potente ed imbattibile! B-D
ok, ora sgonfio il mio ego e vado a letto che domani si torna a studiare! 
:'-(
Ciao,
   Stefano 

Stefano Bragaglia ha scritto:

mi potresti dire come hai fatto???

...:::LORDMASTER:::...
	Ciao
	MassimoB
 
---------------------------
http://www.massimobeschi.it/
----------------Unit pas ------------------------
unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, IdTCPConnection, IdTCPClient, IdBaseComponent,
  IdComponent, IdTCPServer, ExtCtrls;
type
  TForm1 = class(TForm)
    GroupBox1: TGroupBox;
    GroupBox2: TGroupBox;
    Splitter1: TSplitter;
    MemoServer: TMemo;
    Splitter2: TSplitter;
    GroupBox3: TGroupBox;
    IdTCPServer1: TIdTCPServer;
    IdTCPClient1: TIdTCPClient;
    IdTCPClient2: TIdTCPClient;
    EditClient1: TEdit;
    ButtonClient1: TButton;
    MemoClient1: TMemo;
    EditClient2: TEdit;
    Button1: TButton;
    MemoClient2: TMemo;
    TimerClient1: TTimer;
    TimerClient2: TTimer;
    Button2: TButton;
    Button3: TButton;
    Button4: TButton;
    Button5: TButton;
    procedure IdTCPServer1Connect(AThread: TIdPeerThread);
    procedure IdTCPServer1Disconnect(AThread: TIdPeerThread);
    procedure IdTCPServer1Execute(AThread: TIdPeerThread);
    procedure TimerClient1Timer(Sender: TObject);
    procedure TimerClient2Timer(Sender: TObject);
    procedure ButtonClient1Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
    procedure Button5Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.IdTCPServer1Connect(AThread: TIdPeerThread);
begin
  MemoServer.Lines.Add('Connect: ' + AThread.Connection.LocalName);
end;
procedure TForm1.IdTCPServer1Disconnect(AThread: TIdPeerThread);
begin
  MemoServer.Lines.Add('Disconnect: ' + AThread.Connection.LocalName);
end;
procedure TForm1.IdTCPServer1Execute(AThread: TIdPeerThread);
var
  Count: Integer;
  List : TList;
  Msg  : String;
begin
  Msg := AThread.Connection.ReadLn;
  if Msg<>'' Then
  begin
    Msg := Trim(Msg);
    MemoServer.Lines.Add(AThread.Connection.LocalName + '> ' + Msg)
    List := IdTCPServer1.Threads.LockList;
    try
      for Count := 0 to List.Count -1 do
      try
        TIdPeerThread(List.Items[Count]).Connection.WriteLn(Msg);
      except
        TIdPeerThread(List.Items[Count]).Stop;
      end;
    finally
      IdTCPServer1.Threads.UnlockList;
    end;
  end;
end;
procedure TForm1.TimerClient1Timer(Sender: TObject);
var
  Msg : String;
begin
  if not IdTcpClient1.Connected then
    exit;
  Msg := IdTCPClient1.ReadLn('', 5);
  if Msg <> '' then
    MemoClient1.Lines.Add(Msg);
end;
procedure TForm1.TimerClient2Timer(Sender: TObject);
var
  Msg : String;
begin
  if not IdTcpClient2.Connected then
    exit;
  Msg := IdTCPClient2.ReadLn('', 5);
  if Msg <> '' then
    MemoClient2.Lines.Add(Msg);
end;
procedure TForm1.ButtonClient1Click(Sender: TObject);
begin
  IdTCPClient1.WriteLn(EditClient1.Text);
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
  IdTCPClient2.WriteLn(EditClient2.Text);
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
  IdTCPServer1.Active := true;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
  IdTCPClient1.Connect;
end;
procedure TForm1.Button3Click(Sender: TObject);
begin
  IdTCPClient1.Disconnect;
end;
procedure TForm1.Button4Click(Sender: TObject);
begin
  IdTCPClient2.Connect;
end;
procedure TForm1.Button5Click(Sender: TObject);
begin
  IdTCPClient2.Disconnect;
end;
end.
-------------------------------------------------------
-----------------Unit dfm-----------------------------
object Form1: TForm1
  Left = 141
  Top = 237
  Width = 679
  Height = 342
  Caption = 'Form1'
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'MS Sans Serif'
  Font.Style = []
  OldCreateOrder = False
  OnCreate = FormCreate
  PixelsPerInch = 96
  TextHeight = 13
  object Splitter1: TSplitter
    Left = 193
    Top = 0
    Width = 8
    Height = 308
    Cursor = crHSplit
  end
  object Splitter2: TSplitter
    Left = 433
    Top = 0
    Width = 8
    Height = 308
    Cursor = crHSplit
  end
  object GroupBox1: TGroupBox
    Left = 0
    Top = 0
    Width = 193
    Height = 308
    Align = alLeft
    Caption = 'Server'
    TabOrder = 0
    object MemoServer: TMemo
      Left = 2
      Top = 15
      Width = 189
      Height = 291
      Align = alClient
      TabOrder = 0
    end
  end
  object GroupBox2: TGroupBox
    Left = 201
    Top = 0
    Width = 232
    Height = 308
    Align = alLeft
    Caption = 'Client 1'
    TabOrder = 1
    DesignSize = (
      232
      308)
    object EditClient1: TEdit
      Left = 0
      Top = 40
      Width = 145
      Height = 21
      Anchors = [akLeft, akTop, akRight]
      TabOrder = 0
    end
    object ButtonClient1: TButton
      Left = 152
      Top = 40
      Width = 75
      Height = 25
      Anchors = [akTop, akRight]
      Caption = 'Invia'
      TabOrder = 1
      OnClick = ButtonClient1Click
    end
    object MemoClient1: TMemo
      Left = 1
      Top = 72
      Width = 225
      Height = 233
      Anchors = [akLeft, akTop, akRight, akBottom]
      TabOrder = 2
    end
    object Button2: TButton
      Left = 0
      Top = 16
      Width = 113
      Height = 25
      Caption = 'Connetti'
      TabOrder = 3
      OnClick = Button2Click
    end
    object Button3: TButton
      Left = 120
      Top = 16
      Width = 105
      Height = 25
      Caption = 'Disconnetti'
      TabOrder = 4
      OnClick = Button3Click
    end
  end
  object GroupBox3: TGroupBox
    Left = 441
    Top = 0
    Width = 230
    Height = 308
    Align = alClient
    Caption = 'Client 2'
    TabOrder = 2
    DesignSize = (
      230
      308)
    object EditClient2: TEdit
      Left = -8
      Top = 40
      Width = 145
      Height = 21
      Anchors = [akLeft, akTop, akRight]
      TabOrder = 0
    end
    object Button1: TButton
      Left = 140
      Top = 40
      Width = 75
      Height = 25
      Anchors = [akTop, akRight]
      Caption = 'Invia'
      TabOrder = 1
      OnClick = Button1Click
    end
    object MemoClient2: TMemo
      Left = 1
      Top = 72
      Width = 225
      Height = 233
      Anchors = [akLeft, akTop, akRight, akBottom]
      TabOrder = 2
    end
    object Button4: TButton
      Left = 0
      Top = 16
      Width = 113
      Height = 25
      Caption = 'Connetti'
      TabOrder = 3
      OnClick = Button4Click
    end
    object Button5: TButton
      Left = 120
      Top = 16
      Width = 105
      Height = 25
      Caption = 'Disconnetti'
      TabOrder = 4
      OnClick = Button5Click
    end
  end
  object IdTCPServer1: TIdTCPServer
    Bindings = <>
    CommandHandlers = <>
    DefaultPort = 3000
    Greeting.NumericCode = 0
    MaxConnectionReply.NumericCode = 0
    OnConnect = IdTCPServer1Connect
    OnExecute = IdTCPServer1Execute
    OnDisconnect = IdTCPServer1Disconnect
    ReplyExceptionCode = 0
    ReplyTexts = <>
    ReplyUnknownCommand.NumericCode = 0
    Left = 8
    Top = 24
  end
  object IdTCPClient1: TIdTCPClient
    MaxLineAction = maException
    Host = '127.0.0.1'
    Port = 3000
    Left = 208
    Top = 48
  end
  object IdTCPClient2: TIdTCPClient
    MaxLineAction = maException
    Host = '127.0.0.1'
    Port = 3000
    Left = 448
    Top = 48
  end
  object TimerClient1: TTimer
    Interval = 500
    OnTimer = TimerClient1Timer
    Left = 240
    Top = 48
  end
  object TimerClient2: TTimer
    OnTimer = TimerClient2Timer
    Left = 480
    Top = 48
  end
end
---------------------------------------------------

   Stefano


Allora io ho provato a fare una chat con i componenti indy ed ho 
riscontrato dei problemi(tipo quando chiudo l'applicazione senza 
disconnettere mi genere un'eccezzione) il listato è questo
ma devo per forza di cose utilizzare i thread?
Cosa ne pensate del codice
---------------------------------------------
unit Unit1;
interface
uses
   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, 
Forms,
   Dialogs, StdCtrls, IdTCPServer, IdBaseComponent, IdComponent,
   IdTCPConnection, IdTCPClient, IdThreadMgr, IdThreadMgrDefault, Menus,
   Sockets, OleCtrls, SHDocVw, XPMan, SimpleTCP, ComCtrls;
type
     TSimpleClient = class(TObject)
     DNS,
     Name        : String;
     ListLink    : Integer;
     Thread      : Pointer;
   end;
   TForm1 = class(TForm)
     Client: TIdTCPClient;
     Server: TIdTCPServer;
     txtmes: TEdit;
     lmes: TMemo;
     cmdinvia: TButton;
     txtusr: TEdit;
     cmdconnetti: TButton;
     IdThreadMgrDefault1: TIdThreadMgrDefault;
     MainMenu1: TMainMenu;
     txtnick: TEdit;
     Label1: TLabel;
     File1: TMenuItem;
     Modifica1: TMenuItem;
     N1: TMenuItem;
     Help1: TMenuItem;
     N2: TMenuItem;
     About1: TMenuItem;
     Copia1: TMenuItem;
     aglia1: TMenuItem;
     Incolla1: TMenuItem;
     Chiudi1: TMenuItem;
     Label2: TLabel;
     wb: TWebBrowser;
     localip1: TSimpleTCPServer;
     StatusBar1: TStatusBar;
     Extra1: TMenuItem;
     VisualizzaIP1: TMenuItem;
     Contatti1: TMenuItem;
     procedure cmdconnettiClick(Sender: TObject);
     procedure cmdinviaClick(Sender: TObject);
     procedure FormCreate(Sender: TObject);
     procedure ServerConnect(AThread: TIdPeerThread);
     procedure ServerExecute(AThread: TIdPeerThread);
     procedure ServerDisconnect(AThread: TIdPeerThread);
     procedure FormClose(Sender: TObject; var Action: TCloseAction);
     procedure Chiudi1Click(Sender: TObject);
     procedure ClientDisconnected(Sender: TObject);
   private
     { Private declarations }
   public
     { Public declarations }
   end;
var
   Form1: TForm1;
implementation
   uses
   IdSocketHandle;  // This is where the IdSocketHandle class is defined.
{$R *.dfm}
procedure TForm1.cmdconnettiClick(Sender: TObject);
   begin
     if cmdconnetti.Caption='Connetti'then
       begin
         cmdconnetti.Caption:='Disconnetti';
         Client.Host := txtusr.Text;
         Client.Port :=50000;
           if txtnick.Text<>'' then
             begin
               Client.Connect;
               client.WriteLn('@connessione');
               client.WriteLn(localip1.LocalIP);
             end
           else
             begin
               Showmessage('Inserisci un nickname');
             end;
       end
     else
         begin
           cmdconnetti.Caption:='Connetti';
           client.Disconnect;
         end;
   end;
procedure TForm1.cmdinviaClick(Sender: TObject);
   begin
     if txtusr.Text='localhost'then
       begin
         Client.WriteLn(txtnick.Text+': '+txtmes.Text);
         txtmes.Text := '';
       end
     else
       begin
         Client.WriteLn(txtmes.Text);
         lmes.Lines.Add(txtnick.Text+': '+txtmes.Text);
         txtmes.Text := '';
       end;
   end;
procedure TForm1.FormCreate(Sender: TObject);
   begin
     server.Active:=true;
   end;
procedure TForm1.ServerConnect(AThread: TIdPeerThread);
   var
     Client1 : TSimpleClient;
   begin
     Client1 := TSimpleClient.Create;
     Client1.DNS  := AThread.Connection.LocalName;
     Client1.Thread := AThread;
     AThread.Data := Client;
   end;
procedure TForm1.ServerExecute(AThread: TIdPeerThread);
   var
     Msg: String;
   begin
     { Riceve il messaggio e lo visualizza}
     if client.Connected then
       begin
         Msg:=AThread.Connection.ReadLn;
         lmes.Lines.Add(msg);
       end
     else
       client.Disconnect;
   end;
procedure TForm1.ServerDisconnect(AThread: TIdPeerThread);
   begin
     server.Active:=false;
     client.Disconnect;
   end;
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
   begin
     server.Active:=false;
     client.Disconnect;
   end;
procedure TForm1.Chiudi1Click(Sender: TObject);
   begin
     server.Active:=false;
     client.Disconnect;
     close;
   end;
procedure TForm1.ClientDisconnected(Sender: TObject);
   begin
     client.Disconnect;
     server.Active:=false;
   end;
end.

end.
Mi sa che devi centralizzare un pò di cose in quanto
questi eventi eseguono tante volte la stessa cosa e ad
occhio e croce alle volte l'ordine di esecuzione di
alcune operazioni non lo vedo corretto ... ma devo
ancora capire bene come dovrebbe funzionare tale
applicativo ... vuoi ottenere un PeerToPeer o un
Client/Server?


MassimoB ha scritto:

Guarda io ti ringrazio per tutto quello che stai facendo mi stai dando 
veramente una mano...
:-)
allora l'apllicativo che vorrei fare in poche parole è:
una sola form la quale fa sia da server che da client in modo da 
distribuire solo un'applicazione.
l'applicazione poi dovra permettere di:
scambiare file e mandare messaggi.
in realtà il codice è un po macchinoso anche perche ho preso spunto da 
una demo.
tempo fa ho fatto la stessa cosa con Visual Basic ed era stato tutto 
molto piu semplice avevo fatto solo un'applicazione che faceva sia da 
client che da server.cosi facendo davo a tutti i miei amici sempre lo 
stesso software ,i quali inserendo l'indirizzo ip della persona con la 
quale volevano comunicare,potevano farlo senza collegamenti a server vari.
voglio fare tutto questo in delphi.aggiungendo la possibilità di 
scambiare file.
ti ringrazio ancora per gli eventuali suggerimenti
...:::LORDMASTER:::...
http://lordmasterc.altervista.org


http://lordmasterc.altervista.org
	Ciao
	MassimoB
 
---------------------------
http://www.massimobeschi.it/

Ancora buongiorno a tutti!
allora l'applicativo è finito ed è anche funzionante.
ora pero mi sorge un problema perche vorrei fare in modo che un utente x
collegato con l'utente y possa Comunicare vocalmente
Avete qualche idea su come potrei fare

supponendo che esista un componente per registrare dal microfono in wav o 
mp3 direttamente, lo usi per generare uno stream dati che passi attraverso 
la socket al destinatario.
il destinatario legge lo stream, ottiene il wav/mp3 e lo suona 
normalmente...
purtroppo non conosco componenti che registrino da microfono, ma non ho mai 
avuto modo di doverci ragionare...
ciao,
   Ste 

il problema non è tanto registrare l'audio perche penso che si possa fare
con il componente media player standard di delphi.
il problema è che quel componente registra e crea(una volta stoppata la
registrazione) un mp3 o un wav
quindi come faccio a trasformarlo in uno stream
e poi come si fa a creare uno stream.

 e poi come si fa a creare uno stream.
Analoga domanda venne posta tempo fa, le risposte vertevano sul protocollo
*voip*, e su skype o roger wilko devi informarti riguardo questo.
Guarda su Sourceceforge
Ciao
-- 
Morde. 
M-List di icld: 
http://it.groups.yahoo.com/group/icld/

ok, quelli sono protocolli e applicazioni di alto livello...
rimanendo più terra terra:
1) il sender ed il receiver del protocollo client/server che hai messo su 
per la tua applicazione sono entrambi dotati di media player di delphi 
(forse ne occorro due per lato, rivediamolo dopo)
2) il sender usa il media player per registrare l'mp3 o il wav, ma dove 
salva questi dati? normalmente in un file o in uno stream direttamente. se 
te lo salva in file tu dichiari un TFileStream a cui fai aprire il suddetto 
file ed hai lo stream che ti serve (ma credo che se il media player te lo fa 
salvare in mp3 o wav, te lo faccia parcheggiare direttamente in uno stream, 
senza bisogno di questo passaggio ridondante).
3) lo stream ottenuto al punto precedente viene attaccato al tcpclient o 
udpclient (vedi help di delphi per capire come) che lo invia all'altro lato 
della connessione, dal tcpserver o udpclient relativo, sempre sotto forma di 
stream.
4) l'altro lato ha anche lui un media player a cui gli passo lo stream 
(credo che si possa fare, se non si può crei un TFileStream, attacchi a lui 
lo stream e gli dici di salvarlo come file. al media player fai poi aprire 
quel file. secondo me questo è un passaggio ridondate, vedi sopra). una 
volta che il media player è configurato, suona i dati che gli sono stati 
passati.
NB) visto che probabilmente ogni "lato" dell'applicazione distribuita deve 
poter registrare dati da inviare e suonare i dati ricevuti, probabilmente 
ogni lato dovrà avere due media player e non uno come detto sopra... ma 
questo è ovvio...
di più non ti so dire... sono anche io perso nella realizzazione di una 
applicazione distribuita, di più non riesco a dirti...
ciao
    Ste 

Ma per caso non è che conosci qualche esempio per capire un po meglio.
un'altra cosa che non ho capito bene ma tu dici che il mediaplayer si trova
gia negli indy component tcpclient e tcpserver o devo mettere proprio il
componente standard che si trova nella palette system in delphi 7?

no, purtroppo non conosco esempi...
il tcpserver e il tcpclient sono i componenti di delphi nella palette 
internet per gestire connessioni affidabili via tcp... per quel che mi 
riguarda sono già troppo sofisticati... io di solito uso ServerSocket e 
ClientSocket... credo siano padri di TcpServer e TcpClient e non dovrebbero 
essere in nessun gruppo nella palette dei componenti... per comodità mia ho 
creato una classe fatta così:
unit SocketsReg;
interface
uses
  SysUtils, Classes, ScktComp;
procedure Register;
implementation
procedure Register;
begin
  RegisterComponents('Custom', [TServerSocket, TClientSocket]);
end;
end.
in modo da avere i componenti suddetti a portata di mano... una volta che 
hai creato la connessione vedi l'help su SendStream e ReceiveStream (a 
memoria mi pare siano questi i nomi) che ti permettono di scrivere/leggere 
dati dalla/alla socket sotto forma di flusso di byte (stream appunto).
il media player me lo hai citato tu, suppongo ti riferissi al componente nel 
gruppo System della palette, quello che per icona ha una nota gialla su una 
pellicola blu... so che serve per i contenuti multimediali, ma non avendolo 
mai usato non ti so dire nulla di più preciso... vista la filosofia di 
delphi, mi parrebbe strano che tale componente non permetta di usare gli 
stream...
ad ogni modo, supponi di avere il file audio.wav da trasferire, puoi fare:
var
  aFile: TFileStream;
...
aFile := TFileStream.Create ('c:\percorso\audio.wav', fmOpenRead);
try
  ClientSocket.Socket.SendStream (aFile);
finally
  aFile.Free;
end;
Dall'altra parte basta che fai l'opposto...
Ciao, buonanotte,
   Ste 

 componente standard che si trova nella palette system in delphi 7?
Se puņ esserti utile puoi provare a scaricare la AsyncPro di TurboPower. 
Ha anche dei componenti per la telefonia ed il VoiceOver Ip con degli 
esempi.
guastatore

 esempi.
Si gli ho visti ma non ci ho capito una mazza, ma qualcosa di piu semplice?
mi faresti un favorone anche perche mi manca solo questo per incominciare a
fare la documentazione in modo da portarlo agli esami di maturitą!.
grazie mille in anticipo