hackedteam/core-symbian

#include "Network.h"

const TInt KTimeOut = 3*60*1000000;

// -----------------------------------------------------------------------------
// CNetwork* CNetwork::NewL(MNetworkObserver& aObserver)
// -----------------------------------------------------------------------------
//
CNetwork* CNetwork::NewL(RSocketServ& aSocketServ, RConnection& aConnection, MNetworkObserver& aObserver)
    {
    CNetwork* self = CNetwork::NewLC(aSocketServ, aConnection, aObserver);
    CleanupStack::Pop(); // self;
    return self;
    }

// -----------------------------------------------------------------------------
// CNetwork* CNetwork::NewLC(MNetworkObserver& aObserver)
// -----------------------------------------------------------------------------
//
CNetwork* CNetwork::NewLC(RSocketServ& aSocketServ, RConnection& aConnection, MNetworkObserver& aObserver)
    {
    CNetwork* self = new (ELeave) CNetwork(aSocketServ, aConnection, aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CNetwork::CNetwork()
// Constructor for performing 1st stage construction
// -----------------------------------------------------------------------------
//
CNetwork::CNetwork(RSocketServ& aSocketServ, RConnection& aConnection, MNetworkObserver& aObserver) :
    CActive(EPriorityStandard), iSocketServ(aSocketServ), iConnection(aConnection), iConnectionState(
            EConnectionStateDisconnected), iObserver(aObserver)
    {
    // No implementation required
    }

CNetwork::~CNetwork()
    {
    Cancel(); // Cancel any request, if outstanding 
    delete iTimer;
    iResolver.Close();
    iSocket.Close();
    delete iWriteBuffer;
    }

// -----------------------------------------------------------------------------
// void CNetwork::ConstructL()
// EPOC default constructor for performing 2nd stage construction
// -----------------------------------------------------------------------------
//
void CNetwork::ConstructL()
    {
    CActiveScheduler::Add(this);
    iTimer = CTimeOutTimer::NewL(*this);
    }


TBool CNetwork::SendInProgressL()
    {
    return (iConnectionState == EConnectionStateSending);
    }


// -----------------------------------------------------------------------------
// void CNetwork::RunL()
// Handle completion
// -----------------------------------------------------------------------------
//
void CNetwork::RunL()
    {
    // Cancel the timer
    iTimer->Cancel();
    
    TInt res = iStatus.Int();
    if (iStatus != KErrNone && iStatus != KErrEof)
        {
        HandleConnectionErrorL(res);
        return;
        }
    switch (iConnectionState)
        {
        case EConnectionStateDnsLookingUp:
            HandleDnsLookingUpCompleteL();
            break;
        case EConnectionStateConnecting:
            HandleConnectionCompleteL();
            break;
        case EConnectionStateReceiving:
            HandleDataReceivedL();
            break;
        case EConnectionStateSending:
            HandleSendingCompleteL();
            break;
        default:
            break;
        }
    }

// -----------------------------------------------------------------------------
// void CNetwork::DoCancel()
// Handle cancellation of outstanding request
// -----------------------------------------------------------------------------
//
void CNetwork::DoCancel()
    {
    iTimer->Cancel();
    
    switch (iConnectionState)
        {
        case EConnectionStateDnsLookingUp:
            iResolver.Cancel();
            break;
        case EConnectionStateConnecting:
            iSocket.CancelConnect();
            break;
        case EConnectionStateReceiving:
            iSocket.CancelRead();
            break;
        case EConnectionStateSending:
            iSocket.CancelWrite();
            break;
        default:
            break;
        }
    }

// -----------------------------------------------------------------------------
// void CNetwork::ConnectToServerL(const TDesC8& aUrl, TInt aPort)
// Connects to the service
// -----------------------------------------------------------------------------
//
void CNetwork::ConnectToServerL(const TDesC& aUrl, TInt aPort)
    {
    Cancel();
    iResolver.Close();
    iSocket.Close();

    iPort = aPort;

    TInetAddr netAddr;
    if (netAddr.Input(aUrl) == KErrNone)
        {
        ConnectL(netAddr.Address());
        return;
        }
    
    // Initiate DNS
    User::LeaveIfError(iResolver.Open(iSocketServ, KAfInet, KProtocolInetUdp, iConnection));
    iResolver.GetByName(aUrl, iNameEntry, iStatus);
    
    iConnectionState = EConnectionStateDnsLookingUp;
    SetActive();
    
    iTimer->After( KTimeOut );
    }

// -----------------------------------------------------------------------------
// void CNetwork::Disconnect()
// Disconnects the object from the network
// -----------------------------------------------------------------------------
//
void CNetwork::Disconnect()
    {
    Cancel();  // Cancel any request if outstanding

    if (iConnectionState >= EConnectionStateConnecting)
        {
        iSocket.Close();
        iResolver.Close();  // jo: close here, otherwise connection icon showing for too long 
        iConnectionState = EConnectionStateDisconnected;
        }
    }

// -----------------------------------------------------------------------------
// void CNetwork::SendL(const TDesC& aDataBuffer)
// Sends data through network
// -----------------------------------------------------------------------------
//
void CNetwork::SendL(const TDesC8& aDataBuffer)
    {
    if (iConnectionState == EConnectionStateDisconnected)
        {
        return;
        //User::Leave(KErrNotReady);
        }

    Cancel();

    delete iWriteBuffer;
    iWriteBuffer = NULL;
    iWriteBuffer = aDataBuffer.AllocL();
    iSocket.Write(*iWriteBuffer, iStatus);
    iConnectionState = EConnectionStateSending;
    SetActive();
    
    iTimer->After( KTimeOut );
    }

// -----------------------------------------------------------------------------
// CNetwork::ConnectL(TUint32 aAddr)
// Tries to connect object to the remote end
// -----------------------------------------------------------------------------
//
void CNetwork::ConnectL(TUint32 aAddr)
    {
    TInetAddr inetAddr;
    inetAddr.SetPort(iPort);
    inetAddr.SetAddress(aAddr);
    inetAddr.SetFamily(KAfInet);

    User::LeaveIfError(iSocket.Open(iSocketServ, KAfInet, KSockStream, KProtocolInetTcp, iConnection));

    iSocket.Connect(inetAddr, iStatus);
    iConnectionState = EConnectionStateConnecting;
    SetActive();
    
    iTimer->After( KTimeOut );
    }

// -----------------------------------------------------------------------------
// void CNetwork::DoReceiveL()
// Starts data receiving. Received data will be put in the object buffer
// -----------------------------------------------------------------------------
//
void CNetwork::DoReceiveL()
    {
    iReadBuffer.Zero();
    iSocket.RecvOneOrMore(iReadBuffer, 0, iStatus, iBytesRead);
    iConnectionState = EConnectionStateReceiving;
    SetActive();
    
    iTimer->After( KTimeOut );
    }

// -----------------------------------------------------------------------------
// void CNetwork::HandleDnsLookingUpCompleteL()
// Handle DNS looking up success completion
// -----------------------------------------------------------------------------
//
void CNetwork::HandleDnsLookingUpCompleteL()
    {
    iResolver.Close();

    TNameRecord nameRecord = iNameEntry();
    TInetAddr netAddr = TInetAddr::Cast(nameRecord.iAddr);
    // TBuf<15> ipAddr;
    // netAddr.Output(ipAddr);
    ConnectL( netAddr.Address() );
    }

// -----------------------------------------------------------------------------
// void CNetwork::HandleConnectionCompleteL()
// Handle connection to server success completion
// -----------------------------------------------------------------------------
//
void CNetwork::HandleConnectionCompleteL()
    {
    DoReceiveL();
    iObserver.NotifyConnectionCompleteL();
    }

/*
// -----------------------------------------------------------------------------
// void CNetwork::HandleDataReceivedL()
// Handle date received from server
// -----------------------------------------------------------------------------
//
void CNetwork::HandleDataReceivedL()
    {
    TInt error = iStatus.Int();
    HBufC8* recievedBuffer = iReadBuffer.AllocLC();
    DoReceiveL();
    iObserver.NotifyDataRecievedL(*recievedBuffer);
    CleanupStack::PopAndDestroy(recievedBuffer); 
    }
*/

// -----------------------------------------------------------------------------
// void CNetwork::HandleDataReceivedL()
// Handle date received from server
// -----------------------------------------------------------------------------
//
//Since the server closes the socket when response sending has finished, 
//we notify the observer sending an empty string
void CNetwork::HandleDataReceivedL()
    {
    TInt error = iStatus.Int();
    if(error==KErrNone)
        {
        HBufC8* receivedBuffer = iReadBuffer.AllocLC();
        DoReceiveL();
        iObserver.NotifyDataReceivedL(*receivedBuffer);
        CleanupStack::PopAndDestroy(receivedBuffer); 
        }
    else if(error == KErrEof)
        {
        iObserver.NotifyDataReceivedL(KNullDesC8);
        }
    }

// -----------------------------------------------------------------------------
// void CNetwork::HandleSendingCompleteL()
// Handle sending data success completion
// -----------------------------------------------------------------------------
//
void CNetwork::HandleSendingCompleteL()
    {
    TInt err = iStatus.Int();
    DoReceiveL();
    iObserver.NotifySendingCompleteL();
    }

// -----------------------------------------------------------------------------
// void CNetwork::HandleConnectionErrorL(TInt aError)
// Handle error happened during network operation
// -----------------------------------------------------------------------------
//
void CNetwork::HandleConnectionErrorL(TInt aError)
    {
    switch (iConnectionState)
        {
        case EConnectionStateDnsLookingUp:
            iResolver.Close();
            break;
        case EConnectionStateConnecting:
        case EConnectionStateReceiving:
        case EConnectionStateSending:
            iSocket.CancelAll();
            iSocket.Close();
            break;
        default:
            break;
        }

    iConnectionState = EConnectionStateDisconnected;
    iObserver.NotifyNetworkError(aError);
    }

/*
TBool CNetwork::KeyEventCaptured(TWsEvent aEvent){
    Disconnect();
    return ETrue;
}
*/

void CNetwork::TimerExpiredL(TAny* src)
    {
    Cancel();
    HandleConnectionErrorL(KErrTimedOut);
    }