/*

* 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