/*

* Copyright (c) 2004-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 CPEPhoneModel class 

                 member functions.

*

*/

//  INCLUDE FILES

#include "cpeactivestarter.h"

#include "cpeexternaldatahandler.h"

#include "cpeidlestatusmonitor.h"

#include "cpemessagehandler.h"

#include "cpephonemodel.h"

#include "cpeservicehandling.h"

#include "cpesimstatemonitor.h"

#include "pepanic.pan"

#include "cperemotepartyinfomediator.h"

#include <ccce.h>

#include <cpeaudiodata.h>

#include <cpecallhandling.h>                   

#include <cpecontacthandlingproxy.h>

#include <cpeengineinfo.h>

#include <cpegsmaudiodata.h>

#include <cpeloghandlingproxy.h>

#include <featmgr.h>

#include <mccedtmfinterface.h>

#include <mpecontacthandling.h>

#include <mpeloghandling.h>

#include "phoneservices.h"

#include "parserrecognizer.h"

// CONSTANTS

const TInt KDriveProfile ( 6 );

const TInt KPECallTimerOff = 0;

// ==================== LOCAL FUNCTIONS ====================

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

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

// CPEPhoneModel::CPEPhoneModel

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

// might leave.

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

//

CPEPhoneModel::CPEPhoneModel(

        MEngineMonitor& aEngineMonitor      // The reference parameter for phone application communication

        ) : CPEPhoneModelIF(),

            iEngineMonitor( aEngineMonitor ),

            iStep( 0 )

    {

    }

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

// CPEPhoneModel::CPEPhoneModel

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

// might leave.

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

//

CPEPhoneModel::CPEPhoneModel(

        MEngineMonitor& aEngineMonitor ,     // The reference parameter for phone application communication

        CPEAudioFactory& aAudioFactory

        ) : CPEPhoneModelIF(),

            iEngineMonitor( aEngineMonitor ),

            iStep( 0 ),

            iAudioFactory( &aAudioFactory )

    {

    }

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

// CPEPhoneModel::ConstructL

// EPOC default constructor can leave.

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

//

void CPEPhoneModel::ConstructL()

    {

    TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 1" );

    iEngineInfo = CPEEngineInfo::NewL();

    TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 2" );

    User::LeaveIfError( iFsSession.Connect() );

    TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 3" );

    FeatureManager::InitializeLibL();

    TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 4" );

    iActiveStarter = CPEActiveStarter::NewL( this );

    TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 5" );

    iActiveStarter->StartUp();

    TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 6" );

    }// ConstructL

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

// CPEPhoneModel::NewL

// Two-phased constructor.

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

//

CPEPhoneModel* CPEPhoneModel::NewL(

        MEngineMonitor& aEngineMonitor   //for phone application communication

        )

    {

    CPEPhoneModel* self = new ( ELeave ) CPEPhoneModel( aEngineMonitor );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }// NewL

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

// CPEPhoneModel::NewL

// Two-phased constructor for module testing.

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

//

CPEPhoneModel* CPEPhoneModel::NewL( 

    MEngineMonitor& aEngineMonitor,

    CPEAudioFactory& aAudioFactory )

    {

    CPEPhoneModel* self = 

        new ( ELeave ) CPEPhoneModel( aEngineMonitor, aAudioFactory );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CPEPhoneModel::~CPEPhoneModel()

    {   

    delete iMediatorCommunicationHandler;

    delete iSimChangedMonitor;

    delete iMessageHandler;

    delete iServiceHandling;

    delete iSimStatusMonitor;

    delete iContactHandling;

    delete iLogHandling;

    delete iAudioData;

    delete iCallHandling;

    delete iExternalDataHandler;

    delete iCallStackCutter;

    if ( iActiveStarter )

        {

        delete iActiveStarter;

        }

    FeatureManager::UnInitializeLib();

    iFsSession.Close();

    delete iEngineInfo;

    delete iConvergedCallEngine;

    if ( iIdleStatusMonitor )

        {

        delete iIdleStatusMonitor;

        } 

    delete iPhoneServices;

    delete iParserRecognizer;

    }// ~CPEPhoneModel

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

// CPEPhoneModel::EngineInfo

// Returns the pointer of the CPEEngineInfo object.

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

//

MPEEngineInfo* CPEPhoneModel::EngineInfo()

    {

    return iEngineInfo;

    }

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

// Returns the pointer of the CPEEngineInfo object.

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

//

MPEDataStore* CPEPhoneModel::DataStore()

    {

    return iEngineInfo;

    }    

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

// CPEPhoneModel::DataStoreExt

// Returns the pointer to CPEExternalDataHandler object

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

//

MPEExternalDataHandler* CPEPhoneModel::DataStoreExt()

    {

    return iExternalDataHandler;

    }

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

// CPEPhoneModel::MediatorCommandHandler

// Returns the pointer to CPERemotePartyInfoMediator object

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

//

CPERemotePartyInfoMediator* CPEPhoneModel::MediatorCommunicationHandler()

    {

    return iMediatorCommunicationHandler;

    }

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

// CPEPhoneModel::NameByMessageToPhoneEngine

// Return message name, given the id of message.

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

//

#ifdef TEF_LOGGING_ENABLED

TPtrC CPEPhoneModel::NameByMessageToPhoneEngine(

        const MPEPhoneModel::TPEMessagesToPhoneEngine aMessage

        ) const

    {

    switch ( aMessage )

        {

        // Audio messages                     1000 - 1999

        case MPEPhoneModel::EPEMessageSetAudioMute:

            return MESSAGE("EPEMessageSetAudioMute");

        case MPEPhoneModel::EPEMessageSetAudioVolume:

            return MESSAGE("EPEMessageSetAudioVolume");

        case MPEPhoneModel::EPEMessageSetAudioOutput:

            return MESSAGE("EPEMessageSetAudioOutput");

        // Call messages                      2000 - 2999

        case MPEPhoneModel::EPEMessageAnswer:

            return MESSAGE("EPEMessageAnswer");

        case MPEPhoneModel::EPEMessageClientDial:

            return MESSAGE("EPEMessageClientDial");

        case MPEPhoneModel::EPEMessageClientDialEmergency:

            return MESSAGE("EPEMessageClientDialEmergency");

        case MPEPhoneModel::EPEMessageDialServiceCall:

            return MESSAGE("EPEMessageDialServiceCall");

        case MPEPhoneModel::EPEMessageContinueEmergencyCallInitialization:

            return MESSAGE("EPEMessageContinueEmergencyCallInitialization");

        case MPEPhoneModel::EPEMessageContinueDTMFSending:

            return MESSAGE("EPEMessageContinueDTMFSending");

        case MPEPhoneModel::EPEMessageDial:

            return MESSAGE("EPEMessageDial");

        case MPEPhoneModel::EPEMessagePlayDTMF:

            return MESSAGE("EPEMessagePlayDTMF");

        case MPEPhoneModel::EPEMessageEndDTMF:

            return MESSAGE("EPEMessageEndDTMF");

        case MPEPhoneModel::EPEMessagePhoneNumberEdited:

            return MESSAGE("EPEMessagePhoneNumberEdited");

        case MPEPhoneModel::EPEMessageRelease:

            return MESSAGE("EPEMessageRelease");

        case MPEPhoneModel::EPEMessageReleaseAll:

            return MESSAGE("EPEMessageReleaseAll");

        case MPEPhoneModel::EPEMessageReject:

            return MESSAGE("EPEMessageReject");

        case MPEPhoneModel::EPEMessageSendDTMF:

            return MESSAGE("EPEMessageSendDTMF");

        case MPEPhoneModel::EPEMessageStopDTMFSending:

            return MESSAGE("EPEMessageStopDTMFSending");

        case MPEPhoneModel::EPEMessageStopTonePlay:

            return MESSAGE("EPEMessageStopTonePlay");

        case MPEPhoneModel::EPEMessageAutomaticAnswerOff:

            return MESSAGE("EPEMessageAutomaticAnswerOff");

        case MPEPhoneModel::EPEMessageTerminateAllConnections:

            return MESSAGE("EPEMessageTerminateAllConnections");

        case MPEPhoneModel::EPEMessageSatCallRequestCompleted:

            return MESSAGE("EPEMessageSatCallRequestCompleted");

        case MPEPhoneModel::EPEMessageAcceptUnattendedTransfer:

            return MESSAGE("EPEMessageAcceptUnattendedTransfer");

        case MPEPhoneModel::EPEMessageRejectUnattendedTransfer:

            return MESSAGE("EPEMessageRejectUnattendedTransfer");

        case MPEPhoneModel::EPEMessageDoUnattendedTransfer:

            return MESSAGE("EPEMessageDoUnattendedTransfer");

        case MPEPhoneModel::EPEMessageForwardCallToAddress:

            return MESSAGE("EPEMessageForwardCallToAddress");

        // Contact messages                   3000 - 3999

        // Error messages                     4000 - 4999

        // Network messages                   5000 - 5999

        // Parser messages                    6000 - 6999

        // Security messages                  7000 - 7999

        // Settings and Shared Data messages  8000 - 8999

        // Service messages                   8000 - 8999

        case MPEPhoneModel::EPEMessageDisableService:

            return MESSAGE("EPEMessageDisableService");

        // Startup messages                   9000 - 9999

        case MPEPhoneModel::EPEMessagePEConstructionReady:

            return MESSAGE("EPEMessagePEConstructionReady");

        // Miscellaneous messages             10000 - 10999

        case MPEPhoneModel::EPEMessageCheckEmergencyNumber:

            return MESSAGE("EPEMessageCheckEmergencyNumber");

        // Variant messages                   11000 - 12999

        // Audio messages                         11000 - 11199

        // Call messages                          11200 - 11399

        case CPEPhoneModelIF::EPEMessageAddConferenceMember:

            return MESSAGE("EPEMessageAddConferenceMember");

        case CPEPhoneModelIF::EPEMessageCreateConference:

            return MESSAGE("EPEMessageCreateConference");

        case CPEPhoneModelIF::EPEMessageDropConferenceMember:

            return MESSAGE("EPEMessageDropConferenceMember");

        case CPEPhoneModelIF::EPEMessageGoOneToOne:

            return MESSAGE("EPEMessageGoOneToOne");

        case CPEPhoneModelIF::EPEMessageHangUpConference:

            return MESSAGE("EPEMessageHangUpConference");

        case CPEPhoneModelIF::EPEMessageHold:

            return MESSAGE("EPEMessageHold");

        case CPEPhoneModelIF::EPEMessageHoldConference:

            return MESSAGE("EPEMessageHoldConference");

        case CPEPhoneModelIF::EPEMessageResume:

            return MESSAGE("EPEMessageResume");

        case CPEPhoneModelIF::EPEMessageResumeConference:

            return MESSAGE("EPEMessageResumeConference");

        case CPEPhoneModelIF::EPEMessageSwap:

            return MESSAGE("EPEMessageSwap");

        case CPEPhoneModelIF::EPEMessageSwapConference:

            return MESSAGE("EPEMessageSwapConference");

        case CPEPhoneModelIF::EPEMessageTransfer:

            return MESSAGE("EPEMessageTransfer");

        case CPEPhoneModelIF::EPEMessageSwitchToVideoOrVoice:

            return MESSAGE("EPEMessageSwitchToVideoOrVoice");   

        // Contact messages                       11400 - 11599

        // Error messages                         11600 - 11799

        // Network messages                       11800 - 12999

        // Parser messages                        12000 - 12199

        case CPEPhoneModelIF::EPEMessageCancelSSstringCommand:

            return MESSAGE("EPEMessageCancelSSstringCommand");

        // Security messages                      12200 - 12399

        // Settings and Shared Data messages      12400 - 12599

        // Miscellaneous messages                 12600 - 12799

        default:

            TEFLOGSTRING2( KTAINT, "pe:cpephonemodel::namebymessagetophoneengine, unknown message = %d", static_cast<TInt>(aMessage));

            return MESSAGE("Unknown message");

        } 

    }

#else

TPtrC CPEPhoneModel::NameByMessageToPhoneEngine(

        const TInt /*aMessage*/ ) const

    {

    return MESSAGE("Not available");

    }

#endif // TEF_LOGGING_ENABLED

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

// CPEPhoneModel::NameByMessageFromPhoneEngine

// Return message name, given the id of message.

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

//

#ifdef TEF_LOGGING_ENABLED

TPtrC CPEPhoneModel::NameByMessageFromPhoneEngine(

        const TInt aMessage ) const

    {

    switch ( aMessage )

        {

        // Audio messages                     1000 - 1999

        case MEngineMonitor::EPEMessageAudioDtmfEvent:

            return MESSAGE("EPEMessageAudioDtmfEvent");

        case MEngineMonitor::EPEMessageAudioDTMFPlayComplete:

            return MESSAGE("EPEMessageAudioDTMFPlayComplete");

        case MEngineMonitor::EPEMessageAudioOutputPreferenceChanged:

            return MESSAGE("EPEMessageAudioOutputPreferenceChanged");

        case MEngineMonitor::EPEMessageAudioMuteChanged:

            return MESSAGE("EPEMessageAudioMuteChanged");

        case MEngineMonitor::EPEMessageAudioOutputChanged:

            return MESSAGE("EPEMessageAudioOutputChanged");

        case MEngineMonitor::EPEMessageAvailableAudioOutputsChanged:

            return MESSAGE("EPEMessageAvailableAudioOutputsChanged");

        case MEngineMonitor::EPEMessageAudioPlayStopped:

            return MESSAGE("EPEMessageAudioPlayStopped");

        case MEngineMonitor::EPEMessageAudioVolumeChanged:

            return MESSAGE("EPEMessageAudioVolumeChanged");

        // Call messages                      2000 - 2999

        case MEngineMonitor::EPEMessageAnswer:

            return MESSAGE("EPEMessageAnswer");

        case MEngineMonitor::EPEMessageAnswering:

            return MESSAGE("EPEMessageAnswering");

        case MEngineMonitor::EPEMessageCallControlCapsChanged:

            return MESSAGE("EPEMessageCallControlCapsChanged");

        case MEngineMonitor::EPEMessageCallWaiting:

            return MESSAGE("EPEMessageCallWaiting");

        case MEngineMonitor::EPEMessageCallWaitingAnswered:

            return MESSAGE("EPEMessageCallWaitingAnswered");

        case MEngineMonitor::EPEMessageChangedCallDuration:

            return MESSAGE("EPEMessageChangedCallDuration");

        case MEngineMonitor::EPEMessageConferenceIdle:

            return MESSAGE("EPEMessageConferenceIdle");

        case MEngineMonitor::EPEMessageConferenceCapsChange:

            return MESSAGE("EPEMessageConferenceCapsChange");

        case MEngineMonitor::EPEMessageConnected:

            return MESSAGE("EPEMessageConnected");

        case MEngineMonitor::EPEMessageConnectedConference:

            return MESSAGE("EPEMessageConnectedConference");

        case MEngineMonitor::EPEMessageConnecting:

            return MESSAGE("EPEMessageConnecting");

        case MEngineMonitor::EPEMessageDialing:

            return MESSAGE("EPEMessageDialing");

        case MEngineMonitor::EPEMessageDialingError:

            return MESSAGE("EPEMessageDialingError");

        case MEngineMonitor::EPEMessageDisconnecting:

            return MESSAGE("EPEMessageDisconnecting");

        case MEngineMonitor::EPEMessageDisconnectingConference:

            return MESSAGE("EPEMessageDisconnectingConference");

        case MEngineMonitor::EPEMessageDTMFSendingAborted:

            return MESSAGE("EPEMessageDTMFSendingAborted");

        case MEngineMonitor::EPEMessageHeld:

            return MESSAGE("EPEMessageHeld");

        case MEngineMonitor::EPEMessageHeldConference:

            return MESSAGE("EPEMessageHeldConference");

        case MEngineMonitor::EPEMessageIdle:

            return MESSAGE("EPEMessageIdle");

        case MEngineMonitor::EPEMessageIncoming:

            return MESSAGE("EPEMessageIncoming");

        case MEngineMonitor::EPEMessageInitiatedEmergencyCall:

            return MESSAGE("EPEMessageInitiatedEmergencyCall");

        case MEngineMonitor::EPEMessageInitiatedEmergencyWhileActiveVideo:

            return MESSAGE("EPEMessageInitiatedEmergencyWhileActiveVideo");

        case MEngineMonitor::EPEMessagePacketNetworkDetached:

            return MESSAGE("EPEMessagePacketNetworkDetached");

        case MEngineMonitor::EPEMessageRemoteBusy:

            return MESSAGE("EPEMessageRemoteBusy");            

        case MEngineMonitor::EPEMessageSendingDTMF:

            return MESSAGE("EPEMessageSendingDTMF");

        case MEngineMonitor::EPEMessageSentDTMF:

            return MESSAGE("EPEMessageSentDTMF");

        case MEngineMonitor::EPEMessageSentSSString:

            return MESSAGE("EPEMessageSentSSString");

        case MEngineMonitor::EPEMessageStoppedDTMF:

            return MESSAGE("EPEMessageStoppedDTMF");

        case MEngineMonitor::EPEMessageSwapped:

            return MESSAGE("EPEMessageSwapped");

        case MEngineMonitor::EPEMessageTransferDone:

            return MESSAGE("EPEMessageTransferDone");

        case MEngineMonitor::EPEMessageWentOneToOne:

            return MESSAGE("EPEMessageWentOneToOne");

        case MEngineMonitor::EPEMessageDisconnectingWithInband:

            return MESSAGE("EPEMessageDisconnectingWithInband");

        case MEngineMonitor::EPEMessageContinuingDTMFSending:

            return MESSAGE("EPEMessageContinuingDTMFSending");

        case MEngineMonitor::EPEMessageCallAdded:

            return MESSAGE("EPEMessageCallAdded");

        case MEngineMonitor::EPEMessageRemoteTerminated:

            return MESSAGE("EPEMessageRemoteTerminated");

        case MEngineMonitor::EPEMessageShowIMEI:

            return MESSAGE("EPEMessageShowIMEI");

        case MEngineMonitor::EPEMessageUnknown:

            return MESSAGE("EPEMessageUnknown");

        case MEngineMonitor::EPEMessagePromptSpeedDial:

            return MESSAGE("EPEMessagePromptSpeedDial");

        case MEngineMonitor::EPEMessageSpeedDialNotAssigned:

            return MESSAGE("EPEMessageSpeedDialNotAssigned");

        case MEngineMonitor::EPEMessageInvalidSpeedDial:

            return MESSAGE("EPEMessageInvalidSpeedDial"); 

        case MEngineMonitor::EPEMessageDataPortLoaned:

            return MESSAGE("EPEMessageDataPortLoaned");

        case MEngineMonitor::EPEMessageUnattendedTransferRequest:

            return MESSAGE("EPEMessageUnattendedTransferRequest");

        case MEngineMonitor::EPEMessageRemoteForwarding:

            return MESSAGE("EPEMessageRemoteForwarding");

        case MEngineMonitor::EPEMessageMovedPermanently:

            return MESSAGE("EPEMessageMovedPermanently");

        case MEngineMonitor::EPEMessageMultipleChoices:

            return MESSAGE("EPEMessageMultipleChoices");

        case MEngineMonitor::EPEMessageRemotePartyInfoChanged:

            return MESSAGE("EPEMessageRemotePartyInfoChanged");

        case MEngineMonitor::EPEMessageConnectingWithInband:

            return MESSAGE("EPEMessageConnectingWithInband");

        // Contact messages                   3000 - 3999

        case MEngineMonitor::EPEMessageThumbnailLoadingCompleted:

            return MESSAGE("EPEMessageThumbnailLoadingCompleted");

        // Error messages                     4000 - 4999

        case MEngineMonitor::EPEMessageError:

            return MESSAGE("EPEMessageError");

        case MEngineMonitor::EPEMessageAudioHandlingError:

            return MESSAGE("EPEMessageAudioHandlingError");

        case MEngineMonitor::EPEMessageCallHandlingError:

            return MESSAGE("EPEMessageCallHandlingError");

        case MEngineMonitor::EPEMessageContactHandlingError:

            return MESSAGE("EPEMessageContactHandlingError");

        case MEngineMonitor::EPEMessageLogHandlingError:

            return MESSAGE("EPEMessageLogHandlingError");

        case MEngineMonitor::EPEMessageServiceHandlingError:

            return MESSAGE("EPEMessageServiceHandlingError");

        // Network messages                   5000 - 5999

        case MEngineMonitor::EPEMessageCallSecureStatusChanged:

            return MESSAGE("EPEMessageCallSecureStatusChanged");

        case MEngineMonitor::EPEMessageNetworkRegistrationStatusChange:

            return MESSAGE("EPEMessageNetworkRegistrationStatusChange");

        // Parser messages                    6000 - 6999

        case MEngineMonitor::EPEMessageSSRequestFailed:

            return MESSAGE("EPEMessageSSRequestFailed");

        // Security messages                  7000 - 7999

        case MEngineMonitor::EPEMessageBadBarringPasswordChange:

            return MESSAGE("EPEMessageBadBarringPasswordChange");

        case MEngineMonitor::EPEMessageBadPin1Change:

            return MESSAGE("EPEMessageBadPin1Change");

        case MEngineMonitor::EPEMessageBadPin2Change:

            return MESSAGE("EPEMessageBadPin2Change");

        case MEngineMonitor::EPEMessageBadPin1Unblock:

            return MESSAGE("EPEMessageBadPin1Unblock");

        case MEngineMonitor::EPEMessageBadPin2Unblock:

            return MESSAGE("EPEMessageBadPin2Unblock");