/*
* Copyright (c) 2004 - 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:  Container for ETel session and subsessions.
*
*/


#pragma CTC SKIP
// INCLUDE FILES
#include    "CVtCtlSessionContainer.h"
#include    "CVtCtlLineMonitor.h"
#include    "CVtCtlVideoCall.h"
#include    <mmtsy_names.h>
#include    <cvtlogger.h>

// CONSTANTS

// Retrials for connecting to ETel server
const TInt KVtCtlETelConnectRetrials = 5;

// Granularity
const TInt KVtCtlMaxCalls = 5;

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

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::CVtCtlSessionContainer
// C++ constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVtCtlSessionContainer::CVtCtlSessionContainer(
    MVtCtlCallStatusObserver& aObserver ) :
    iCalls( KVtCtlMaxCalls ), 
    iObserver( aObserver )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.CVtCtlSessionContainer" )
    __VTPRINTEXIT( "CVtCtlSessionContainer.CVtCtlSessionContainer" )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
/*****************************************************
*   Series 60 Customer / ETel
*   Series 60  ETel API
*****************************************************/
void CVtCtlSessionContainer::ConstructL()
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.ConstructL" )
    TInt retries( KVtCtlETelConnectRetrials );
    TInt err( KErrNone );
    while ( retries-- && 
            iServer.Handle() == KNullHandle )
        {
        err = iServer.Connect();        
        }
    User::LeaveIfError( err );
    User::LeaveIfError( iServer.LoadPhoneModule( KMmTsyModuleName() ) );
    User::LeaveIfError( iPhone.Open( iServer, KMmTsyPhoneName() ) );
    User::LeaveIfError( iLine.Open( iPhone, KMmTsyDataLineName() ) );

    iLineMonitor = new ( ELeave ) CVtCtlLineMonitor( iLine, *this );
    iLineMonitor->Start();

    RMobileCall::TMobileCallStatus lineStatus;
    User::LeaveIfError( iLine.GetMobileLineStatus( lineStatus ) );
    if ( lineStatus != RMobileCall::EStatusIdle )
        {
        __VTPRINT( DEBUG_SESSION | DEBUG_CONSTRUCT, 
            "VtCtl:SesConL line active" )
        TInt calls( 0 );
        User::LeaveIfError( iLine.EnumerateCall( calls ) );
        while ( calls-- )
            {
            RLine::TCallInfo callInfo;
            iLine.GetCallInfo( calls, callInfo );
            if ( InitCallL( callInfo.iCallName ) )
                {
                __VTPRINT( DEBUG_SESSION | DEBUG_CONSTRUCT, 
                    "VtCtl:SesConL call found and created" )
                calls = 0;
                }
            }
        }

    __VTPRINTEXIT( "CVtCtlSessionContainer.ConstructL" )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVtCtlSessionContainer* CVtCtlSessionContainer::NewL( 
    MVtCtlCallStatusObserver& aObserver )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.NewL" )
    CVtCtlSessionContainer* self = 
        new ( ELeave ) CVtCtlSessionContainer( aObserver );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    __VTPRINTEXIT( "CVtCtlSessionContainer.NewL" )
    return self;
    }

    
// Destructor
CVtCtlSessionContainer::~CVtCtlSessionContainer()
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.~" )

    TInt count( iCalls.Count() );
    CVtCtlVideoCall* call = NULL;
    while ( count-- )
        {
        call = iCalls[count];
        delete call;
        }
    iCalls.Close();
    delete iLineMonitor;
    iLine.Close();
    iPhone.Close();    
    iServer.UnloadPhoneModule( KMmTsyModuleName() );
    iServer.Close();
    __VTPRINTEXIT( "CVtCtlSessionContainer.~" )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::HandleLineEventL
// Handle new call on data line
// -----------------------------------------------------------------------------
//
void CVtCtlSessionContainer::HandleLineEventL(
    const TLineEvent aEvent, 
    TDesC& aCallName )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.HandleLineEventL" )
    if ( aEvent == ELineEventCallAdded )
        {
        CVtCtlVideoCall* call = FindCall( aCallName );
        if ( call == NULL )
            {
            InitCallL( aCallName );
            }
        }
    __VTPRINTEXITR( "CVtCtlSessionContainer.HandleLineEventL event=%d", 
        aEvent )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::HandleLineEventL
// 
// -----------------------------------------------------------------------------
//
/*****************************************************
*   Series 60 Customer / ETel
*   Series 60  ETel API
*****************************************************/
void CVtCtlSessionContainer::HandleLineEventL( 
    const TLineEvent aEvent, 
    const RMobileCall::TMobileCallStatus aStatus )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.HandleLineEventL" )
    __VTPRINT3( DEBUG_SESSION, "SesCont.LineEvent2 event=%d,status=%d",
        (TInt) aEvent,
        (TInt) aStatus )
    if ( aEvent == ELineEventStatusChange && 
         ( aStatus == RMobileCall::EStatusRinging ||
           aStatus == RMobileCall::EStatusDialling ) )
        {
        TInt calls( 0 );
        iLine.EnumerateCall( calls );
        while ( calls-- )
            {
            RLine::TCallInfo callInfo;
            TInt err( iLine.GetCallInfo( calls, callInfo ) );
            // ensure we're opening correct call
            if ( err == KErrNone &&
               ( callInfo.iStatus == RCall::EStatusDialling ||
                 callInfo.iStatus == RCall::EStatusRinging ) )
                {
                calls = 0; // break
                CVtCtlVideoCall* call = FindCall( callInfo.iCallName );
                if ( call == NULL )
                    {
                    InitCallL( callInfo.iCallName );
                    }
                }
            }        
        }
    __VTPRINTEXIT( "CVtCtlSessionContainer.HandleLineEventL" )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::HandleCallStatusChangeL
// passes call status change event to observer
// -----------------------------------------------------------------------------
//
void CVtCtlSessionContainer::HandleCallStatusChangeL( 
    TVtCtlSessionId aId,
    MVtCtlCallControl::TVtCtlState aStatus,
    MVtCtlCallControl::TVtCtlState aPreviousStatus )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.HandleCallStatusChangeL" )
    iObserver.HandleCallStatusChangeL( aId, aStatus, aPreviousStatus );
    if ( aStatus == MVtCtlCallControl::EIdle )
        {
        DestructCall( aId );
        }
    __VTPRINTEXIT( "CVtCtlSessionContainer.HandleCallStatusChangeL" )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::FindCall
// Finds call by name
// -----------------------------------------------------------------------------
//
/*****************************************************
*   Series 60 Customer / ETel
*   Series 60  ETel API
*****************************************************/
CVtCtlVideoCall* CVtCtlSessionContainer::FindCall( TDesC& aCallName ) const
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.FindCall" )
    TInt count( iCalls.Count() );
    CVtCtlVideoCall* call = NULL;
    while ( count-- )
        {
        call = iCalls[count];
        const RMobileCall::TMobileCallInfoV1& mobileInfo = call->MobileInfo();
        if ( aCallName == mobileInfo.iCallName )
            {
            count = 0; // break
            }
        else
            {
            call = NULL;
            }
        }
    __VTPRINT2( DEBUG_SESSION | DEBUG_DETAIL, 
        "SesCont.FindCall by name --> %d",(TInt)call )
    __VTPRINTEXIT( "CVtCtlSessionContainer.FindCall" )
    return call;
    }


// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::FindCall
// Finds call by id.
// -----------------------------------------------------------------------------
//
CVtCtlVideoCall* CVtCtlSessionContainer::FindCall( TVtCtlSessionId aId ) const
    {    
    __VTPRINTENTER( "CVtCtlSessionContainer.FindCall" )
    TInt count( iCalls.Count() );
    CVtCtlVideoCall* call = NULL;
    if ( aId == KActiveSessionId && count == 1 )
        {
        call = iCalls[0];
        count = 0;
        }
    while ( count-- )
        {
        call = iCalls[count];
        const CVtCtlVideoCall::TVtCtlCallInfo& info =
            call->CallInfo();
        if ( aId == info.iId )
            {
            count = 0; // break
            }
        else
            {
            call = NULL;
            }
        }
    __VTPRINT2( DEBUG_SESSION | DEBUG_DETAIL, 
        "SesCont.FindCall by id --> %d",(TInt)call )
    __VTPRINTEXIT( "CVtCtlSessionContainer.FindCall" )
    return call;
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::Sessions
// Returns sessions.
// -----------------------------------------------------------------------------
//
TInt CVtCtlSessionContainer::GetSessions( RVtCtlSessionIdArray& aArray ) const
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.GetSessions" )
    const TInt count( iCalls.Count() );
    for ( TInt ii = 0; ii < count; ii++ )
        {
        TInt err( aArray.Append( iCalls[ii]->CallInfo().iId ) );
        if ( err != KErrNone )
            {
            __VTPRINTEXIT( "CVtCtlSessionContainer.GetSessions" )
            return err;
            }
        }
    __VTPRINTEXIT( "CVtCtlSessionContainer.GetSessions" )
    return count;
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::DestructCall
// Destructs call
// -----------------------------------------------------------------------------
//
void CVtCtlSessionContainer::DestructCall( TVtCtlSessionId aId )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.DestructCall" )
    TInt count( iCalls.Count() );
    CVtCtlVideoCall* call = NULL;
    while ( count-- )
        {
        call = iCalls[count];
        const CVtCtlVideoCall::TVtCtlCallInfo& info =
            call->CallInfo();
        if ( aId == info.iId )
            {
            delete call;
            iCalls.Remove( count );
            count = 0; // break
            }
        }
    __VTPRINTEXIT( "CVtCtlSessionContainer.DestructCall" )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::CheckCallTypeL
// Checks call type
// -----------------------------------------------------------------------------
//
/*****************************************************
*   Series 60 Customer / ETel
*   Series 60  ETel API
*****************************************************/
TBool CVtCtlSessionContainer::CheckCallTypeL( 
    RMobileCall& aCall, 
    const TName& aName )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.CheckCallTypeL" )
    User::LeaveIfError( aCall.OpenExistingCall( iLine, aName ) );
    TBool typeOk( EFalse );
    RMobileCall::TMobileCallDataCapsV1 caps;
    RMobileCall::TMobileCallDataCapsV1Pckg pckg( caps );
    User::LeaveIfError( aCall.GetMobileDataCallCaps( pckg ) );
    __VTPRINT3( DEBUG_SESSION | DEBUG_DETAIL,
        "SesCont.ChkCall speedCaps=%d,protCaps=%d", 
        caps.iSpeedCaps, caps.iProtocolCaps )    
    if ( caps.iProtocolCaps & RMobileCall::KCapsIsdnMultimedia )
        {
        typeOk = ETrue;
        }
    else
        {        
        aCall.Close();
        }
    __VTPRINTEXIT( "CVtCtlSessionContainer.CheckCallTypeL" )
    return typeOk;
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::InitCallL
// Initializes call if it is video call.
// -----------------------------------------------------------------------------
//
/*****************************************************
*   Series 60 Customer / ETel
*   Series 60  ETel API
*****************************************************/
TBool CVtCtlSessionContainer::InitCallL( const TName& aCallName )
    {
    __VTPRINTENTER( "CVtCtlSessionContainer.InitCallL" )
    RMobileCall* mobilecall = new ( ELeave ) RMobileCall;
    CleanupStack::PushL( mobilecall );

    // check that type is multimedia call
    const TBool callTypeOk = CheckCallTypeL( *mobilecall, aCallName );
    if ( callTypeOk )
        {
        __VTPRINT( DEBUG_SESSION | DEBUG_DETAIL,
            "SesCont.InitCall ok" )
        TVtCtlSessionId id = iSessionIds.Create();
        CVtCtlVideoCall* call = CVtCtlVideoCall::NewL( 
            iLine, id, *this );
        CleanupStack::PushL( call );
        User::LeaveIfError( iCalls.Append( call ) );
        call->InitializeCallL( *mobilecall ); // takes ownership
        const CVtCtlVideoCall::TVtCtlCallInfo& callInfo = call->CallInfo();
        iObserver.HandleCallStatusChangeL( 
            id, callInfo.iStatus, callInfo.iPreviousStatus );
        CleanupStack::Pop(2); // mobilecall, call
        }
    else
        {
        CleanupStack::PopAndDestroy(); // mobilecall
        }
    __VTPRINTEXIT( "CVtCtlSessionContainer.InitCallL" )
    return callTypeOk;
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::TVtCtlSessionIdentities::TVtCtlSessionIdentities
// C++ constructor
// -----------------------------------------------------------------------------
//
CVtCtlSessionContainer::TVtCtlSessionIdentities::TVtCtlSessionIdentities() 
    : iCurrentId( 0 )
    {
    __VTPRINTENTER( "TVtCtlSessionIdentities.TVtCtlSessionIdentities" )
    __VTPRINTEXIT( "TVtCtlSessionIdentities.TVtCtlSessionIdentities" )
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::TVtCtlSessionIdentities::Create
// Increment session id.
// -----------------------------------------------------------------------------
//
TVtCtlSessionId CVtCtlSessionContainer::TVtCtlSessionIdentities::Create()
    {
    __VTPRINTENTER( "TVtCtlSessionIdentities.Create" )
    __VTPRINTEXIT( "TVtCtlSessionIdentities.Create" )
    return ++iCurrentId;
    }

// -----------------------------------------------------------------------------
// CVtCtlSessionContainer::TVtCtlSessionIdentities::Current
// Return current session id.
// -----------------------------------------------------------------------------
//
TVtCtlSessionId CVtCtlSessionContainer::TVtCtlSessionIdentities::Current() const
    {
    __VTPRINTENTER( "TVtCtlSessionIdentities.Current" )
    __VTPRINTEXIT( "TVtCtlSessionIdentities.Current" )
    return iCurrentId;
    }
#pragma CTC ENDSKIP
//  End of File