/*
* 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:  Session handler.
*
*/



// INCLUDE FILES
#include    "CVtEngSessionHandler.h"
#include    "CVtEngOperation.h"
#include    "CVtEngStateManager.h"
#include 	"cvtengincomingcallmonitor.h"
#include    "vtengcommands.h"
#include    "CVtEngOperation.h"
#include    "CVtCtlFactory.h"
#include    "MVtCtlCallControl.h"
#include    "CVtEngSettings.h"
#include    "VtEngUtils.h"
#include    "VtCtlTypes.h" // for TVtCtlCSSessionInfoV1 
#include    "cvtlogger.h"

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

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::CVtEngSessionHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVtEngSessionHandler::CVtEngSessionHandler() 
    : CActive( CActive::EPriorityStandard ), iIncomingCallMonitor(NULL)
    {
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::ConstructL()
    {
    SetActive();
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, KErrNone );
    StartIncomingCallMonitorL();
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVtEngSessionHandler* CVtEngSessionHandler::NewL(  )
    {
    CVtEngSessionHandler* self = new( ELeave ) 
        CVtEngSessionHandler( );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

    
// -----------------------------------------------------------------------------
// CVtEngSessionHandler::~CVtEngSessionHandler
// Destructor
// 
// -----------------------------------------------------------------------------
//
CVtEngSessionHandler::~CVtEngSessionHandler()
    {
    __VTPRINTENTER( "SH.~" )
    Cancel();
    Uninitialize();
    delete iIncomingCallMonitor;
    __VTPRINTEXIT( "SH.~" )
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::HandleL
// Performs session request.
// 
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::HandleL( 
    CVtEngOperation& /*aOperation*/ )
    {
    __VTPRINT( DEBUG_SESSION, "SH.HandleL leave not supported" )
    User::Leave( KErrNotSupported );
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::State
// Returns session state
// 
// -----------------------------------------------------------------------------
//
MVtEngSessionInfo::TSessionState CVtEngSessionHandler::State( 
    TBool aForcedRefresh ) const
    {
    CVtEngStateManager* states = CVtEngUtility::StateManager();
    if ( aForcedRefresh )
        {
        states->Update();
        }
    return states->SessionState();
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::GetDirection
// Returns direction.
// 
// -----------------------------------------------------------------------------
//
TInt CVtEngSessionHandler::GetDirection( 
    TDirection& aDirection ) const
    {
    __VTPRINTENTER( "SH.GetDirection" )
    if ( !iSessionControl )
        {
        __VTPRINTEXITR( "SH.GetDirection err=%d", KErrNotFound )
        return KErrNotFound;
        }

    TVtCtlCSSessionInfoV1 info;
    TPckg<TVtCtlCSSessionInfoV1> pckg( info );
    TRAPD( err, iSessionControl->GetSessionInfoL( KActiveSessionId, pckg ) );
    if ( err == KErrNone )
        {
        switch ( info.iDirection )
            {
            case MVtCtlCallControl::EDirectionMobileOriginated:
                aDirection = EDirectionMO;
                break;
            case MVtCtlCallControl::DirectionMobileTerminated:
                aDirection = EDirectionMT;
                break;
            default:
                aDirection = EDirectionNone;
                break;
            }
        }
    __VTPRINT2( DEBUG_SESSION, "SH.direction dir=%d", aDirection )
    __VTPRINTEXITR( "SH.GetDirection err=%d", err )
    return err;
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::GetDuration
// Returns session duration.
// 
// -----------------------------------------------------------------------------
//
TInt CVtEngSessionHandler::GetDuration( 
    TDuration& aDuration,
    TBool& aEnabled ) const
    {
    if ( !iSessionControl )
        {
        return KErrNotFound;
        }

    TVtCtlDuration duration;
    TInt err ( iSessionControl->GetDuration( KActiveSessionId, duration ) );
    if ( err == KErrNone )
        {
        aDuration = duration;
        const CVtEngSettings& settings = CVtEngUtility::Settings();
        aEnabled = settings.Config().iCallTimerOn;
        }
    return err;
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::GetCLI
// 
// 
// -----------------------------------------------------------------------------
//
TInt CVtEngSessionHandler::GetCLI( TCLI& aCLI ) const
    {
    const CVtEngSettings& settings = CVtEngUtility::Settings();
    const TBool isValid = settings.GetCLI( aCLI);
    TInt res = KErrNone;
    if ( !isValid )
        {
        res = KErrNotReady;    
        }
    return res;
    }


// -----------------------------------------------------------------------------
// CVtEngSessionHandler::HandleVtSessionEventL
// 
// 
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::HandleVtSessionEventL( 
    TVtCtlEvent aEvent,
    TAny* /*aParams*/ )
    {
    if ( aEvent == KVtCtlEventSessionStatusChanged )
        {
        CVtEngStateManager* states = CVtEngUtility::StateManager();
        states->Update( );
        }
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::InitializeL
// 
// 
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::InitializeL()
    {
    __VTPRINTENTER( "SH.Initilialize" )
    if ( iSessionControl )
        {
        // already initialized
        __VTPRINTEXIT( "SH.Initilialize" )
        return;
        }
    TInt err = iLib.Load( KVtCtlLibraryName() );
    CleanupClosePushL( iLib );
    if ( err == KErrNone )
        {
        TLibraryFunction func = iLib.Lookup( 1 );
        iFactory = reinterpret_cast<CVtCtlFactory*>( func() );
        iSessionControl = iFactory->CreateCallControlL( *this );
        
        // Update state
        CVtEngStateManager* states = CVtEngUtility::StateManager();
        states->Update();
        }    
    CleanupStack::Pop(); // lib
    __VTPRINTEXIT( "SH.Initilialize" )
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::Uninitialize
// 
// 
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::Uninitialize()
    {
    if ( iFactory )
        {
        iFactory->Delete( iSessionControl );
        delete iFactory;
        iFactory = NULL;
        iSessionControl = NULL;
        }
    iLib.Close();
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::RealState
// 
// 
// -----------------------------------------------------------------------------
//
MVtCtlCallControl::TVtCtlState CVtEngSessionHandler::RealState() const
    {
    MVtCtlCallControl::TVtCtlState state( MVtCtlCallControl::EUnknown );
    if ( iSessionControl )
        {
        state = iSessionControl->GetSessionState( KActiveSessionId );
        __VTPRINT2( DEBUG_SESSION, "SH.realState=%d", state )
        }
    return state;
    }
// -----------------------------------------------------------------------------
// CVtEngSessionHandler::RunL
// 
// 
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::RunL()
    {
    InitializeL();
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::DoCancel
// 
// 
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::DoCancel()
    {
    // nothing here
    }

// -----------------------------------------------------------------------------
// CVtEngSessionHandler::StartIncomingCallMonitorL
// 
// 
// -----------------------------------------------------------------------------
//
void CVtEngSessionHandler::StartIncomingCallMonitorL()
    {
    iIncomingCallMonitor = CVtEngIncomingCallMonitor::NewL();
    }

//  End of File