diff -r 2eacb6118286 -r ba76fc04e6c2 phoneengine/callhandling/src/cpesinglecallobserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneengine/callhandling/src/cpesinglecallobserver.cpp	Fri Jun 04 10:19:18 2010 +0100
@@ -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