diff -r 000000000000 -r 5f000ab63145 phoneengine/callhandling/src/cpevideocallhandling.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phoneengine/callhandling/src/cpevideocallhandling.cpp Mon Jan 18 20:18:27 2010 +0200 @@ -0,0 +1,995 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// ----------------------------------------------------------------------------- +// 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 + { + RMobileCall::TMobileCallRemoteIdentityStatus remoteIdentity; + remoteIdentity = iDataStore.RemoteIdentity( aCallId ); + TEFLOGSTRING2( KTAINT, + "VID CPEVideoCallHandling::IsPhoneNumberAvailable, remoteIdentity: %d", + remoteIdentity); + phoneNumberAvailable = ( remoteIdentity == RMobileCall::ERemoteIdentityAvailable ); + } + TEFLOGSTRING2( KTAINT, + "VID CPEVideoCallHandling::IsPhoneNumberAvailable, isAvailable: %d", + phoneNumberAvailable ); + return phoneNumberAvailable; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::VideoCallByState +// returns CPEVoiceCall video call object by State +// ----------------------------------------------------------------------------- +// +CPESingleCall* CPEVideoCallHandling::VideoCallByState( TPEState aState ) + { + TEFLOGSTRING2( KTAINT, + "CPEVideoCallHandling::VideoCallByState, aState: %d", aState ); + TPEState state; + CPESingleCall* returnValue( NULL ); + + for ( TInt callId = KPEDataCallIdBase; + callId < ( KPEDataCallIdBase + KPEMaximumNumberOfDataCalls ); + callId++ ) + { + CPESingleCall* callData = iCallArrayOwner.GetCallObject( callId ); + if( callData ) + { + state = callData->GetCallState(); + + if ( state == aState ) + { + returnValue = callData; + break; + } + } + } + return returnValue; + } + +// ----------------------------------------------------------------------------- +// Replace active video call with a waiting video call +// NOT SUPPORTED AS OF 5.1 +// ----------------------------------------------------------------------------- +// +TInt CPEVideoCallHandling::ReplaceActive( TInt /*aCallId*/ ) + { + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::SetCallParams +// +// ----------------------------------------------------------------------------- +// +void CPEVideoCallHandling::SetCallParams( TInt aCallId ) + { + TEFLOGSTRING2( KTAINT, + "VID CCPEVideoCallHandling::SetCallParams, aCallId: %d", aCallId ); + iCallOpenParams->SetLineType( CCCECallParameters::ECCELineTypePrimary ); + + switch ( iModel.DataStore()->CallTypeCommand() ) + { + case EPECallTypeVideo: + { + iCallOpenParams->SetCallType( CCPCall::ECallTypeVideo ); + iModel.DataStore()->SetServiceIdCommand( 1 ); + iModel.DataStore()->SetCallType( EPECallTypeVideo, aCallId ); + } + break; + default: + __ASSERT_DEBUG( EFalse, Panic( EPEPanicIndexOutOfRange )); + iCallOpenParams->SetCallType( CCPCall::ECallTypeVideo ); + iModel.DataStore()->SetServiceIdCommand( 1 ); + iModel.DataStore()->SetCallType( EPECallTypeVideo, aCallId ); + break; + } + iCallOpenParams->SetServiceId( iModel.DataStore()->ServiceIdCommand() ); + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::OpenNewCallL +// returns ETrue if hangup active +// ----------------------------------------------------------------------------- +// +CPESingleCall* CPEVideoCallHandling::OpenNewCallL( const TPEPhoneNumber& aNumber ) + { + TEFLOGSTRING( KTAINT, "VID CPEVideoCallHandling::OpenNewCallL"); + TInt errorCode( KErrNone ); + CPESingleCall* callData( NULL ); + MCCECall* cceCall( NULL ); + + callData = iCallArrayOwner.CreateDataCallL( *this ); + SetCallParams( callData->GetCallId() ); + + TEFLOGSTRING( KTAINT, + "VID CPEVideoCallHandling::OpenNewCallL > CCCE::OpenNewCallL"); + TRAP( errorCode, + cceCall = &( iConvergedCallEngine.OpenNewCallL( aNumber, + *iCallOpenParams, + *callData ) ) ); + if ( errorCode == KErrNone ) + { + callData->SetCall( *cceCall ); + iModel.DataStore()->SetServiceId( callData->GetCallId(), cceCall->ServiceId() ); + iModel.DataStore()->SetCallSecureStatus( callData->IsSecureCall(), callData->GetCallId() ); + iModel.DataStore()->SetSecureSpecified( callData->SecureSpecified() ); + } + else + { + // Open new call failed + ReleaseCallObject( callData->GetCallId() ); + TEFLOGSTRING2( KTAERROR, + "VID CPEVideoCallHandling::DIALCALL ! OPENNEWCALL FAILED: MAY NOT PROCEED! %d", + errorCode ); + User::Leave( errorCode ); + } + return callData; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::GetCallState +// Returns call state information. +// ----------------------------------------------------------------------------- +// +TPEState CPEVideoCallHandling::GetCallState( TInt aCallId ) + { + TEFLOGSTRING2( KTAINT, + "CALL CPEVideoCallHandling::GetCallState %d", aCallId ); + TPEState callState( EPEStateUnknown ); + CPESingleCall* callData = iCallArrayOwner.GetCallObject( aCallId ); + if( callData ) + { + callState = callData->GetCallState(); + } + else + { + callState = EPEStateIdle; + } + TEFLOGSTRING2( KTAINT, + "CALL CPEVideoCallHandling::GetCallState, callState: %d", + callState ); + return callState; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::VideoCallById +// returns CPESingleCall video call object by State +// ----------------------------------------------------------------------------- +// +CPESingleCall* CPEVideoCallHandling::VideoCallById( TInt aCallId ) + { + TEFLOGSTRING2( KTAINT, "VID CPEVideoCallHandling::VideoCallById %d", aCallId ); + return iCallArrayOwner.GetCallObject( aCallId ); + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::GetNumberOfCalls +// Returns number of data calls. +// ----------------------------------------------------------------------------- +// +TInt CPEVideoCallHandling::GetNumberOfCalls() + { + TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::GetNumberOfCalls" ); + // Count ongoing calls + return iCallArrayOwner.ActiveCallCount(); + } + + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::SendMessage +// Reroutes messages to the Phone Engine +// ----------------------------------------------------------------------------- +// +void CPEVideoCallHandling::SendMessage( + MEngineMonitor::TPEMessagesFromPhoneEngine aMessage, + const TName& aName ) + { + TEFLOGSTRING2( KTAINT, "CALL CPECallHandling::SendMessage, message id: %d", aMessage ); + CPESingleCall* videoCall = VideoCallByName( aName ); + if( videoCall ) + { + SendMessage( aMessage, videoCall->GetCallId() ); + } + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::VideoCallByName +// returns data call object by name +// ----------------------------------------------------------------------------- +// +CPESingleCall* CPEVideoCallHandling::VideoCallByName( const TName& aName ) + { + TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::DataCallByName" ); + CPESingleCall* returnValue( NULL ); + CPESingleCall* callData; + for ( TInt callId = KPEDataCallIdBase; + callId < ( KPEDataCallIdBase + KPEMaximumNumberOfDataCalls ); + callId++ ) + { + callData = iCallArrayOwner.GetCallObject( callId ); + + if ( callData + && ( VideoCallName( callId ) == aName ) ) + { + returnValue = callData; + TEFLOGSTRING2( KTAINT, + "CALL CPEVideoCallHandling::DataCallByName %d", callId ); + break; + } + } + return returnValue; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::VideoCallName +// Finds data call name given the call id. +// ----------------------------------------------------------------------------- +// +TName& CPEVideoCallHandling::VideoCallName( const TInt aCallId ) + { + TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::DataCallName" ); + + iDataCallName = KNullDesC; + TInt errorCode( KErrNone ); + + if ( CallIdCheck::IsVideo( aCallId ) ) + { + RMobileCall::TMobileCallInfoV3* dataCallInfo = NULL; + dataCallInfo = new RMobileCall::TMobileCallInfoV3; + + if ( dataCallInfo ) + { + errorCode = GetCallInfo( *dataCallInfo, aCallId ); + TEFLOGSTRING2( KTAINT, + "CALL CPEVideoCallHandling::DataCallName > GetCallInfo, error code: %d", + errorCode ); + + if ( errorCode == KErrNone ) + { + iDataCallName = dataCallInfo->iCallName; + } + } + else + { + errorCode = KErrNoMemory; + TEFLOGSTRING( KTAINT, + "CALL CPEVideoCallHandling::DataCallName, error code = KErrNoMemory" ); + } + delete dataCallInfo; + } + return iDataCallName; + } + + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::GetCallInfo +// Returns data call information. +// ----------------------------------------------------------------------------- +// +TInt CPEVideoCallHandling::GetCallInfo( + RMobileCall::TMobileCallInfoV3& aCallInfo, + TInt aCallId ) + { + TEFLOGSTRING2( KTAINT, "CALL CPEVideoCallHandling::GetCallInfo %d", aCallId ); + CPESingleCall* videoCall( NULL ); + TInt errorCode( KErrNotFound ); + videoCall = iCallArrayOwner.GetCallObject( aCallId ); + if ( videoCall && CallIdCheck::IsVideo( aCallId ) ) + { + errorCode = videoCall->GetCallInfo( aCallInfo ); + errorCode = KErrNone; + } + else + { + __ASSERT_DEBUG( EFalse, Panic( EPEPanicIllegalCommand) ); + } + return errorCode; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::SendErrorMessage +// Reroutes error code to Call Handling interface. +// ----------------------------------------------------------------------------- +// +void CPEVideoCallHandling::SendErrorMessage( + const TInt aCallId, + const TInt aErrorCode ) + { + TEFLOGSTRING3( KTAINT, + "CALL CPEVideoCallHandling::SendErrorMessage, error code: %d, error cause: %d, call id: %d", + aErrorCode, + aCallId ); + iOwner.SendErrorMessage( aCallId, aErrorCode ); + } + + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::HandleInternalMessage +// Reroutes messages to the Phone Engine +// ----------------------------------------------------------------------------- +// +void CPEVideoCallHandling::HandleInternalMessage( TInt aMessage ) + { + TEFLOGSTRING2( KTAINT, "CALL CPEVideoCallHandling::HandleInternalMessage, message: %d", aMessage ); + iOwner.HandleInternalMessage( aMessage ); + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::ConnectedCalls +// Indicates if there are any connected calls. +// ----------------------------------------------------------------------------- +// +TBool CPEVideoCallHandling::ConnectedCalls() + { + TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::ConnectedCalls" ); + TBool returnValue( EFalse ); + if( VideoCallByState( EPEStateConnected ) ) + { + returnValue = ETrue; + } + return returnValue ; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::RejectCall +// Rejects the incoming call. +// ----------------------------------------------------------------------------- +// +TInt CPEVideoCallHandling::RejectCall() + { + TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::RejectCall" ); + TInt errorCode( KErrNotFound ); + + CPESingleCall* videoCall = VideoCallByState( EPEStateRinging ); + if( videoCall ) + { + videoCall->HangUp(); + errorCode = KErrNone; + } + return errorCode; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::ReleaseAll +// Releases all ongoing calls. +// ----------------------------------------------------------------------------- +// +TInt CPEVideoCallHandling::ReleaseAll() + { + CPESingleCall* callData; + TInt errorCode( KErrNotFound ); + TPEState callState; + + TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::ReleaseAll " ); + + for ( TInt callId = KPEDataCallIdBase; + callId < ( KPEDataCallIdBase + KPEMaximumNumberOfDataCalls ); + callId++ ) + { + callData = iCallArrayOwner.GetCallObject( callId ); + if ( callData ) + { + callState = callData->GetCallState(); + if ( callState != EPEStateIdle && callState != EPEStateRinging ) + { + TEFLOGSTRING2( KTAINT, + "CALL CPEVideoCallHandling::ReleaseAll, call id: %d", + callId ); + HangUp( callId ); + errorCode = KErrNone; + } + } + } + + TEFLOGSTRING2( KTAINT, + "CALL CPEVideoCallHandling::ReleaseAll, error code: %d", + errorCode ); + + return errorCode; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::TerminateAllConnections +// Terminates all ringing data calls, connected data calls and packet data +// connections. +// ----------------------------------------------------------------------------- +// +TInt CPEVideoCallHandling::TerminateAllConnections() + { + TEFLOGSTRING( KTAMESINT, + "CALL CPEVideoCallHandling::TerminateAllConnections"); + // Terminate GPRS connection. + // If GPRS connections are being terminated, + // then we do not start again. + TBool canBeDeleted = ETrue; + if ( iGprsInterface ) + { + canBeDeleted = !iGprsInterface->IsTerminating(); + } + + TInt error( KErrNone ); + if ( canBeDeleted ) + { + delete iGprsInterface; + iGprsInterface = NULL; + TRAP( error, + iGprsInterface = new (ELeave) CPEGprsTermination; + iGprsInterface->StartL() ); + } + // Hangup Data calls + ReleaseAll(); + + return error; + } + +// ----------------------------------------------------------------------------- +// CPEVideoCallHandling::GetCallDuration +// Returns voice and conference (master call) call duration. +// Method checks that call id is valid number and gets +// call duration from conference or data call object or from +// calls base class for voice call duration. +// ----------------------------------------------------------------------------- +// + TInt CPEVideoCallHandling::GetCallDuration( + TTimeIntervalSeconds& aDuration, + TInt aCallId ) + { + TEFLOGSTRING2( KTAINT, "CALL CPEVideoCallHandling::GetCallDuration %d", aCallId ); + TInt errorCode( KErrNotFound ); + CPESingleCall* callData( NULL ); + callData = iCallArrayOwner.GetCallObject( aCallId ); + + if ( callData && CallIdCheck::IsVideo( aCallId ) ) + { + callData->GetCallDuration( aDuration ); + errorCode = KErrNone; + } + else + { + __ASSERT_DEBUG( EFalse, Panic( EPEPanicIllegalCommand) ); + } + + return errorCode; + } + + // ----------------------------------------------------------------------------- + // CPEVideoCallHandling::ReleaseCallObject + // ----------------------------------------------------------------------------- + // + TInt CPEVideoCallHandling::ReleaseCallObject( const TInt aCallId ) + { + TInt error(KErrNone); + TEFLOGSTRING2( KTAINT, + "CALL CPEVideoCallHandling::ReleaseCallObject ReleaseCallObject %d", aCallId ); + error = iCallArrayOwner.DeleteCallObject( aCallId ); + // Reset datastore to prevent invalid usage in next call + TEFLOGSTRING( KTAINT, "CALL CPEVideoCallHandling::ReleaseCallObject, Reset CallInfo" ); + iModel.DataStore()->ResetCallInfo( aCallId ); + return error; + } + +// End of File