/*

* Copyright (c) 2003-2008 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 CPESingleCall class 

*                member functions.

*

*/

// INCLUDE FILES

#include <pepanic.pan>

#include <talogger.h>

#include "cpesinglecall.h"

#include "mpecallowner.h"

#include "cpevideocallhandling.h"

// ================= MEMBER FUNCTIONS =======================

// Destructor

//

CPESingleCall::~CPESingleCall()

    {

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::~CPESingleCall: Start." );

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::~CPESingleCall: Complete." );

    }

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

// CPESingleCall::CPESingleCall

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

// might leave.

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

//

CPESingleCall::CPESingleCall( 

        MPEMessageSender& aOwner

        ) : CPESingleCallObserver( aOwner ),

    {

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::CPESingleCall start." );

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::CPESingleCall complete." );

    }

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

// CPEGsmVoiceCall::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPESingleCall::ConstructL()

    {

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall:::ConstructL start." );

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::ConstructL complete." );

    }

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

// CPEGsmVoiceCall::NewL

// Two-phased constructor.

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

//

CPESingleCall* CPESingleCall::NewL( 

        MPEMessageSender& aOwner )

    {

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::NewL start." );

    CPESingleCall* self = new ( ELeave ) CPESingleCall( aOwner );

    CleanupStack::PushL(self);

    self->ConstructL( );

    CleanupStack::Pop( self );

    TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::NewL complete." );

    return self;

    }

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

// CPESingleCall::SendMessage

// Method reroutes messages from other modules to the CPEPhoneData-object

// Note that it does not use base class SendMessage.

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

//

void CPESingleCall::SendMessage( 

        const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage )

    {

    iErrorCode = KErrNone;

    if( aMessage == MEngineMonitor::EPEMessageIdle )

        {

        // Get the call duration before the call object is closed.

        iDuration = Call().CallDuration();

        TEFLOGSTRING2( 

            KTAREQEND, 

            "CALL CPESingleCall::SendMessage: MCCECall::GetCallDuration() called, Duration: %d", 

            iDuration.Int() );

        }

    if ( aMessage != MEngineMonitor::EPEMessageUnknown )

        {

        CPECall::SendMessage( aMessage );

        }

    }

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

// CPESingleCall::Answer

// Method Answers the incoming call.

// Method creates iCallInfo parameter package and

// makes answer request to CPECallCommand-parameter.

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

//

TInt CPESingleCall::Answer()

    {

    SetMissedCall( EFalse );

    return Call().Answer();    

    }

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

// CPESingleCall::Dial

// creates dial request to the CPECallCommand object.

// Method opens the line for the new call.

// If error occurs the method returns error value.

// Method makes call parameter package and

// starts monitoring call statuses and call events and

// makes a dial request to the CPECallCommand object.

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

//

TInt CPESingleCall::Dial( 

        const RMobileCall::TTelNumberC& aNumber )

    {

    TInt errorCode( KErrNone );

    iDialledNumber = aNumber;

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Dial");

    errorCode = Call().Dial(KNullDesC8);

    return errorCode;

    }

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

// CPESingleCall::DialEmergency

// creates emergency dial request to the CPECallCommand object

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

//

void CPESingleCall::DialEmergency(

        const TPEPhoneNumber& aEmergencyNumber )

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::DialEmergency" );

    iCall->DialEmergencyCall( aEmergencyNumber );

    }

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

// CPESingleCall::DisableFDNCheck

// Disables FDN checking for SIM ATK originated calls

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

//

void CPESingleCall::DisableFDNCheck()

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::DisableFDNCheck UNSUPPORTED" );

    // NOTE! Currently disabled due to incomplete TSY implementation

    // Remove comments after this task is completed

    //iCall->NoFDNCheck();

    }

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

// CPESingleCall::Hold

// creates hold request to the CPECallCommand object

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

//

TInt CPESingleCall::Hold()

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Hold" );

    return iCall->Hold();

    }

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

// CPESingleCall::Resume

// Method resumes held call

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

//

TInt CPESingleCall::Resume()

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Resume" );

    return iCall->Resume();

    }

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

// CPESingleCall::Swap

// Method swaps active and held call

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

//

TInt CPESingleCall::Swap()

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Swap" );

    return iCall->Swap();

    }

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

// CPESingleCall::Transfer

// Method Transfers the active and the held call.

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

//

void CPESingleCall::Transfer( const TDesC& aTransferTarget )

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Transfer" );

    iCall->AttendedTransfer( aTransferTarget );

    }

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

// CPESingleCall::Tone

// Returns the inband tone needed to play in state transition

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

//

TCCPTone CPESingleCall::Tone()

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Tone" );

    return iCall->Tone();

    }

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

// CPESingleCall::HangUp

// 

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

//

TInt CPESingleCall::HangUp()

    {

    TEFLOGSTRING( KTAREQOUT, "CALL CPESingleCall::HangUp" );

    SetMissedCall( EFalse );

    return iCall->HangUp();

    }

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

// CPESingleCall::GetCallInfo

// Method returns call information.

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

//

TInt CPESingleCall::GetCallInfo(

        RMobileCall::TMobileCallInfoV3& aCallInfo )

    {

    TEFLOGSTRING( KTAREQOUT, 

            "CALL CPESingleCall::GetCallInfo > RMobileCall::GetMobileCallInfo()" );

    RMobileCall::TMobileCallInfoV3Pckg callInfoPckg( iCallInfo );

    Call().GetMobileCallInfo( callInfoPckg );

    iCallInfo = callInfoPckg();

    aCallInfo = iCallInfo;

    return KErrNone;

    }

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

// CPESingleCall::SetMissedCall

// Set the missed call indicator = ETrue, if the current call

// was hanged up on state ringing by remote party.

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

//

void CPESingleCall::SetMissedCall( TBool aMissed )

    {

    TEFLOGSTRING2( KTAINT, "CALL CPESingleCall::SetMissedCall: Call Missed. %d", aMissed );

    iMissedCall = aMissed; 

    }

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

// CPESingleCall::GetMissedCall

// Returns the missed data call indicator.

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

//

TInt CPESingleCall::GetMissedCall(

        TBool& aMissedCall) const

    {

    aMissedCall = iMissedCall;

    return KErrNone;

    }

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

// CPESingleCall::IsSecureCall

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

//

TBool CPESingleCall::IsSecureCall() const

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::IsSecureCall" );

    return iCall->IsSecured();

    }

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

// CPESingleCall::SecureSpecified

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

//

TBool CPESingleCall::SecureSpecified() const

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::SecureSpecified" );

    return iCall->SecureSpecified(); 

    }

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

// CPESingleCall::AcceptUnattendedTransfer

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

//

TInt CPESingleCall::AcceptUnattendedTransfer()

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::AcceptUnattendedTransfer" );

    return iCall->AcceptTransfer( ETrue );

    }

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

// CPESingleCall::RejectUnattendedTransfer

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

//

TInt CPESingleCall::RejectUnattendedTransfer()

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::RejectUnattendedTransfer" );

    return iCall->AcceptTransfer( EFalse );

    }

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

// CPESingleCall::UnattendedTransfer

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

//

TInt CPESingleCall::UnattendedTransfer( const TDesC& aTransferTo ) const

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::UnattendedTransfer" );

    return iCall->UnattendedTransfer( aTransferTo );

    }

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

// CPESingleCall::ForwardCallToAddress

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

//

TInt CPESingleCall::ForwardCallToAddress( TInt aIndex )

    {

    TEFLOGSTRING( KTAINT, "CALL CPESingleCall::ForwardToAddress" );

    TRAPD( err, iCall->ForwardToAddressL( aIndex ) );

    return err;

    }

// End of File