--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneengine/callhandling/src/cpesinglecallobserver.cpp Mon Jan 18 20:18:27 2010 +0200
@@ -0,0 +1,445 @@
+/*
+* Copyright (c) 2003-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 the implementation of CPESingleCallObserver class
+* member functions.
+*
+*/
+
+
+// INCLUDE FILES
+#include <talogger.h>
+#include <pepanic.pan>
+
+#include "cpesinglecallobserver.h"
+#include "mpemessagesender.h"
+
+// ================= MEMBER FUNCTIONS =======================
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::CPESingleCallObserver
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CPESingleCallObserver::CPESingleCallObserver( MPEMessageSender& aOwner )
+ : CPECall( aOwner ),
+ iDialledNumber( KNullDesC )
+ {
+ TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCallObserver::CPESingleCallObserver start." );
+ TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCallObserver::CPESingleCallObserver complete." );
+ }
+
+// Destructor
+CPESingleCallObserver::~CPESingleCallObserver()
+ {
+ TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCallObserver::~CPESingleCallObserver: Start." );
+ if( iCall )
+ {
+ TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCallObserver::~CPESingleCallObserver: Release" );
+ iCall->Release();
+ }
+ TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCallObserver::~CPESingleCallObserver: Complete." );
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::ErrorOccurred
+// Asynchronous call errors are notified using this interface.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPESingleCallObserver::ErrorOccurred( const TCCPError aError )
+ {
+ TInt error = static_cast < TInt > ( aError );
+ TEFLOGSTRING2( KTAERROR, "CALL CPESINGLECALLOBSERVER::ERROROCCURRED, ! ERROR CODE: %d !", error );
+ // Currently completes also with KErrNone
+ // Need to prevent forwarding in no-error situation
+ if( ECCPErrorBusy == aError )
+ {
+ iErrorCode = aError;
+ CPECall::SendMessage( MEngineMonitor::EPEMessageRemoteBusy );
+ }
+ else if( ECCPErrorRejected == aError )
+ {
+ // Don't send error message.
+ SetMissedCall( EFalse );
+ }
+ else if( aError != KErrNone )
+ {
+ CPECall::SendErrorMessage( error );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::CallStateChanged
+// Notifies observer the change in call state. The observer needs to verify
+// event correctness.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPESingleCallObserver::CallStateChanged( const CCPCall::TCallState aState )
+ {
+ TEFLOGSTRING2( KTAREQIN, "CALL CPESingleCallObserver::CallStateChanged, Call state: %d", aState );
+
+ switch ( aState )
+ {
+ case CCPCall::EStateIdle:
+ {
+ SetCallState( EPEStateIdle );
+ SendMessage( MEngineMonitor::EPEMessageIdle );
+ break;
+ }
+ case CCPCall::EStateRinging:
+ {
+ SetCallState( EPEStateRinging );
+ SendMessage( MEngineMonitor::EPEMessageIncoming );
+ SetMissedCall( ETrue );
+ break;
+ }
+ case CCPCall::EStateConnecting:
+ {
+ SetCallState( EPEStateConnecting );
+ SendMessage( MEngineMonitor::EPEMessageConnecting );
+ break;
+ }
+ case CCPCall::EStateConnected:
+ {
+ SetCallState( EPEStateConnected );
+ SendMessage( MEngineMonitor::EPEMessageConnected );
+ SetMissedCall( EFalse );
+ break;
+ }
+ case CCPCall::EStateDisconnecting:
+ {
+ SetCallState( EPEStateDisconnecting );
+ SendMessage( MEngineMonitor::EPEMessageDisconnecting );
+ break;
+ }
+ case CCPCall::EStateHold:
+ {
+ SetCallState( EPEStateHeld );
+ SendMessage( MEngineMonitor::EPEMessageHeld );
+ break;
+ }
+ case CCPCall::EStateAnswering:
+ {
+ SetCallState( EPEStateAnswering );
+ SendMessage( MEngineMonitor::EPEMessageAnswering );
+ break;
+ }
+ case CCPCall::EStateDialling:
+ {
+ SetCallState( EPEStateDialing );
+ SendMessage( MEngineMonitor::EPEMessageDialing );
+ break;
+ }
+ case CCPCall::EStateQueued:
+ {
+ SetCallState( EPEStateRinging );
+ SendMessage( MEngineMonitor::EPEMessageIncoming );
+ SetMissedCall( ETrue );
+ break;
+ }
+
+ case CCPCall::EStateTransferring:
+
+ {
+ // Not supported -> Ignored
+ TEFLOGSTRING( KTAERROR, "CALL CPESingleCallObserver::CALLSTATECHANGED ! STATE IGNORED !" );
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::CallStateChangedWithInband
+//
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPESingleCallObserver::CallStateChangedWithInband(
+ const CCPCall::TCallState aState )
+ {
+ TEFLOGSTRING2(
+ KTAREQIN,
+ "CALL CPESingleCallObserver::CallStateChangedWithInband, Call state: %d",
+ aState );
+
+ switch ( aState )
+ {
+ case CCPCall::EStateConnecting:
+ {
+ SetCallState( EPEStateConnecting );
+ SendMessage( MEngineMonitor::EPEMessageConnectingWithInband );
+ break;
+ }
+ case CCPCall::EStateDisconnecting:
+ {
+ SetCallState( EPEStateDisconnecting );
+ SendMessage( MEngineMonitor::EPEMessageDisconnectingWithInband );
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::CallEventOccurred
+// An event for the call has occurred. The observer needs to verify
+// event correctness.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPESingleCallObserver::CallEventOccurred( const MCCECallObserver::TCCECallEvent aEvent )
+ {
+ TEFLOGSTRING2( KTAREQIN, "CALL CPESingleCallObserver::CallEventOccurred, Call event: %d", aEvent );
+
+ switch ( aEvent )
+ {
+ case MCCECallObserver::ERemoteTerminated:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Remotely terminated" );
+ SendMessage( MEngineMonitor::EPEMessageRemoteTerminated );
+ break;
+ }
+ case MCCECallObserver::ESecureSession: // fall through
+ case MCCECallObserver::ENotSecureSession: // fall through
+ case MCCECallObserver::EVoIPEventNotSecureSessionWithSips:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Secure information changed" );
+ SendMessage( MEngineMonitor::EPEMessageCallSecureStatusChanged );
+ break;
+ }
+ case MCCECallObserver::ECCESecureNotSpecified:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Secure not specified" );
+ SendMessage( MEngineMonitor::EPEMessageSecureNotSpecified );
+ break;
+ }
+ case MCCECallObserver::ELocalHold:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Locally held, IGNORED" );
+ break;
+ }
+ case MCCECallObserver::ELocalResume:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Locally resumed, IGNORED" );
+ break;
+ }
+ case MCCECallObserver::ERemoteHold:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Remotely held" );
+ SendMessage( MEngineMonitor::EPEMessageRemoteHeld );
+ break;
+ }
+ case MCCECallObserver::ERemoteResume:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Remotely resumed" );
+ SendMessage( MEngineMonitor::EPEMessageRemoteResumed );
+ break;
+ }
+ case MCCECallObserver::ERemoteConferenceCreate:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Remotely created conference" );
+ SendMessage( MEngineMonitor::EPEMessageRemoteCreatedConference );
+ break;
+ }
+ case MCCECallObserver::ELocalTransfer:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::ELocalTransfer" );
+ SendMessage( MEngineMonitor::EPEMessageTransferDone );
+ break;
+ }
+ case MCCECallObserver::ERemoteTransferring:
+ case MCCECallObserver::ERemoteTransferAlerting:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::ERemoteTransferring or ERemoteTransferAlerting" );
+ SendMessage( MEngineMonitor::EPEMessageTransferring );
+ break;
+ }
+ case MCCECallObserver::ECCENotifyRemotePartyInfoChange:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::ECCENotifyRemotePartyInfoChange" );
+ SendMessage( MEngineMonitor::EPEMessageRemotePartyInfoChanged );
+ break;
+ }
+
+ // Indicates that network or call provider has started to play
+ // inband tone so our tone playing must be stopped.
+ case MCCECallObserver::EVoIPEventEarlyMediaStarted:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::EVoIPEventEarlyMediaStarted" );
+ iOwner.HandleInternalMessage( MPEPhoneModel::EPEMessageStopTonePlay );
+ break;
+ }
+
+ case MCCECallObserver::ERemoteForwarding:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::EPEMessageRemoteForwarding" );
+ SendMessage( MEngineMonitor::EPEMessageRemoteForwarding );
+ break;
+ }
+ case MCCECallObserver::EVoIPEventMovedPermanently:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::EMovedPermanently" );
+ SendMessage( MEngineMonitor::EPEMessageMovedPermanently );
+ break;
+ }
+ case MCCECallObserver::EVoIPEventMultipleChoices:
+ {
+ TEFLOGSTRING( KTAINT, "CALL CPESingleCallObserver::EMovedPermanently" );
+ SendMessage( MEngineMonitor::EPEMessageMultipleChoices );
+ break;
+ }
+
+ case MCCECallObserver::ELocalDeflectCall:
+ case MCCECallObserver::ERemoteBarred:
+ case MCCECallObserver::ERemoteWaiting:
+ case MCCECallObserver::ELocalBarred:
+ default:
+ {
+ TEFLOGSTRING2( KTAINT, "CALL CPESingleCallObserver::CallEventOccurred, Unspecified/protocol specific call event: %d", aEvent );
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::CallDurationChanged
+// Notifies observer the change in call duration.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPESingleCallObserver::CallDurationChanged( const TTimeIntervalSeconds aDuration )
+ {
+ TEFLOGSTRING( KTAREQIN, "CALL CPESingleCallObserver::CallDurationChanged" );
+ iDuration = aDuration;
+ SendMessage( MEngineMonitor::EPEMessageChangedCallDuration );
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::CallCapsChanged
+// Notifies observer about the changes in call control caps.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPESingleCallObserver::CallCapsChanged( const MCCECallObserver::TCCECallControlCaps aCaps )
+ {
+ TEFLOGSTRING( KTAREQIN, "CALL CPESingleCallObserver::CallCapsChanged" );
+ iControlCaps = aCaps;
+ SendMessage( MEngineMonitor::EPEMessageCallControlCapsChanged );
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::HandleTransfer
+// Notifies observer about transfer made by remote end
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPESingleCallObserver::HandleTransfer( const TBool aAttended,
+ const TDesC& aDestination )
+ {
+ TEFLOGSTRING3( KTAREQIN, "CALL CPESingleCallObserver::HandleTransfer: Remote transfer request, attended: %d, destination: %S", aAttended, &aDestination );
+ TEFLOGSTRING( KTAREQIN, "CALL CPESingleCallObserver::HandleTransfer: Currently not supported" );
+ if ( KNullDesC() != aDestination && EFalse == aAttended &&
+ aDestination.Length() <= iTransferTarget.MaxLength() )
+ {
+ iTransferTarget = aDestination;
+ SendMessage( MEngineMonitor::EPEMessageUnattendedTransferRequest );
+ }
+ else
+ {
+ iCall->AcceptTransfer( EFalse );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::GetCallDuration
+// Method returns the duration of the current call.
+// -----------------------------------------------------------------------------
+//
+void CPESingleCallObserver::GetCallDuration(
+ TTimeIntervalSeconds& aDuration )
+ {
+ TEFLOGSTRING2(
+ KTAINT,
+ "CALL CPESingleCallObserver::GetCallDuration, iDuration: %d",
+ iDuration.Int() );
+ aDuration = iDuration;
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::GetCallControlCaps
+// Method returns call control caps
+// -----------------------------------------------------------------------------
+//
+void CPESingleCallObserver::GetCallControlCaps(
+ MCCECallObserver::TCCECallControlCaps& aCallControlCaps ) const
+ {
+ TEFLOGSTRING2( KTAINT, "CALL CPESingleCallObserver::GetCallControlCaps, iControlCaps: %d", iControlCaps );
+ aCallControlCaps = iControlCaps;
+ }
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::Call
+// Returns reference to MCCECall handle
+// -----------------------------------------------------------------------------
+//
+MCCECall& CPESingleCallObserver::Call()
+ {
+ TEFLOGSTRING2( KTAINT, "CALL CPESingleCallObserver::Call, iCall: %d", iCall );
+ return *iCall;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::SetCall
+//
+// -----------------------------------------------------------------------------
+//
+void CPESingleCallObserver::SetCall( MCCECall& aCall )
+ {
+ TEFLOGSTRING2( KTAINT, "CALL CPESingleCallObserver::SetCall, aCall: %d", &aCall );
+ iCall = &aCall;
+ iCall->SetObserver( *this );
+ iControlCaps = iCall->Caps();
+ TEFLOGSTRING2( KTAINT, "CALL CPESingleCallObserver::SetCall, iControlCaps: %b", iControlCaps );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::UnattendedTransferTarget
+// -----------------------------------------------------------------------------
+//
+const TPEPhoneNumber& CPESingleCallObserver::UnattendedTransferTarget() const
+ {
+ TEFLOGSTRING2( KTAREQIN,
+ "CALL CPESingleCallObserver::UnattendedTransferTarget: %S",
+ &iTransferTarget );
+
+ return iTransferTarget;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CPESingleCallObserver::ForwardAddressChoices
+// -----------------------------------------------------------------------------
+//
+const CDesC8Array* CPESingleCallObserver::ForwardAddressChoices() const
+ {
+ const CDesC8Array* array = NULL;
+ TRAP_IGNORE( array = &iCall->GetForwardAddressChoicesL() );
+
+ return array;
+ }
+
+// End of File