/*

* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Class for Data send and recevive.

*

*

*/

// INCLUDE FILES

#include    <apparc.h>

#include    <bautils.h>

#include    "impssendreceive.h"

#include    "Impsutils.h"

#include    "impserrors.h"

#include    "impstimer.h"

#include    "impsactiveconnmonitor.h"

#include    "Impsdatautils.h"

// MACROS

#ifndef _DEBUG

#define _NO_IMPS_LOGGING_

#endif

#ifdef LOCAL_IMPS

#ifndef _FAKE_RESPONSE

#define _FAKE_RESPONSE

#endif

#endif

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CImpsSendReceive2::CImpsSendReceive2(

    RFs& aFs,

    MImpsCSPSession& aServer,

    CBufFlat& aOutputBuffer )

        : iServer( aServer ),

        iOutputBuffer( aOutputBuffer ),

        iOpenId( 0 ),

        iFs( aFs ),

        iSender( NULL ),

        iRequList( _FOFF( CTrReq, iLink ) ),  //lint !e413

        iConnMan( NULL ),

        iSAP ( NULL ),

        iTrState( EImpsTrInit )

    {

    }

// default constructor can leave.

void CImpsSendReceive2::ConstructL( TDesC8& aMimeType )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: rel200541.3+" ) );

#endif

    iMimeType = aMimeType;

    iConnMan = CImpsConnManager::NewL( *this, CActive::EPriorityUserInput + 1 );

    MMsgConnManager& man = iConnMan->ManagerHandleL();

    iSender = NewImpsSenderL( *this, man, aMimeType );

    }

// Two-phased constructor.

CImpsSendReceive2* CImpsSendReceive2::NewL(

    RFs&  aFs,

    MImpsCSPSession& aServer,

    CBufFlat& aOutputBuffer,

    TDesC8& aMimeType )

    {

    CImpsSendReceive2* self = new ( ELeave ) CImpsSendReceive2(

        aFs,

        aServer,

        aOutputBuffer );

    CleanupStack::PushL( self );

    self->ConstructL( aMimeType );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CImpsSendReceive2::~CImpsSendReceive2()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: destructor begins" ) );

#endif

    delete iConnMan;

    delete iSAP;

    if ( iSender )

        {

        // In error case this may be null

        iSender->Destroy();

        }

    DeleteAllIds();

    // delete iObserver;

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: destructor ends" ) );

#endif

    }

// ---------------------------------------------------------

// CImpsSendReceive2::CloseTr

// ---------------------------------------------------------

//

void CImpsSendReceive2::CloseTr( )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: CloseTr" ) );

#endif

    DeleteAllIds();

    if ( iTrState == EImpsTrClosing )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: CloseTr IGNORED ***" ) );

#endif

        return;

        }

    // cancel open AP

    if ( iTrState == EImpsTrAPOpening )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: CANCEL open ***" ) );

#endif

        NewTrState( EImpsTrClosing );

        iConnMan->CloseAP( ETrue );

        return;

        }

    if ( iSender )

        {

        // In error cases iSender may be null

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: CloseTr CLOSE DATA CHANNEL" ) );

#endif

        iSender->Close( );

        iSender->Destroy();

        iSender = NULL;

        NewTrState( EImpsTrAPOpen );

        }

    else if ( iTrState == EImpsTrCloseDelayed )

        {

        NewTrState( EImpsTrAPOpen );

        }

    if ( iTrState == EImpsTrAPOpen )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: CloseTr START TO CLOSE AP" ) );

#endif

        // This causes APStatusEvent call finally.

        NewTrState( EImpsTrClosing );

        iConnMan->CloseAP( ETrue );

        }

    // This is needed in CImpsServer so that transient server can be closed

    else if ( iTrState == EImpsTrInit )

        {

        iServer.TransportStatus( EInternal_NO_IAP );

        }

    }

// ---------------------------------------------------------

// CImpsSendReceive2::Close2

// Delayed close operation

// ---------------------------------------------------------

//

TInt CImpsSendReceive2::Close2( )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: Close2" ) );

#endif

    __ASSERT_DEBUG( iConnMan,

                    User::Panic( KImpsPanicCategory, EImpsCorrupted ) );

    TInt ret = KErrNone;

    if ( iTrState == EImpsTrAPOpening )

        {

        CloseTr();

        return ret;

        }

    else if ( iTrState == EImpsTrClosing || iTrState == EImpsTrCloseDelayed )

        {

        // There is pending close request that will call callback sooner or later.

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: Close2 ignored ***" ) );

#endif

        return ret;

        }

    else if ( iTrState == EImpsTrInit )

        {

        // Nothing to do, callback will not be called.

        // This error must be handled in calling method.

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: iTrState was EImpsTrInit ***" ) );

#endif

        return KErrCancel;

        }

    DeleteAllIds();

    if ( iSender )

        {

        // In error cases iSender may be null

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: Close2 CLOSE DATA CHANNEL" ) );

#endif

        iSender->Close( );

        iSender->Destroy();

        iSender = NULL;

        NewTrState( EImpsTrAPOpen );

        }

    // yield control for scheduler before close takes place

    iConnMan->StartDelayed( );

    NewTrState( EImpsTrCloseDelayed );

    return ret;

    }

// ---------------------------------------------------------

// CImpsSendReceive2::IsConnected

// ---------------------------------------------------------

//

TBool CImpsSendReceive2::isConnected( )

    {

    TBool ret( EFalse );

    TRAPD( errx, ( ret = DoIsConnectedL() ) );

    if ( errx || !ret )

        {

        return EFalse;

        }

    if ( iSender && iTrState == EImpsTrDataOpen )

        {

        return ETrue;

        }

    return EFalse;

    }

// ---------------------------------------------------------

// CImpsSendReceive2::DoIsConnectedL

// ---------------------------------------------------------

//

TBool CImpsSendReceive2::DoIsConnectedL( )

    {

    MMsgConnManager& man = iConnMan->ManagerHandleL();

    if ( !man.Status() )

        {

        return EFalse;

        }

    return ETrue;

    }

// ---------------------------------------------------------

// CImpsSendReceive2::OpenL

// ---------------------------------------------------------

//

void CImpsSendReceive2::OpenL(

    const TDesC& aTID,

    TInt aXmlLog,

    const TDesC& aSAP,

    TInt  aIAP,

    TBool aDelayed )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: OpenL Begins iTrState=%d" ), iTrState );

#endif

    delete iSAP;

    iSAP = NULL;

    iSAP = aSAP.AllocL();

    iIAP = aIAP;

    DeleteId( iOpenId );

    iOpenId = 0;

    iOpenId = AddIdL( aTID ); // saved so that it can be deleted later

    iXmlLog = aXmlLog;

    if ( iTrState == EImpsTrClosing || iTrState == EImpsTrCloseDelayed ||

         iTrState == EImpsTrClosingPDP )

        {

        // just parameters saved

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: Leaves(KErrNotReady) ***" ) );

#endif

        DeleteId( iOpenId );

        iOpenId = 0;

        User::Leave( KErrNotReady );

        }

    OpenL( aTID, aDelayed );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: OpenL ends" ) );

#endif

    }

// ---------------------------------------------------------

// CImpsSendReceive2::OpenL

// ---------------------------------------------------------

//

void CImpsSendReceive2::OpenL( const TDesC& aTID, TBool aDelayed )

    {

    // Prevent opening twice data channel or connection

    if ( iTrState == EImpsTrAPOpening )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: Leaves(KErrNotReady) ****" ) );

#endif

        User::Leave( KErrNotReady );

        }

    // Handle NULL TID so that Login primitive is not sent later,

    // only channels are opened when recovering from flight mode.

    // The old state is ignored, because of

    // this should be called after NO_IAP only.

    if ( aTID.Length() == 0 )

        {

        iOpenId = 0;

        }

    if ( iSender && iTrState == EImpsTrDataOpen )

        {

        iSender->CancelAll();

        iSender->Destroy();

        iSender = NULL;

        NewTrState( EImpsTrAPOpen );

        }

    if ( iTrState == EImpsTrAPOpen )

        {

        NewTrState( EImpsTrClosing );

        iConnMan->CloseAP( ETrue );

        }

    else if ( iTrState == EImpsTrInit )

        {

        Open2L( iIAP, aDelayed );

        }

    }

// ---------------------------------------------------------

// CImpsSendReceive2::Open2L

// ---------------------------------------------------------

//

void CImpsSendReceive2::Open2L( TInt aIAP, TBool aDelayed )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: Open2L Begins aIAP=%d" ), aIAP );

#endif

    __ASSERT_DEBUG( iConnMan,

                    User::Panic( KImpsPanicCategory, EImpsCorrupted ) );

    iConnMan->OpenAPL( aIAP, aDelayed );

    NewTrState( EImpsTrAPOpening );

    }

// ---------------------------------------------------------

// CImpsSendReceive2::ClosePDP

// ---------------------------------------------------------

//

void CImpsSendReceive2::ClosePDP()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: ClosePDP iTrState=%d" ), iTrState );

#endif

    if ( iTrState == EImpsTrInit )

        {

        iServer.TransportStatus( EInternal_NO_IAP );

        }

    if ( iTrState != EImpsTrDataOpen )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: ClosePDP error ***" ) );

#endif

        return;

        }

    DeleteAllIds();

    if ( iSender )

        {

        // In error cases iSender may be null

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: ClosePDP CLOSE DATA CHANNEL" ) );

#endif

        iSender->Close( );

        iSender->Destroy();

        iSender = NULL;

        }

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: ClosePDP START TO CLOSE AP" ) );

#endif

    // This causes APStatusEvent call finally.

    NewTrState( EImpsTrClosingPDP );

    iConnMan->CloseAP( EFalse );

    }

// ---------------------------------------------------------

//CImpsSendReceive2::OpenPDPL

// ---------------------------------------------------------

//

void CImpsSendReceive2::OpenPDPL(

    const TDesC& aSAP,

    TInt  aIAP )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: OpenPDPL iTrState=%d" ), iTrState );

#endif

    __ASSERT_DEBUG( iConnMan,

                    User::Panic( KImpsPanicCategory, EImpsCorrupted ) );

    // Prevent opening twice data channel or connection

    if ( iTrState == EImpsTrAPOpening )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: OpenPDPL Leaves(corrupted) ***" ) );

#endif

        User::Leave( EImpsCorrupted );

        }

    delete iSAP;

    iSAP = NULL;

    iSAP = aSAP.AllocL();

    iIAP = aIAP;

    if ( iTrState == EImpsTrClosedPDP || iTrState == EImpsTrInit )

        {

        iConnMan->OpenAPL( aIAP, EFalse );

        NewTrState( EImpsTrOpeningPDP );

        }

    else

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: OpenPDPL Leaves(corrupted) ****" ) );

#endif

        User::Leave( EImpsCorrupted );

        }

    }

// ---------------------------------------------------------

// CImpsSendReceive2::Cancel

// ---------------------------------------------------------

//

void CImpsSendReceive2::Cancel()

    {

    if ( iSender )

        {

        iSender->CancelAll();

        }

    }

// ---------------------------------------------------------

// CImpsSendReceive2::SendAndWaitL

// ---------------------------------------------------------

//

void CImpsSendReceive2::SendAndWaitL(

    const TDesC& aTID,

    TInt aExpiryTime )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendReceive2: SendAndWait begins %d" ), iTrState );

#endif

    if ( !iSender || iTrState != EImpsTrDataOpen )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SendReceive2: SendAndWaitL Leaves(KErrNotReady) ****" ) );

#endif

        User::Leave( KErrNotReady );

        }

    // XML log ***************************************************************

#ifdef _DEBUG

    if ( iXmlLog&0x1 )

        {

        if ( iXmlLog&0x2 || aTID.Length() > 0 ) // This works with WBXML too

            {

            TFileName fileName = _L( "c:\\logs\\impss\\" );

            if ( BaflUtils::PathExists( iFs, fileName ) )

                {

                _LIT( KRelated, "Sent.xml" );

                iParse.Set( fileName, &KRelated, NULL );

                fileName = iParse.FullName();

                TRAPD( errxy, CApaApplication::GenerateFileName( iFs, fileName ) );

                if ( errxy )

                    {

#ifndef _NO_IMPS_LOGGING_

                    CImpsClientLogger::Log( _L( "SendReceive2: SendAndWaitL Leaves(%d) ****" ), errxy );

#endif

                    User::Leave( errxy );

                    }

                RFile file;

                TInt xmlError = file.Create( iFs, fileName, EFileWrite | EFileShareExclusive );

                if ( xmlError == KErrNone )

                    {