CClientInterface Class Reference

#include <clientinterface.h>

Public Member Functions

 CClientInterface ()
 ~CClientInterface ()
int Initialize ()
int Initialize (int SendFlag, double m_EstimatedTimeParameter)
void Stop ()
void Send (StrRequest *Request)
void Receive (StrRequest *Request)

Private Attributes

int m_SendFlag
int m_NumberOfBlocksToSend

Detailed Description

Definition at line 33 of file clientinterface.h.

Constructor & Destructor Documentation

CClientInterface::CClientInterface (  ) 

Definition at line 44 of file clientinterface.cpp.

00045 {
00046     m_SendFlag             = 0;
00047     m_NumberOfBlocksToSend = 0;
00048 }

CClientInterface::~CClientInterface (  ) 

Definition at line 51 of file clientinterface.cpp.

00052 {
00053 }

Member Function Documentation

int CClientInterface::Initialize ( int  SendFlag,
double  m_EstimatedTimeParameter 
)

Definition at line 63 of file clientinterface.cpp.

00064 {
00065     m_SendFlag = SendFlag;
00066     #ifdef RIO_DEBUG2
00067     RioErr << "Init SendFlag " << SendFlag << endl;
00068     #endif
00069     return 0;
00070 }

int CClientInterface::Initialize (  ) 

Definition at line 57 of file clientinterface.cpp.

00058 {
00059     return 0;
00060 }

void CClientInterface::Receive ( StrRequest *  Request  ) 

Definition at line 411 of file clientinterface.cpp.

00412 {
00413     //#ifdef RIO_DEBUG2
00414     // Estrutura usada para imprimir o IP do cliente no formato com o ".".
00415     struct in_addr clientip;
00416 
00417     clientip.s_addr = Request->IPaddress;
00418     //#endif
00419 
00420     // For now, we don't receive data from client but assume we did it
00421 
00422     // Setting state is not really necessary.
00423     // This may be removed or not, depending on if we will ever need to
00424     // use status for anything ...
00425     Request->Status = RequestStatusWaitReceive;
00426 
00427     // Send a status message to router telling it is ready to receive
00428     // data from client
00429 
00430     // A nova chamada a funcao NetInterface.FindIPAndPort e para verificarmos se
00431     // devemos usar a funcao do objeto da nova classe ou a funcao do objeto da 
00432     // classe antiga.
00433     if( NetInterface.FindIPAndPort( Request->IPaddress, Request->Port ) )
00434     {
00435         #ifdef RIO_DEBUG2
00436         RioErr << "CClientInterface::Receive recebendo um bloco de " 
00437                << Request->Size << " bytes para o cliente no IP " 
00438                << inet_ntoa( clientip ) << " e na porta "
00439                << ntohs( Request->Port ) << ", com o ID " 
00440                << Request->ClientId << " usando a nova implementacao de "
00441                << "rede." << endl;
00442         #endif
00443             
00444         NetInterface.GetBlock ( Request->IPaddress,
00445                                 Request->Port,
00446                                 Request->ClientId,
00447                                 Request->Data,
00448                                 Request->Size,
00449                                 ReceiveComplete,
00450                                 (void*) Request);
00451     }
00452     else
00453     {
00454         #ifdef RIO_DEBUG2
00455         RioErr << "CClientInterface::Receive recebendo um bloco de " 
00456                << Request->Size << " bytes para o cliente no IP " 
00457                << inet_ntoa( clientip ) << " e na porta "
00458                << ntohs( Request->Port ) << ", com o ID " 
00459                << Request->ClientId << " usando a implementacao antiga de "
00460                << "rede." << endl;
00461         #endif
00462             
00463         NetManager.GetBlock ( Request->IPaddress,
00464                               Request->Port,
00465                               Request->ClientId,
00466                               Request->Data,
00467                               Request->Size,
00468                               ReceiveComplete,
00469                               (void*) Request);
00470     }
00471 }

void CClientInterface::Send ( StrRequest *  Request  ) 

Definition at line 266 of file clientinterface.cpp.

00267 {
00268     // Variavel usada para sabermos se a copia sera feita via UDP sem 
00269     // retransmissao, ou via TCP.
00270     bool UseTcp;
00271     
00272     #ifdef RIO_DEBUG2
00273     struct in_addr clientip;
00274     clientip.s_addr = Request->IPaddress;
00275     //Este trecho de codigo eh impresso no log do storage
00276     RioErr << "clientinterface: Thread " << pthread_self()
00277            << " : SendFlag "         << m_SendFlag
00278            << " Send data to ip "    << inet_ntoa(clientip)
00279            << " port "               << ntohs( Request->Port )
00280            << " ClientId "           << Request->ClientId    << endl;
00281     #endif
00282     // ------------------------------------------------------------------------
00283     
00284     // Descobre se a copia sera via UDP sem retransmissao (envio em tempo real)
00285     // ou via TCP (envio em tempo nao real). Isso dependere do valor de
00286     // Request->StreamTraffic. 
00287     // TODO: O valor fico 3 era o usado no codigo da funcao SendData do objeto 
00288     // da classe RioNeti para a copia em tempo real. O conteudo deste campo 
00289     // (igual ao campo do mesmo nome da mensagem) parece ser o tipo do Evento do
00290     // servidor, dado pela estrutura EventType em server/Event.h (o 
00291     // identificador do evento no servidor associado a copia em tempo real, 
00292     // EventTypeRTDataRequest, e igual a 3). O que devemos fazer neste caso, ja 
00293     // que nao e correto incluirmos server/Event.h no neste arquivo? Mudamos a 
00294     // mensagem trocada entre o servidor e o storage para passarmos um valor 
00295     // booleano? Ou usamos o include e o comando a seguir se torna:
00296     // UseTcp = ( Request->StreamTraffic != EventTypeRTDataRequest );
00297     UseTcp = ( Request->StreamTraffic != 3 ); 
00298 
00299     if( m_SendFlag ==  1 )
00300     {
00301         // Alteracao para o controle de fluxo: passamos mais um parametro para
00302         // a funcao SendBlock: a taxa de transferencia do video, dada por
00303         // Request->VideoRate (em Kbps).
00304         // 
00305         // A nova chamada a funcao NetInterface.FindIPAndPort e para 
00306         // verificarmos se devemos usar a funcao do objeto da nova classe ou
00307         // a funcao do objeto da classe antiga.
00308         if( NetInterface.FindIPAndPort( Request->IPaddress, Request->Port,
00309                                         UseTcp ) )
00310         {
00311             #ifdef RIO_DEBUG2
00312             RioErr << "CClientInterface::Send enviando um bloco de " 
00313                    << Request->Size << " bytes para o cliente no IP " 
00314                    << inet_ntoa( clientip ) << " e na porta "
00315                    << ntohs( Request->Port ) << ", com o ID " 
00316                    << Request->ClientId << " usando a nova implementacao de "
00317                    << "rede." << endl;
00318             #endif
00319             
00320             NetInterface.SendBlock ( Request->IPaddress,
00321                                      Request->Port,
00322                                      Request->ClientId,
00323                                      Request->Data,
00324                                      Request->Size,
00325                                      SendComplete,
00326                                      (void*) Request,
00327                                      UseTcp,
00328                                      Request->VideoRate );
00329         } 
00330         else
00331         {
00332             #ifdef RIO_DEBUG2
00333             RioErr << "CClientInterface::Send enviando um bloco de " 
00334                    << Request->Size << " bytes para o cliente no IP " 
00335                    << inet_ntoa( clientip ) << " e na porta "
00336                    << ntohs( Request->Port ) << ", com o ID " 
00337                    << Request->ClientId << " usando a implementacao antiga de "
00338                    << "rede." << endl;
00339             #endif
00340             
00341             NetManager.SendBlock ( Request->IPaddress,
00342                                    Request->Port,
00343                                    Request->ClientId,
00344                                    Request->Data,
00345                                    Request->Size,
00346                                    SendComplete,
00347                                    (void*) Request,
00348                                    Request->StreamTraffic,
00349                                    Request->VideoRate );
00350         }
00351     }
00352     else
00353     {
00354         // For tests do not send the all block - m_SendFlag == 0
00355         // just 1500 bytes (1 packet)
00356         // Alteracao para o controle de fluxo: passamos mais um parametro para
00357         // a funcao SendBlock: a taxa de transferencia do video, dada por
00358         // Request->VideoRate (em Kbps).
00359         // 
00360         // A nova chamada a funcao NetInterface.FindIPAndPort e para 
00361         // verificarmos se devemos usar a funcao do objeto da nova classe ou
00362         // a funcao do objeto da classe antiga.
00363         if( NetInterface.FindIPAndPort( Request->IPaddress, Request->Port,
00364                                         UseTcp ) )
00365         {
00366             #ifdef RIO_DEBUG2
00367             RioErr << "CClientInterface::Send enviando um bloco de " 
00368                    << Request->Size << " bytes para o cliente no IP " 
00369                    << inet_ntoa( clientip ) << " e na porta "
00370                    << ntohs( Request->Port ) << ", com o ID " 
00371                    << Request->ClientId << " usando a nova implementacao de "
00372                    << "rede." << endl;
00373             #endif
00374             
00375             NetInterface.SendBlock ( Request->IPaddress,
00376                                      Request->Port,
00377                                      Request->ClientId,
00378                                      Request->Data,
00379                                      1452,
00380                                      SendComplete,
00381                                      (void*) Request,
00382                                      UseTcp,
00383                                      Request->VideoRate );
00384         }
00385         else
00386         {                                
00387             #ifdef RIO_DEBUG2
00388             RioErr << "CClientInterface::Send enviando um bloco de " 
00389                    << Request->Size << " bytes para o cliente no IP " 
00390                    << inet_ntoa( clientip ) << " e na porta "
00391                    << ntohs( Request->Port ) << ", com o ID " 
00392                    << Request->ClientId << " usando a implementacao antiga de "
00393                    << "rede." << endl;
00394             #endif
00395             
00396             NetManager.SendBlock ( Request->IPaddress,
00397                                    Request->Port,
00398                                    Request->ClientId,
00399                                    Request->Data,
00400                                    1452,
00401                                    SendComplete,
00402                                    (void*) Request,
00403                                    Request->StreamTraffic,
00404                                    Request->VideoRate );
00405         }
00406     }
00407 }

void CClientInterface::Stop ( void   ) 

Definition at line 74 of file clientinterface.cpp.

00075 {
00076     return;
00077 }

Field Documentation

int CClientInterface::m_NumberOfBlocksToSend [private]

Definition at line 46 of file clientinterface.h.

int CClientInterface::m_SendFlag [private]

Definition at line 45 of file clientinterface.h.

The documentation for this class was generated from the following files:
Generated on Wed Jul 4 16:03:31 2012 for RIO by  doxygen 1.6.3