/*

* Copyright (c) 2007 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:  CVtCtlCallControl class implementation.

*

*/

#pragma CTC SKIP

// INCLUDE FILES

#include <cvtlogger.h>

#include    "CVtCtlCallControl.h"

#include    "MVtCtlEventObserver.h"

#include    "CVtCtlSessionContainer.h"

#include    "CVtCtlVideoCall.h"

#include    "VtCtlTypes.h"

#include    <cvtlogger.h>

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

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

// CVtCtlCallControl::NewL

// two-phase constructor

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

//

CVtCtlCallControl* CVtCtlCallControl::NewL(

            MVtCtlEventObserver& aEventObserver )

    {

    __VTPRINTENTER( "CVtCtlCallControl.NewL" )

    CVtCtlCallControl* self = new ( ELeave )

        CVtCtlCallControl( aEventObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    __VTPRINTEXIT( "CVtCtlCallControl.NewL" )

    return self;

    }

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

// CVtCtlCallControl::~CVtCtlCallControl

// Destructor

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

//

CVtCtlCallControl::~CVtCtlCallControl()

    {

    __VTPRINTENTER( "CVtCtlCallControl.~" )

    delete iContainer;

    // uninitialize logging (if enabled)

    VTLOGUNINIT

    __VTPRINTEXIT( "CVtCtlCallControl.~" )

    }

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

// CVtCtlCallControl::CVtCtlCallControl

// c++ constructor

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

//

CVtCtlCallControl::CVtCtlCallControl(

    MVtCtlEventObserver& aEventObserver ) :

    iEventObserver( aEventObserver )

    {

    __VTPRINTENTER( "CVtCtlCallControl.CVtCtlCallControl" )

    __VTPRINTEXIT( "CVtCtlCallControl.CVtCtlCallControl" )

    }

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

// CVtCtlCallControl::ConstructL

// 

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

//

void CVtCtlCallControl::ConstructL()

    {

    __VTPRINTENTER( "CVtCtlCallControl.ConstructL" )

    // initialize logging (if enabled)

    VTLOGINIT

    iContainer = CVtCtlSessionContainer::NewL( *this );

    __VTPRINTEXIT( "CVtCtlCallControl.ConstructL" )

    }

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

// CVtCtlCallControl::GetDuration

// 

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

//

TInt CVtCtlCallControl::GetDuration(

    TVtCtlSessionId aId,

    TVtCtlDuration& aDuration )     

    {

    __VTPRINTENTER( "CVtCtlCallControl.GetDuration" )

    CVtCtlVideoCall* call = iContainer->FindCall( aId );

    TInt err( KErrNotFound );

    if ( call )

        {

        err = call->GetDuration( aDuration );

        }

    __VTPRINTEXIT( "CVtCtlCallControl.GetDuration" )

    return err;

    }

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

// CVtCtlCallControl::GetSessionInfoL

// 

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

//

/*****************************************************

*   Series 60 Customer / ETel

*   Series 60  ETel API

*****************************************************/

void CVtCtlCallControl::GetSessionInfoL( 

    TVtCtlSessionId aId,

    TDes8& aInfo )

    {

    __VTPRINTENTER( "CVtCtlCallControl.GetSessionInfoL" )

    ValidateDataExtensionL( aInfo, EVtCtlCSSessionInfoExtensionId );

    CVtCtlVideoCall* call = iContainer->FindCall( aId );

    if ( call )

        {

        TPckg<TVtCtlCSSessionInfoV1>& pckg = 

            reinterpret_cast<TPckg<TVtCtlCSSessionInfoV1>&>( aInfo );

        TVtCtlCSSessionInfoV1& info = pckg();

        TInt err( call->UpdateCallInfo() );

        if ( err == KErrNone )

            {

            const RMobileCall::TMobileCallInfoV1& mobileInfo = call->MobileInfo();

            info.iDuration = mobileInfo.iDuration;

            info.iTelNumber = mobileInfo.iRemoteParty.iRemoteNumber.iTelNumber;

            __VTPRINT2( DEBUG_SESSION, "VtCtl: mobile dir=%d", 

                mobileInfo.iRemoteParty.iDirection  )

            switch ( mobileInfo.iRemoteParty.iDirection )

                {

                case RMobileCall::EMobileOriginated:

                    info.iDirection = EDirectionMobileOriginated;

                    break;

                case RMobileCall::EMobileTerminated:

                    info.iDirection = DirectionMobileTerminated;

                    break;

                case RMobileCall::EDirectionUnknown:

                default:

                    info.iDirection = EDirectionUnknown;

                    break;

                }

            }

        }

    else

        {

        __VTPRINT( DEBUG_SESSION, "CallCtrl.GetSessionInfoL not found" )

        User::Leave( KErrNotFound );

        }

    __VTPRINTEXIT( "CVtCtlCallControl.GetSessionInfoL" )

    }

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

// CVtCtlCallControl::GetState

// 

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

//

MVtCtlCallControl::TVtCtlState CVtCtlCallControl::GetSessionState( 

    TVtCtlSessionId aId ) const

    {

    __VTPRINTENTER( "CVtCtlCallControl.GetSessionState" )

    __VTPRINT2( DEBUG_SESSION, "CallCtrl.GetSessionState for id:%d",aId )

    MVtCtlCallControl::TVtCtlState state = EUnknown;

    CVtCtlVideoCall* call = iContainer->FindCall( aId );

    if ( call )

        {

        call->GetCallState( state );

        }

    __VTPRINT3( DEBUG_SESSION, " callPtr=%d state=%d", (TInt) call, state )

    __VTPRINTEXIT( "CVtCtlCallControl.GetSessionState" )

    return state;

    }

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

// CVtCtlCallControl::GetPreviousState

// 

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

//

MVtCtlCallControl::TVtCtlState CVtCtlCallControl::GetPreviousPreviousState(

    TVtCtlSessionId aId ) const

    {

    __VTPRINTENTER( "CVtCtlCallControl.GetPreviousPreviousState" )

    MVtCtlCallControl::TVtCtlState state = EUnknown;

    const CVtCtlVideoCall* call = iContainer->FindCall( aId );

    if ( call )

        {

        state = call->CallInfo().iPreviousStatus;

        }

    __VTPRINTEXIT( "CVtCtlCallControl.GetPreviousPreviousState" )

    return state;

    }

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

// CVtCtlCallControl::HandleCallStatusChangeL

// Notifies observer about call status change.

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

//

void CVtCtlCallControl::HandleCallStatusChangeL(

    TVtCtlSessionId aId,

    MVtCtlCallControl::TVtCtlState aStatus,

    MVtCtlCallControl::TVtCtlState aPreviousStatus )

    {

    __VTPRINTENTER( "CVtCtlCallControl.HandleCallStatusChangeL" )

    __VTPRINT2( DEBUG_SESSION, " status=%d", (TInt) aStatus )

    TVtCtlSessionStateEvent event;

    event.iPreviousState = aPreviousStatus;

    event.iState = aStatus;

    event.iSessionId = aId;

    TAny* parameter = &event;

    iEventObserver.HandleVtSessionEventL(

        KVtCtlEventSessionStatusChanged,

        parameter );

    __VTPRINTEXIT( "CVtCtlCallControl.HandleCallStatusChangeL" )

    }

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

// CVtCtlCallControl::ValidateDataExtensionL

// Validates extension id of descriptor representation of data type.

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

//

void CVtCtlCallControl::ValidateDataExtensionL(

    TDesC8& aData,

    TInt aExtension )

    {

    __VTPRINTENTER( "CVtCtlCallControl.ValidateDataExtensionL" )

    TVtCtlType type;

    TPckg<TVtCtlType> pckg(type);

    TPtrC8 ptr( aData.Ptr(), sizeof( TVtCtlType ) );

    pckg.Copy( ptr );

    if ( type.Extension() != aExtension )

        {

        __VTPRINT( DEBUG_SESSION, "CallCtrl.Validate not supported" )

        User::Leave( KErrNotSupported );

        }

    __VTPRINTEXIT( "CVtCtlCallControl.ValidateDataExtensionL" )

    }

#pragma CTC ENDSKIP

//  End of File