chatinet.cpp

一个聊天的软件

/*
* ==============================================================================
*  Name        : ChatInet.cpp
*  Part of     : Chat
*  Interface   : 
*  Description : 
*  Version     : 
*
*  Copyright (c) 2005-2006 Nokia Corporation.
*  This material, including documentation and any related 
*  computer programs, is protected by copyright controlled by 
*  Nokia Corporation.
* ==============================================================================
*/

// INCLUDE FILES
#include <StringLoader.h>
#include <ChatEx.rsg>
#include <coemain.h>

#include "ChatInet.h"
#include "Chat.pan"
#include "Log.h"
#include "es_enum.h"

// ============================ MEMBER FUNCTIONS ==============================

// ----------------------------------------------------------------------------
// CChatInet::NewL()
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CChatInet* CChatInet::NewL( MLog& aLog )
    {
    CChatInet* self = NewLC( aLog );
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CChatInet::NewLC()
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CChatInet* CChatInet::NewLC( MLog& aLog )
    {
    CChatInet* self = new ( ELeave ) CChatInet( aLog );
    CleanupStack::PushL( self );
    self->ConstructL ();
    return self;

    }

// ----------------------------------------------------------------------------
// CChatInet::CChatInet()
// Constructor.
// ----------------------------------------------------------------------------
//
CChatInet::CChatInet( MLog& aLog ) : 
    CChatBase( aLog ),
    iLog( aLog ),
    iPort( KDefaultPortNumber )
    {
    SetState( EDisconnected );
    }

// ----------------------------------------------------------------------------
// CChatInet::~CChatInet()
// Destructor.
// ----------------------------------------------------------------------------
//
CChatInet::~CChatInet()
    {
    // Close() will wait forever for Read to complete
    if ( State() == EConnected )
        {
        if ( iActiveSocket )
            {
            iActiveSocket->CancelRead();
            }
        }
    Cancel();
    iAcceptedSocket.Close();
    iSocket.Close();
    iSocketServer.Close();

    delete iMessage;
    iMessage = NULL;
    }

// ----------------------------------------------------------------------------
// CChatInet::ConstructL()
// Perform second phase construction of this object.
// ----------------------------------------------------------------------------
//
void CChatInet::ConstructL()
    {
    User::LeaveIfError( iSocketServer.Connect() );
    }

// ----------------------------------------------------------------------------
// CChatInet::DoCancel()
// Cancel any outstanding requests.
// ----------------------------------------------------------------------------
//
void CChatInet::DoCancel()
    {
    if ( State() == EConnected )
        {
        if ( iActiveSocket )
            {
            iActiveSocket->CancelRead();
            }
        }
        SetState( EDisconnected );
    }

// ----------------------------------------------------------------------------
// CChatInet::RunL()
// Respond to an event.
// ----------------------------------------------------------------------------
//
void CChatInet::RunL()
    {
    HBufC* textResource = NULL;
    TBuf<KMaxMarkLen> mark;
  
    if ( ( iStatus == KErrDisconnected ) || ( iStatus == KErrEof ) )
        {
        // Disconnected so go back to listening
        HBufC* strDisconnected = StringLoader
            ::LoadLC ( R_CHAT_STR_DISCONNECTED );
        iLog.LogL( *strDisconnected );
        CleanupStack::PopAndDestroy( strDisconnected );
        Stop();
        return;
        }
    else if ( iStatus == KErrAbort )
        {
        HBufC* strDisconnected = StringLoader
            ::LoadLC ( R_CHAT_STR_DISCONNECTED );
        iLog.LogL( *strDisconnected );
        CleanupStack::PopAndDestroy( strDisconnected );
        Stop();
        return;
        }
        
    else if ( iStatus != KErrNone )
        {
        switch ( State() )
            {
            case EGettingConnection:
                textResource = StringLoader
                    ::LoadLC( R_CHAT_ERR_CONNECTION_ERROR );
                iLog.LogL( *textResource, iStatus.Int() );
                DisconnectFromServerL();
                CleanupStack::PopAndDestroy( textResource );
                SetState( EDisconnecting );
                break;
              
            case EConnected:
                textResource = StringLoader
                    ::LoadLC( R_CHAT_ERR_LOST_CONNECTION );
                iLog.LogL( *textResource, iStatus.Int() );
                DisconnectFromServerL();
                CleanupStack::PopAndDestroy( textResource );
                SetState( EDisconnecting );
                break;
                
            case ESendingMessage:
                textResource = StringLoader
                    ::LoadLC( R_CHAT_ERR_MESSAGE_FAILED );
                iLog.LogL( *textResource, iStatus.Int() );
                CleanupStack::PopAndDestroy( textResource );
                DisconnectFromServerL();
                SetState( EDisconnecting );
                break;
                
            case EDisconnecting:
                if ( iStatus == KErrDisconnected )
                    {
                    textResource = StringLoader
                        ::LoadLC( R_CHAT_DISCONNECT_COMPLETE );
                    iLog.LogL( *textResource, iStatus.Int() );
                    CleanupStack::PopAndDestroy( textResource );
                    Stop();
                    SetState( EDisconnected );
                    }
                else
                    {
                    textResource = StringLoader
                        ::LoadLC( R_CHAT_ERR_FAILED_TO_DISCONNECT );
                    iLog.LogL( *textResource, iStatus.Int() );
                    CleanupStack::PopAndDestroy( textResource );
                    }
                    break;
                    
            case EDisconnected:
                    textResource = StringLoader
                        ::LoadLC( R_CHAT_DISCONNECT_COMPLETE );
                    iLog.LogL( *textResource, iStatus.Int() );
                    CleanupStack::PopAndDestroy( textResource );
                break;
                        
            default:
                break;
            }
        }
    else 
        {
        switch ( State() )
            {
   
            case EGettingConnection:
                textResource = StringLoader
                    ::LoadLC( R_CHAT_CONNECTED );
                iLog.LogL( *textResource );
                CleanupStack::PopAndDestroy( textResource );

                SetState( EConnected );
                RequestData();
                break;
              
            case EConnected:
              
              mark.Append( '>' );
                textResource = HBufC::NewLC( iBuffer.Length() );
              textResource->Des().Copy( iBuffer );
              iLog.LogL( *textResource, mark );
              iBuffer.Zero();
              CleanupStack::PopAndDestroy( textResource );
                RequestData();
                break;
                
            case ESendingMessage:
                SetState( EConnected );
                RequestData();
                break;
                
            case EDisconnecting:
                textResource = StringLoader
                    ::LoadLC( R_CHAT_DISCONNECT_COMPLETE );
                iLog.LogL( *textResource );
                CleanupStack::PopAndDestroy ( textResource );

                Stop();
                SetState( EDisconnected );
                break;
            
            case EDisconnected:
                break;
                
            default:
                Panic( EChatInvalidLogicState );
                break;
            };
        }
    }

// ----------------------------------------------------------------------------
// CChatInet::ConnectL()
// Connect to a service.
// ----------------------------------------------------------------------------
//
void CChatInet::ConnectL( const TDesC& aAddress )
    {
    if ( State() == EDisconnected && !IsActive() )
        {
        SetState( EGettingConnection );
        ConnectToServerL( aAddress );
        }
    else
        {
        HBufC* errClientBusy = StringLoader::LoadLC ( R_CHAT_CLIENT_BUSY );
        iLog.LogL( *errClientBusy );
        CleanupStack::PopAndDestroy( errClientBusy );

        User::Leave( KErrInUse );
        }
    }