/*

* Copyright (c) 2006 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:    Simple Engine

*

*/

// INCLUDE FILES

#include <e32std.h>

// own simple

#include "simplesipconnection.h"

#include "simplecommon.h"

#include "simpleenginerequest.h"

#include "msimpleconnectionobserver.h"

#include "simpleconnection.h"

#include "simpleengineutils.h"

#include "msimpleenginerequest.h"

#ifdef _DEBUG

#include "simpledebugutils.h"

#endif

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

//

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

// CSimpleConnection::CSimpleConnection

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

//

CSimpleConnection::CSimpleConnection( MSimpleConnectionObserver& aObserver )

: iState( EInactive ),

  iObserver( aObserver ),

  iOpId(0),

  iRequestList( CSimpleEngineRequest::LinkOffset())

    {

    }

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

// CSimpleConnection::~CSimpleConnection

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

//

CSimpleConnection::~CSimpleConnection()

    {

    delete iConnection;

    DeleteRequests();

    }

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

// CSimpleConnection::ConstructL

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

//

void CSimpleConnection::ConstructL( TInt32 aServiceId )

    {

    // Create CSimpleSipConnection entity in simplesiputils.dll

    iConnection = CSimpleSipConnection::NewL();

    // Set operation id ranges

    iLimitLowerValue = TSimpleEngineUtils::OpIdRange();

    iLimitUpperValue = iLimitLowerValue + KRangeSize;

    iOpId = iLimitLowerValue;

    // start to listen to status events

    IncreaseOpId();

    CSimpleEngineRequest* req = CSimpleEngineRequest::NewL(

        *this, MSimpleEngineRequest::EListenEvents, iOpId );

    CleanupStack::PushL( req );

    if ( aServiceId )

        {

        iConnection->SetServiceId( aServiceId );

        }

    iConnection->DispatchReqL( *req );

    iRequestList.AddLast( *req );

    CleanupStack::Pop( req );

    }

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

// CSimpleConnection::NewL

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

//

CSimpleConnection* CSimpleConnection::NewL(

    MSimpleConnectionObserver& aObserver )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: NewL" ));

#endif

    CSimpleConnection* self = new (ELeave) CSimpleConnection( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( NULL );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimpleConnection::NewL

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

//

CSimpleConnection* CSimpleConnection::NewL(

    MSimpleConnectionObserver& aObserver, TInt32 aServiceId )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: NewL" ));

#endif

    CSimpleConnection* self = new (ELeave) CSimpleConnection( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aServiceId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimpleConnection::Connection

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

//

CSimpleSipConnection* CSimpleConnection::Connection()

    {

    return iConnection;

    }

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

// CSimpleConnection::Close

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

//

void CSimpleConnection::Close( )

    {

    delete this;

    }

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

// CSimpleConnection::LoginL

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

//

TInt CSimpleConnection::LoginL(  )

    {

    return LoginL( 0 );

    }

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

// CSimpleConnection::LoginL

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

//

TInt CSimpleConnection::LoginL( TInt aId  )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: LoginL aId=%d" ), aId);

#endif

    // check state

    if ( iState != EInactive )

        {

        User::Leave(KErrNotReady);

        }

    IncreaseOpId();

    CSimpleEngineRequest* req = CSimpleEngineRequest::NewL(

        *this, MSimpleEngineRequest::ERegister, iOpId );

    req->SetAux( aId );

    CleanupStack::PushL( req );

    iConnection->DispatchReqL( *req );

    iRequestList.AddLast( *req );

    CleanupStack::Pop( req );

    SetConnectionStatus( EIdle );

    return iOpId;

    }

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

// CSimpleConnection::ConnectionStatus

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

//

MSimpleConnection::TSimpleState CSimpleConnection::ConnectionStatus()

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: ConnectionStatus returns %d" ), iState);

#endif

    return iState;

    }

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

// CSimpleConnection::CurrentSIPIdentityL

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

//    

TPtrC8 CSimpleConnection::CurrentSIPIdentityL()

    {

    return iConnection->CurrentSIPIdentityL();    

    }

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

// CSimpleConnection::Complete

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

//

void CSimpleConnection::Complete(

    TInt aOpId, TInt aStatus, MSimpleEngineRequest& aReq )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: Complete opid=%d status=%d" ),

        aOpId, aStatus );

#endif

    // check the SIP state from another DLL

    TSimpleSipState st = iConnection->SIPState();

    MSimpleConnection::TSimpleState oldState = ConnectionStatus();

    MSimpleConnection::TSimpleState newState = ConvertState( st );

    SetConnectionStatus( newState );

    if ( aReq.RequestType() != MSimpleEngineRequest::EListenEvents )

        {

        // delete corresponding request from another DLL too.

        aReq.ModifyType( MSimpleEngineRequest::EDestroy );

        TRAP_IGNORE( iConnection->DispatchReqL( aReq ));

        // delete request from this DLL.

        aReq.Destroy();

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: call  RequestCompleteL opid=%d status=%d" ),

        aOpId, aStatus );

#endif

        TRAP_IGNORE( iObserver.RequestCompleteL( aOpId, aStatus ) );

        }

    else

        {

        // This is status event

        if ( oldState != newState )

            {

#ifdef _DEBUG

            TSimpleLogger::Log(_L("SimpleConnection: call ConnectionStatusL state=%d" ),

            newState );

#endif

            TRAP_IGNORE( iObserver.ConnectionStatusL( newState ) );

            }

        }

    }

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

// CSimpleConnection::DeleteRequests

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

void CSimpleConnection::DeleteRequests()

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: DeleteRequests" ));

#endif

    // Delete all buffered transaction requests

    TDblQueIter<CSimpleEngineRequest> rIter( iRequestList );

    rIter.SetToFirst();

    while ( rIter )

        {

        CSimpleEngineRequest* req = rIter;

        rIter++; //lint !e1757

        req->Destroy();

        }

    }

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

// CSimpleConnection::IncreaseOpId

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

void CSimpleConnection::IncreaseOpId( )

    {

    iOpId++;

    if( iOpId >= iLimitUpperValue )

        {

        iOpId = iLimitLowerValue;

        }

    }

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

// CSimpleConnection::ConvertState

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

MSimpleConnection::TSimpleState CSimpleConnection::ConvertState( TSimpleSipState aState )

    {

    switch( aState )

        {

        case ESimpleSipIdle:

            return MSimpleConnection::EIdle;

        case ESimpleSipActive:

            return MSimpleConnection::EActive;

        case ESimpleSipSuspend:

            return ESuspend;

        case ESimpleSipInactive:

            return EInactive;

        case ESimpleSipUnavailable:

        default:

            return EUnavailable;

        }; //lint !e960

    }

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

// CSimpleConnection::SetConnectionStatus

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

void CSimpleConnection::SetConnectionStatus( TSimpleState aState )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SimpleConnection: SetConnectionStatus %d" ), aState );

#endif

    iState = aState;

    }