/*

* Copyright (c) 2002-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:  This file contains implementation of CPEVideoCallHandling class.

*

*/

// INCLUDE FILES

#include "cpevideocallhandling.h"

#include "cpesinglecall.h"

#include "pevirtualengine.h"

#include "cpecallarrayowner.h"

#include "cpecallarrayowner.h"

#include "cpegprstermination.h"

#include <mpephonemodelinternal.h>

#include <e32property.h>

#include <gsmerror.h>

#include <mpedatastore.h>

#include <NetworkHandlingDomainPSKeys.h>

#include <pepanic.pan>

#include <pevirtualengine.h>

#include <talogger.h>

#include <ctsydomainpskeys.h>

#include <connect/sbdefs.h>

#include <ccce.h>

#include <mccecall.h>

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

// CPEVideoCallHandling::CPEVideoCallHandling

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

// might leave.

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

//

CPEVideoCallHandling::CPEVideoCallHandling(

        MPEMessageSender& aOwner,

        MPEPhoneModelInternal& aModel,        

        CCCE& aConvergedCallEngine,

        CPECallArrayOwner& aCallArrayOwner

        ) : iOwner( aOwner ),

            iModel( aModel ),

            iConvergedCallEngine( aConvergedCallEngine ),

            iDataCallName( KNullDesC ),

            iCallArrayOwner( aCallArrayOwner ),

            iDataStore( *( aModel.DataStore( ) ) ),

            iRestoreCauseVTCallReject( EFalse )

    {

    }

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

// CPEVideoCallHandling::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEVideoCallHandling::ConstructL()

    {

    TEFLOGSTRING( KTAOBJECT, "VID CPEVideoCallHandling::ConstructL start." );

    iCallOpenParams = CCCECallParameters::NewL();

    TEFLOGSTRING( KTAOBJECT, "VID CPEVideoCallHandling::ConstructL complete." );

    }

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

// CPEVideoCallHandling::NewL

// Two-phased constructor.

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

//

CPEVideoCallHandling* CPEVideoCallHandling::NewL(

        MPEMessageSender& aOwner,

        MPEPhoneModelInternal& aModel,         

        CCCE& aConvergedCallEngine,

        CPECallArrayOwner& aCallArrayOwner )

    {

    TEFLOGSTRING( KTAOBJECT, "VID CPEVideoCallHandling::NewL start." );

    CPEVideoCallHandling* self = new ( ELeave ) CPEVideoCallHandling( aOwner, 

                                                                      aModel, 

                                                                      aConvergedCallEngine,

                                                                      aCallArrayOwner );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TEFLOGSTRING( KTAOBJECT, "VID CPEVideoCallHandling::NewL complete." );

    return self;

    }

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

// CPEVideoCallHandling::~CPEVideoCallHandling()

// Destructor

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

//

CPEVideoCallHandling::~CPEVideoCallHandling()

    {

    TFLOGSTRING( "CallHandling: CPEVideoCallHandling::~CPEVideoCallHandling() Start");

    delete iGprsInterface;

    iGprsInterface = NULL;

    delete iCallOpenParams;

    TFLOGSTRING( "CallHandling: CPEVideoCallHandling::~CPEVideoCallHandling() complete");

    }

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

// CPEVideoCallHandling::AnswerCall

// Answers the incoming call

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

//

TInt CPEVideoCallHandling::AnswerCall()

    {

    TEFLOGSTRING( KTAINT, "VID CPEVideoCallHandling::AnswerCall");

    TInt errorCode( KErrNotFound );

    CPESingleCall* dataCallData = VideoCallByState( EPEStateRinging );

    if ( dataCallData )

        {

        if ( GetNumberOfCalls() == 1 )

            {

            TEFLOGSTRING( KTAINT, "VID CPEVideoCallHandling::AnswerCall > CPEDataCall::Answer" );

            dataCallData->Answer();

            errorCode = KErrNone;

            }

        else

            {

            TEFLOGSTRING( KTAERROR, 

                    "VID CPEVIDEOCALLHANDLING::ANSWERCALL: NOT ALLOWED WITH EXISTING CALLS!" );

            errorCode = ECCPErrorNotAllowed;

            }

        }

    else

        {

        TEFLOGSTRING( KTAERROR, 

                "VID CPEVIDEOCALLHANDLING::ANSWERCALL: NO RINGING CALLS FOUND!" );

        }

    return errorCode;

    }

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

// CPEVideoCallHandling::VideoCallByState

// Finds a data call object that is in specified  state

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

//  

CPESingleCall* CPEVideoCallHandling::VideoCallByState( 

        const TPEState aState ) const

    {

    TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::DataCallByState" );

    CPESingleCall* returnValue( NULL );

    CPESingleCall* callData;

    for ( TInt callId = KPEDataCallIdBase; 

          callId < ( KPEDataCallIdBase + KPEMaximumNumberOfDataCalls ); 

          callId++ )

        {

        callData = iCallArrayOwner.GetCallObject( callId );

        if ( callData 

             && ( callData->GetCallState() == aState ) )

            {

            returnValue = callData;

            TEFLOGSTRING2( KTAINT, 

                "CALL CPEVideoCallHandling::DataCallByState %d", callId );

            break;

            }

        }

    return returnValue;

    }

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

// CPEVideoCallHandling::CallTerminatedError

// Handles RemoteTerminated. 

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

//

TInt CPEVideoCallHandling::CallTerminatedError( const TInt aCallId )

    {

    TEFLOGSTRING2( KTAINT, 

            "VID CPEVideoCallHandling::CallTerminatedError, aCallId: %d",

            aCallId );

    TInt errorCode( KErrNone );    

	CPESingleCall* dataCall = iCallArrayOwner.GetCallObject( aCallId );

	if ( dataCall )

	    {

	    dataCall->GetErrorCode( errorCode );

	    }

	TEFLOGSTRING2( KTAINT, 

	            "VID CPEVideoCallHandling::CallTerminatedError, errorCode: %d",

	            errorCode );

    return errorCode;

    }

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

// CPEVideoCallHandling::DataPortInUse

// Tells if the call has reserved serial communications data port for use

// The default value is EFalse, i.e. the data port has not been reserved for

// use. The data port is recovered when no longer needed.

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

// 

TBool CPEVideoCallHandling::DataPortInUse(

        TInt aCallId ) const

    {

    TBool dataPortInUse( EFalse );

    TPEState state;

    if ( CallIdCheck::IsVideo( aCallId ) )

        {

        CPESingleCall* callData = iCallArrayOwner.GetCallObject( aCallId );

        if( callData )

            {

            state = callData->GetCallState();

            if( state == EPEStateConnected )

                {

                dataPortInUse = ETrue;

                }

            }

        }

    return dataPortInUse;

    }

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

// CPEVideoCallHandling::DialCall

// Creates dialing request to the Multimode ETel. 

// This request is for creating a new multimedia (=data) call

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

//

TInt CPEVideoCallHandling::DialCall(

        const TPEPhoneNumber& aNumber,

        TInt& aCallId )

    {

    TEFLOGSTRING( KTAINT, "VID CPEVideoCallHandling::DialCall" );

    TInt errorCode( KErrNone );

    TInt networkMode( ENWNetworkModeUnknown );

    CPESingleCall* callData( NULL );

    RProperty::Get( KPSUidNetworkInfo, KNWTelephonyNetworkMode, networkMode );   

    TInt restoreValue;

    RProperty::Get( KUidSystemCategory, conn::KUidBackupRestoreKey, restoreValue );       

    if ( networkMode == ENWNetworkModeWcdma && 

        !( restoreValue & ( conn::EBURRestoreFull | conn::EBURRestorePartial )) )

        {

        TRAP( errorCode, callData = OpenNewCallL( aNumber ) );

        if( errorCode == KErrNone )

            {

            TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::DialCall > Dial" );

            errorCode = callData->Dial( aNumber );

            if ( errorCode != KErrNone )

                {

                // Dial failed: clean up

                ReleaseCallObject( callData->GetCallId() );

                TEFLOGSTRING2( KTAERROR, 

                        "VID CALL CPEVideoCallHandling::DialCall ! DIAL FAILED: MAY NOT PROCEED! %d",

                        errorCode );

                }

            else

                {

                // Dial request passed on successfully: forward new call id

                aCallId = callData->GetCallId();

                }

            }

        }

    else

        {

        TEFLOGSTRING( KTAERROR, 

            "VID CPEVideoCallHandling::DialCall: Attempting video call in 2G network!" );

        errorCode = ( networkMode != ENWNetworkModeWcdma ) ? 

                      ECCPErrorVideoCallNotSupportedByNetwork : 

                      ECCPErrorVideoCallNotAllowedDuringRestore;

        }    

    return errorCode;

    }

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

// CPEVideoCallHandling::HangUp

// terminates an ongoing call

// Method checks that call id is valid number and

// hangups conference or data call or reroutes call to base class.

// (other items were commented in a header).

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

//

TInt CPEVideoCallHandling::HangUp( TInt aCallId )

    {

    TEFLOGSTRING( KTAINT, "VID CPEVideoCallHandling::HangUp" );

    TInt errorCode( KErrNotFound );

    CPESingleCall* videoCall = iCallArrayOwner.GetCallObject( aCallId );

    if ( videoCall && CallIdCheck::IsVideo( aCallId ) ) 

        {

        errorCode = videoCall->HangUp();

        }

    return errorCode;

    }

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

// CPEVideoCallHandling::InitCall

// Handles the initializing of a single data/video call.

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

//

void CPEVideoCallHandling::InitCall( MCCECall& aCall )

    {

    TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::InitCall" );

    CPESingleCall* callData( NULL );

	  TRAP_IGNORE( callData = iCallArrayOwner.CreateDataCallL( *this ) );

    if ( callData )

        {

        iModel.DataStore()->SetPhoneNumber( KNullDesC() );

        iModel.DataStore()->SetServiceId( callData->GetCallId(), aCall.ServiceId() );

        callData->SetCall( aCall );

        iModel.DataStore()->SetCallSecureStatus( callData->IsSecureCall(), callData->GetCallId() );

        iModel.DataStore()->SetSecureSpecified( callData->SecureSpecified() );

    	const CCCPCallParameters& callParameters = aCall.Parameters();

        switch ( callParameters.CallType() )

            {

            case CCPCall::ECallTypeCSVoice:

                {

                iModel.DataStore()->SetCallType( EPECallTypeCSVoice, callData->GetCallId() );

                }

                break;

            case CCPCall::ECallTypeVideo:

                {

                iModel.DataStore()->SetCallType( EPECallTypeVideo, callData->GetCallId() );

                }

                break;

            case CCPCall::ECallTypePS:

                {

                iModel.DataStore()->SetCallType( EPECallTypeVoIP, callData->GetCallId() );

                }

                break;

            default:

                __ASSERT_DEBUG( EFalse, Panic( EPEPanicIndexOutOfRange ));

                break;

            }

        }

    else

    	{

    	Panic( EPEPanicNoFreeCalls );

    	}

    }

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

// CPEVideoCallHandling::IsMultimedia

// Checks if the data call is a multimedia call. Requires that the data call has

// already been opened.

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

//

TBool CPEVideoCallHandling::IsMultimedia( TInt aCallId ) const

    {

    TEFLOGSTRING2( KTAINT, "VID CPEVideoCallHandling::IsMultimedia %d", aCallId );

    TBool multimedia( EFalse );

    CPESingleCall* videoCall = iCallArrayOwner.GetCallObject( aCallId );

    if ( videoCall && CallIdCheck::IsVideo( aCallId ) 

         && videoCall->Call().Parameters().CallType()  

                == CCPCall::ECallTypeVideo )

        {

        multimedia = ETrue;

        }

    return multimedia;

    }

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

// CPEVideoCallHandling::NotifySystemCallStateChanged

// Notifies system for changes to the call state.

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

//

void CPEVideoCallHandling::NotifySystemCallStateChanged( 

        MEngineMonitor::TPEMessagesFromPhoneEngine aMessage,  // The enumeration number of the message

        TInt aCallId )

    {

    TEFLOGSTRING2( KTAINT, "VID CPEVideoCallHandling::NotifySystemCallStateChanged %d", aCallId );

	// this needs to be checked because this function is called for all data calls

	if ( IsMultimedia( aCallId ) )

        {

	    if ( aMessage == MEngineMonitor::EPEMessageIncoming ||

	       aMessage == MEngineMonitor::EPEMessageDialing )

	        {

            TInt updateError = RProperty::Set( KPSUidCtsyCallInformation, 

                KCTsyCallType, EPSCTsyCallTypeH324Multimedia );

            TEFLOGSTRING2( updateError?KTAERROR:KTAMESOUT, 

                "VID CPEVideoCallHandling::NotifySystemCallStateChanged request RProperty::Set, EPSCTsyCallTypeH324Multimedia, updateError: ",

                updateError );

	        }

        }

    }

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

// CPEVideoCallHandling::SendMessage

// Overrides CPECallHandling::SendMessage to provide internal handling for gsm events

// and common events related to multimedia calls.

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

//

void CPEVideoCallHandling::SendMessage(

        MEngineMonitor::TPEMessagesFromPhoneEngine aMessage,

        TInt aCallId )

    {

    TEFLOGSTRING3( KTAINT, 

        "VID CPEVideoCallHandling::SendMessage, message id: %d, call id: %d", 

        aMessage, 

        aCallId );

    TInt error( KErrNone );

    CPESingleCall* videoCall = iCallArrayOwner.GetCallObject( aCallId );

    CPESingleCall* connectedVideoCall = VideoCallByState( EPEStateConnected );

    if ( IsMultimedia( aCallId ) )

        {

        switch ( aMessage )

            {

            case MEngineMonitor::EPEMessageIncoming:

            case MEngineMonitor::EPEMessageDialing:

                {

                TInt restoreValue;

                RProperty::Get( KUidSystemCategory, conn::KUidBackupRestoreKey, restoreValue );

                if( ( restoreValue & ( conn::EBURRestoreFull | conn::EBURRestorePartial ) ) )

                    {

                    // First phase VT and restore: Check if there is a arriving VT 

            	    // call and Restore ongoing.

            	    TEFLOGSTRING( KTAINT, 

                        "VID CPEVideoCallHandling::SendMessage > HangUp restore active " );

               	    iRestoreCauseVTCallReject = ETrue;

               	    if( videoCall )

               	        {

               	        videoCall->HangUp();

               	        }

               	    aMessage = MEngineMonitor::EPEMessageDoNotSendMe;

                    }

                break;

                }

            case MEngineMonitor::EPEMessageDisconnecting:

                {

                if( iRestoreCauseVTCallReject )

	                {

	            	// Second phase VT and restore: Check if there is a rejected arriving VT call 

	                // and Restore ongoing, then don't notify observers.

	                iRestoreCauseVTCallReject = EFalse;

	                TEFLOGSTRING( KTAINT, 

				        "VID CPEVideoCallHandling::SendMessage Second phase Restore and VT call" );

	                aMessage = MEngineMonitor::EPEMessageDoNotSendMe;

	                }

                break;

                }

            case MEngineMonitor::EPEMessageIdle:

                {

                iRestoreCauseVTCallReject = EFalse;

                // Check reject video cace, if there is connect VT call don't disconnect

                if( !connectedVideoCall )

	                {

	                if ( CallTerminatedError( aCallId ) == KErrGsmCCIncompatibleDestination )

	                    {

	                    error = KErrGsmCCIncompatibleDestination;

	                    }

	                }

                break;

                }

            default:

                {

                TEFLOGSTRING2( 

                    KTAINT, 

                    "VID CPEVideoCallHandling::SendMessage: multimedia call, message: %d", 

                    aMessage );

                break;

                }

            } 

        }

    else

        {

        TEFLOGSTRING2( 

            KTAINT, 

            "VID CPEVideoCallHandling::SendMessage, isMultimedia: %d", 

            IsMultimedia( aCallId ) );

        }

    if ( error == KErrNone )

        {

        iOwner.SendMessage( aMessage, aCallId );

        }

    else

        {

        SendErrorMessage( aCallId, error );

        }

    }

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

// CPEVideoCallHandling::VideoCallInState

// Checks if there are any data calls in the specified state

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

//

TBool CPEVideoCallHandling::VideoCallInState( const TPEState& aState ) const

    {

    TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::DataCallInState" );

    TBool returnValue( EFalse );

    if( VideoCallByState( aState ) )

        {

        returnValue = ETrue;

        }

    return returnValue;

    }

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

// CPEVideoCallHandling::IsPhoneNumberAvailable

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

//

TBool CPEVideoCallHandling::IsPhoneNumberAvailable( const TInt aCallId )

    {

    TEFLOGSTRING2( KTAINT, 

        "VID CPEVideoCallHandling::IsPhoneNumberAvailable, aCallId: %d"

        , aCallId );

    TBool phoneNumberAvailable ( EFalse );

    if ( iDataStore.CallDirection( aCallId ) == RMobileCall::EMobileOriginated )

	    {

	    phoneNumberAvailable = ETrue;	

	    }

    else

	    {