/*

* Copyright (c) 2002-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 module contains the implementation of CPEEngineInfoImpl class 

*

*/

// INCLUDE FILES

#include "cpecallinfo.h"

#include "cpeclientinformation.h"

#include "cpeengineinfoimpl.h"

#include <pepanic.pan>

#include <telinternalpskeys.h>

#include <cphcltdialdata.h>

#include <talogger.h>

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

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

// CPEEngineInfoImpl::CPEEngineInfoImpl

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

// might leave.

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

//

CPEEngineInfoImpl::CPEEngineInfoImpl()

    : iCurrentCalls( KPEMaximumNumberOfCalls )

    {

    iCallCommandInfo.iPhoneNumber = KNullDesC;

    iCallCommandInfo.iCallId = 0;

    iCallCommandInfo.iKeyCode = 0;

    iCallCommandInfo.iAudioVolume = KPENumberInitValue;

    iCallCommandInfo.iAudioMute = EFalse;

    iCallCommandInfo.iDtmfString = KNullDesC;

    iCallCommandInfo.iCallType = EPECallTypeUninitialized;

    iCallCommandInfo.iServiceId = 0;

    iBasicInfo.iAudioOutputPreference = EPSAudioPrivate;

    iBasicInfo.iALSLine = CCCECallParameters::ECCELineTypePrimary;

    iBasicInfo.iALSLineSupport = EFalse;

    iBasicInfo.iPhoneAudioRouteParameters.iAudioOutput = EPENotActive;

    iBasicInfo.iAudioVolume = KPEDefaultAudioVolume;

    iBasicInfo.iKeypadVolume = KPENumberInitValue;

    iBasicInfo.iAudioMute = EFalse;

    iBasicInfo.iDtmfString = KNullDesC;

    iBasicInfo.iErrorInfo.iErrorCode = ECCPErrorNone;

    iBasicInfo.iErrorInfo.iCallId = KPECallIdNotUsed;

    iBasicInfo.iProfileId = ECCPErrorNotFound;

    iBasicInfo.iProfileName = KNullDesC;

    iBasicInfo.iPhoneIdentityParameters.iManufacturer = KNullDesC;

    iBasicInfo.iPhoneIdentityParameters.iModel = KNullDesC;

    iBasicInfo.iPhoneIdentityParameters.iRevision = KNullDesC;

    iBasicInfo.iPhoneIdentityParameters.iSerialNumber = KNullDesC;

    iBasicInfo.iLastCallDuration = KPENumberInitValue;

    iBasicInfo.iVMBXNumbers.iVMBXL1 = KNullDesC;

    iBasicInfo.iVMBXNumbers.iVMBXL2 = KNullDesC;

    iBasicInfo.iRingingType = EProfileRingingTypeRinging;

    iBasicInfo.iTextToSpeech = EFalse;

    iBasicInfo.iPhoneNumberIsServiceCode = EFalse;

    iBasicInfo.iTwoDigitSupportStatus = EFalse;

    iBasicInfo.iLifeTimeData.iHours = 0;

    iBasicInfo.iLifeTimeData.iMinutes = 0;

    iBasicInfo.iNetworkRegistrationStatus = ENWStatusRegistrationUnknown;

    iCallCommandInfo.iIdRestrict = RMobileCall::EIdRestrictDefault;

    iCallCommandInfo.iEmergencyNumber = KNullDesC;

    iCallCommandInfo.iTransferToAddress = KNullDesC;

    iCallCommandInfo.iForwardToAddressIndex = ECCPErrorNotFound;

    iBasicInfo.iActiveForward.iActiveType = RMobilePhone::ECFUnconditionalActive;

    iBasicInfo.iActiveForward.iServiceGroup =  RMobilePhone::EServiceUnspecified;

    iBasicInfo.iBarringInfo.iGroupCount = KPENumberInitValue;

    for( TInt i = 0; i < KPEMaxServiceGroup; i++ )

        {

        __ASSERT_DEBUG( 

            iBasicInfo.iBarringInfo.iBarredInfo.Count() > i, 

            Panic( EPEPanicIndexOutOfRange ) );

        iBasicInfo.iBarringInfo.iBarredInfo[i].iCondition = RMobilePhone::EBarUnspecified;

        iBasicInfo.iBarringInfo.iBarredInfo[i].iServiceGroup = 

            RMobilePhone::EServiceUnspecified;

        iBasicInfo.iBarringInfo.iBarredInfo[i].iStatus = 

            RMobilePhone::ECallBarringStatusUnknown;

        }

    iBasicInfo.iSSCommandInfo.action = EPESSActionUnspecified;

    iBasicInfo.iSSCommandInfo.type = EPESSTypeUnspecified;

    iBasicInfo.iSSCommandInfo.group = RMobilePhone::EServiceUnspecified;

    iBasicInfo.iSimState = EPESimStatusUninitialized;

    iBasicInfo.iSecureSpecified = ETrue; 

    iBasicInfo.iDataPortName = KNullDesC;

    iBasicInfo.iSwitchToOngoing = EFalse;

    iConferenceCallInfo.iConferenceCallState = EPEStateConferenceIdle;

    }

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

// CPEEngineInfoImpl::NewL

// Two-phased constructor.

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

//

CPEEngineInfoImpl* CPEEngineInfoImpl::NewL()

    {

    CPEEngineInfoImpl* self = new ( ELeave ) CPEEngineInfoImpl;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPEEngineInfoImpl::ConstructL

// Initializes class member variables

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

//

void CPEEngineInfoImpl::ConstructL()

    {

    iCallParams = CCCECallParameters::NewL();

    iRemoteInfo = new ( ELeave ) RPointerArray<CPERemoteInfo>( KPEMaximumNumberOfCalls );

    for ( TInt i = 0; i < KPEMaximumNumberOfCalls; i++ )

        {

        TEFLOGSTRING( KTAOBJECT, "CPEEngineInfoImpl::ConstructL" );

        CPERemoteInfo* remoteInfo = CPERemoteInfo::NewL();

        CleanupStack::PushL( remoteInfo );

        // associate this remote info instance with a call id

        remoteInfo->SetCallId( i );

        iRemoteInfo->InsertL( remoteInfo, i );

        CleanupStack::Pop( remoteInfo );

        CPECallInfo* callInfo = CPECallInfo::NewL();

        CleanupStack::PushL( callInfo );

        iCurrentCalls.AppendL( callInfo );

        CleanupStack::Pop( callInfo );

        }

    for( TInt i = 0 ; i < KPEMaximumNumberOfCalls ; i++ ) 

        {

        ResetCallInfo( i );    // Resets every call.

        }

    }

// Destructor

CPEEngineInfoImpl::~CPEEngineInfoImpl()

    {

    if ( iRemoteInfo )

        {

        iRemoteInfo->ResetAndDestroy();

        iRemoteInfo->Close();

        delete iRemoteInfo;

        iRemoteInfo = NULL;

        }

    delete iCallParams;

    iCurrentCalls.ResetAndDestroy();

    iCurrentCalls.Close();

    }

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

// CPEEngineInfoImpl::AlertForGroup

// Gets group ids  from the TPEBasicInfo structure.

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

//

const TArray< TContactItemId > CPEEngineInfoImpl::AlertForGroup() const

    {

    return iAlertForGroup.Array();

    }

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

// CPEEngineInfoImpl::ALSLine

// Gets active als line of the phone.

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

//

const CCCECallParameters::TCCELineType& CPEEngineInfoImpl::ALSLine() const

    {

    return iBasicInfo.iALSLine;

    }    

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

// CPEEngineInfoImpl::ALSLine

// Gets active als line of the phone.

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

//

const TBool& CPEEngineInfoImpl::ALSLineSupport() const

    {

    TEFLOGSTRING2( KTAMESIN,"CPEEngineInfoImpl::ALSLineSupport(),iALSLineSupport: %d"

        , iBasicInfo.iALSLineSupport );

    return iBasicInfo.iALSLineSupport;

    }  

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

// CPEEngineInfoImpl::AudioMute

// Gets audio mute value from the TPEBasicInfo structure.

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

//

const TBool& CPEEngineInfoImpl::AudioMute() const

    {

    return iBasicInfo.iAudioMute;

    }

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

// CPEEngineInfoImpl::AudioOutput

// Gets audio output value from the TPEBasicInfo structure.

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

//

const TPEAudioOutput& CPEEngineInfoImpl::AudioOutput() const

    {

    TEFLOGSTRING2( KTAINT, 

        "PE CPEEngineInfoImpl::AudioOutput: iBasicInfo.iAudioOutput: %d", 

        iBasicInfo.iPhoneAudioRouteParameters.iAudioOutput );

    return iBasicInfo.iPhoneAudioRouteParameters.iAudioOutput;

    }

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

// CPEEngineInfoImpl::PhoneIdentityParameters

// Gets the phone identity parameters from the TPEBasicInfo structure

// (other items were commented in a header).

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

//

const TPEPhoneAudioRouteParameters& CPEEngineInfoImpl::RouteParameters() const

    {

    return iBasicInfo.iPhoneAudioRouteParameters;

    }

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

// CPEEngineInfoImpl::AudioOutputAvailable

// Gets audio output path availability status from array

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

//

TBool CPEEngineInfoImpl::AudioOutputAvailable( 

        const TPEAudioOutput aOutput ) const 

    {

    __ASSERT_ALWAYS( ( EPENotActive <= aOutput && 

        aOutput <= EPETTY ), Panic( EPEPanicInvalidParameter ) );

    TBool available( EFalse );

    // find given output from the available outputs array

    for (TInt i = 0; i < iAvailableAudioOutputs.Count(); i++)

        {

        if ( iAvailableAudioOutputs[i] == aOutput )

            {

            available = ETrue;

            }

        }

    return available;

    }

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

// CPEEngineInfoImpl::AudioMuteCommand

// Gets audio mute command value from the TPECallCommandInfo structure.

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

//

const TBool& CPEEngineInfoImpl::AudioMuteCommand() const

    {

    return iCallCommandInfo.iAudioMute;

    }

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

// CPEEngineInfoImpl::AudioOutputCommand

// Gets audio output command value from the TPECallCommandInfo structure.

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

//

const TPEAudioOutput& CPEEngineInfoImpl::AudioOutputCommand() const

    {

    return iCallCommandInfo.iAudioOutput;

    }

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

// CPEEngineInfoImpl::ShowNoteCommand

// Gets audio note command value from the TPECallCommandInfo structure.

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

//

TBool CPEEngineInfoImpl::ShowNoteCommand() const

    {

    return iCallCommandInfo.iShowNote;

    }

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

// CPEEngineInfoImpl::AudioOutputPreference

// Gets audio output preference value from the TPEBasicInfo structure.

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

//

const TInt& CPEEngineInfoImpl::AudioOutputPreference() const

    {

    return iBasicInfo.iAudioOutputPreference;

    }

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

// CPEEngineInfoImpl::AudioVolume

// Gets audio volume value from the TPEBasicInfo structure.

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

//

const TInt& CPEEngineInfoImpl::AudioVolume() const

    {

    TEFLOGSTRING2( KTAINT, 

        "PE CPEEngineInfoImpl::AudioVolume, volume: %d", iBasicInfo.iAudioVolume );

    return iBasicInfo.iAudioVolume;

    }

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

// CPEEngineInfoImpl::AudioVolumeCommand

// Gets audio volume command value from the TPECallCommandInfo structure.

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

//

const TInt& CPEEngineInfoImpl::AudioVolumeCommand() const

    {

    TEFLOGSTRING2( KTAINT, 

        "PE CPEEngineInfoImpl::AudioVolumeCommand, volume: %d", 

        iCallCommandInfo.iAudioVolume );

    return iCallCommandInfo.iAudioVolume;

    } 

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

// CPEEngineInfoImpl::CallClientInformation

// Gets phone client information from the TPECallInfo structure.

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

//

const MPEClientInformation& CPEEngineInfoImpl::CallClientInformation(

        const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->ClientInformation();

    }

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

// CPEEngineInfoImpl::CallDirection

// Gets the call direction.

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

//

RMobileCall::TMobileCallDirection CPEEngineInfoImpl::CallDirection( 

        const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->CallDirection();

    }

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

// CPEEngineInfoImpl::CallDuration

// Gets the duration of the last call to idle.

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

//

const TInt& CPEEngineInfoImpl::CallDuration() const

    {

    return iBasicInfo.iLastCallDuration;

    }

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

// CPEEngineInfoImpl::CallDuration

// Gets the duration of the call.

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

//

TTimeIntervalSeconds CPEEngineInfoImpl::CallDuration(

        const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->Duration();

    }

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

// CPEEngineInfoImpl::CallId

// Gets the identification number of the call from the TPECallCommandInfo structure. 

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

//

const TInt& CPEEngineInfoImpl::CallId() const

    {

    return iCallCommandInfo.iCallId;

    }

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

// CPEEngineInfoImpl::CallALSLine

// Gets als line value from the TPECallInfo structure.

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

//

CCCECallParameters::TCCELineType CPEEngineInfoImpl::CallALSLine( 

        const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->AlsLine();

    }

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

// CPEEngineInfoImpl::CallStartTime

// Gets the start time of the call.

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

//

const TTime& CPEEngineInfoImpl::CallStartTime(

        const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->StartTime();

    }

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

// CPEEngineInfoImpl::CallState

// Gets the state of the call.

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

//

TPEState CPEEngineInfoImpl::CallState( 

        const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->CallState();

    }

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

// CPEEngineInfoImpl::CallType

// Gets the type of the call.

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

//

TPECallType CPEEngineInfoImpl::CallType(

        const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->CallType();

    }

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

// CPEEngineInfoImpl::CallTypeCommand

// Gets call type information for the attempted call

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

//

const TPECallType& CPEEngineInfoImpl::CallTypeCommand() const

    {

    return iCallCommandInfo.iCallType;

    }

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

// CPEEngineInfoImpl::ConferenceCallState

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

//

TPEState CPEEngineInfoImpl::ConferenceCallState() const

    {

    return iConferenceCallInfo.iConferenceCallState;

    }

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

// CPEEngineInfoImpl::IsSecureCall

// Gets secured status from call info

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

//

TBool CPEEngineInfoImpl::IsSecureCall( const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    TInt isSecured = EFalse; 

    // Conference call secure status

    if ( KPEConferenceCallID == aCallId )

        {

        TInt count = iCurrentCalls.Count();

        for ( TInt i = 0; i < count; i++ )

            {

            if ( iCurrentCalls[ i ]->ConferenceMemberId() != KPECallIdNotUsed )

            {

                if ( iCurrentCalls[ i ]->SecureStatus() )

                    {

                    isSecured = ETrue;

                    }

                else

                    {

                    isSecured = EFalse;

                    break;

                    }

                }

            }

        }

    else

        {

        isSecured = iCurrentCalls[ aCallId ]->SecureStatus();

        }

    return isSecured;

    }

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

// CPEEngineInfoImpl::DataPortName

// Gets the name of data port currently on-loan.

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

//

const TName& CPEEngineInfoImpl::DataPortName() const

    {

    return iBasicInfo.iDataPortName;

    }

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

// CPEEngineInfoImpl::DtmfPostFix

// Gets dtmf postfix value from the TPEBasicInfo structure.

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

//

const TPEDtmfString& CPEEngineInfoImpl::DtmfPostFix( const TInt aCallId ) const

    {

    __ASSERT_DEBUG( iCurrentCalls.Count() > aCallId, Panic( EPEPanicCallIndexOutOfRange ) );

    return iCurrentCalls[ aCallId ]->DtmfPostFix();

    }

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

// CPEEngineInfoImpl::DtmfString

// Gets dtmf string value from the TPEBasicInfo structure.

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

//

const TPEDtmfString& CPEEngineInfoImpl::DtmfString() const

    {

    return iBasicInfo.iDtmfString;

    }

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

// CPEEngineInfoImpl::DtmfStringCommand

// Gets dtmf string command value from TPECallCommandInfo-structure

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