diff -r 2eacb6118286 -r ba76fc04e6c2 phoneengine/phonemodel/src/cpephonemodel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phoneengine/phonemodel/src/cpephonemodel.cpp Fri Jun 04 10:19:18 2010 +0100 @@ -0,0 +1,1517 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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(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"); + case MEngineMonitor::EPEMessageBarringPasswordChanged: + return MESSAGE("EPEMessageBarringPasswordChanged"); + case MEngineMonitor::EPEMessageChangedSimLock: + return MESSAGE("EPEMessageChangedSimLock"); + case MEngineMonitor::EPEMessageFailedChangeSimLock: + return MESSAGE("EPEMessageFailedChangeSimLock"); + case MEngineMonitor::EPEMessageFailedNewPin1AndPin2NotEqual: + return MESSAGE("EPEMessageFailedNewPin1AndPin2NotEqual"); + case MEngineMonitor::EPEMessageFailedSecurityCommandAlreadyActive: + return MESSAGE("EPEMessageFailedSecurityCommandAlreadyActive"); + case MEngineMonitor::EPEMessagePin1Changed: + return MESSAGE("EPEMessagePin1Changed"); + case MEngineMonitor::EPEMessagePin2Changed: + return MESSAGE("EPEMessagePin2Changed"); + case MEngineMonitor::EPEMessagePin1Unblocked: + return MESSAGE("EPEMessagePin1Unblocked"); + case MEngineMonitor::EPEMessagePin2Unblocked: + return MESSAGE("EPEMessagePin2Unblocked"); + + // Settings and Shared Data messages 8000 - 8999 + case MEngineMonitor::EPEMessageProfileChanged: + return MESSAGE("EPEMessageProfileChanged"); + + // Startup messages 9000 - 9999 + case MEngineMonitor::EPEMessagePEConstructionReady: + return MESSAGE("EPEMessagePEConstructionReady"); + case MEngineMonitor::EPEMessagePEConstructionFailed: + return MESSAGE("EPEMessagePEConstructionFailed"); + case MEngineMonitor::EPEMessagePEConstructionTwoPhaseReady: + return MESSAGE("EPEMessagePEConstructionTwoPhaseReady"); + + // Miscellaneous messages 10000 - 10999 + case MEngineMonitor::EPEMessageInValidEmergencyNumber: + return MESSAGE("EPEMessageInValidEmergencyNumber"); + case MEngineMonitor::EPEMessageValidEmergencyNumber: + return MESSAGE("EPEMessageValidEmergencyNumber"); + case MEngineMonitor::EPEMessagePhoneIdentityReady: + return MESSAGE("EPEMessagePhoneIdentityReady"); + case MEngineMonitor::EPEMessageStartATDialing: + return MESSAGE("EPEMessageStartATDialing"); + case MEngineMonitor::EPEMessageLogEventSaved: + return MESSAGE("EPEMessageLogEventSaved"); + case MEngineMonitor::EPEMessageDoNotSendMe: + return MESSAGE("EPEMessageDoNotSendMe"); + + // Variant messages 11000 - 12999 + + // Audio messages 11000 - 11199 + + // Call messages 11200 - 11399 + case MEngineMonitor::EPEMessageActiveBarring: + return MESSAGE("EPEMessageActiveBarring"); + case MEngineMonitor::EPEMessageActiveCallForwarding: + return MESSAGE("EPEMessageActiveCallForwarding"); + case MEngineMonitor::EPEMessageAddedConferenceMember: + return MESSAGE("EPEMessageAddedConferenceMember"); + case MEngineMonitor::EPEMessageALSLineChanged: + return MESSAGE("EPEMessageALSLineChanged"); + case MEngineMonitor::EPEMessageCallBarred: + return MESSAGE("EPEMessageCallBarred"); + case MEngineMonitor::EPEMessageIncCallIsForw: + return MESSAGE("EPEMessageIncCallIsForw"); + case MEngineMonitor::EPEMessageIncCallForwToC: + return MESSAGE("EPEMessageIncCallForwToC"); + case MEngineMonitor::EPEMessageOutCallForwToC: + return MESSAGE("EPEMessageOutCallForwToC"); + case MEngineMonitor::EPEMessageForwardUnconditionalModeActive: + return MESSAGE( "EPEMessageForwardUnconditionalModeActive" ); + case MEngineMonitor::EPEMessageForwardConditionallyModeActive: + return MESSAGE( "EPEMessageForwardConditionallyModeActive" ); + case MEngineMonitor::EPEMessageDroppedConferenceMember: + return MESSAGE("EPEMessageDroppedConferenceMember"); + case MEngineMonitor::EPEMessageGoingOneToOne: + return MESSAGE("EPEMessageGoingOneToOne"); + case MEngineMonitor::EPEMessageIssuedUSSDRequest: + return MESSAGE("EPEMessageIssuedUSSDRequest"); + case MEngineMonitor::EPEMessageRemoteCreatedConference: + return MESSAGE("EPEMessageRemoteCreatedConference"); + case MEngineMonitor::EPEMessageRemoteHeld: + return MESSAGE("EPEMessageRemoteHeld"); + case MEngineMonitor::EPEMessageRemoteResumed: + return MESSAGE("EPEMessageRemoteResumed"); + case MEngineMonitor::EPEMessageShowVersion: + return MESSAGE("EPEMessageShowVersion"); + case MEngineMonitor::EPEMessageTempClirSuppressUnsuccessful: + return MESSAGE("EPEMessageTempClirSuppressUnsuccessful"); + case MEngineMonitor::EPEMessageTempClirActivationUnsuccessful: + return MESSAGE("EPEMessageTempClirActivationUnsuccessful"); + + // Contact messages 11400 - 11599 + + // Error messages 11600 - 11799 + + // Network messages 11800 - 12999 + case MEngineMonitor::EPEMessageServiceEnabled: + return MESSAGE("EPEMessageServiceEnabled"); + case MEngineMonitor::EPEMessageServiceEnabling: + return MESSAGE("EPEMessageServiceEnabling"); + case MEngineMonitor::EPEMessageNoService: + return MESSAGE("EPEMessageNoService"); + case MEngineMonitor::EPEMessageServiceDisabled: + return MESSAGE("EPEMessageServiceDisabled"); + + // Parser messages 12000 - 12199 + case MEngineMonitor::EPEMessageActivateRfsDeep: + return MESSAGE("EPEMessageActivateRfsDeep"); + case MEngineMonitor::EPEMessageActivateRfsNormal: + return MESSAGE("EPEMessageActivateRfsNormal"); + case MEngineMonitor::EPEMessageActivateWarrantyMode: + return MESSAGE("EPEMessageActivateWarrantyMode"); + case MEngineMonitor::EPEMessageIssuedSSRequest: + return MESSAGE("EPEMessageIssuedSSRequest"); + case MEngineMonitor::EPEMessageIssuingSSRequest: + return MESSAGE("EPEMessageIssuingSSRequest"); + + // Security messages 12200 - 12399 + + // Settings messages 12400 - 12599 + case MEngineMonitor::EPEMessageBarringNotification: + return MESSAGE("EPEMessageBarringNotification"); + case MEngineMonitor::EPEMessageClipStatusNotification: + return MESSAGE("EPEMessageClipStatusNotification"); + case MEngineMonitor::EPEMessageClirStatusNotification: + return MESSAGE("EPEMessageClirStatusNotification"); + case MEngineMonitor::EPEMessageCnapStatusNotification: + return MESSAGE("EPEMessageCnapStatusNotification"); + case MEngineMonitor::EPEMessageColpStatusNotification: + return MESSAGE("EPEMessageColpStatusNotification"); + case MEngineMonitor::EPEMessageColrStatusNotification: + return MESSAGE("EPEMessageColrStatusNotification"); + case MEngineMonitor::EPEMessageForwardingNotification: + return MESSAGE("EPEMessageForwardingNotification"); + case MEngineMonitor::EPEMessageVmbxNumberLine1Changed: + return MESSAGE("EPEMessageVmbxNumberLine1Changed"); + case MEngineMonitor::EPEMessageVmbxNumberLine2Changed: + return MESSAGE("EPEMessageVmbxNumberLine2Changed"); + case MEngineMonitor::EPEMessageWaitingNotification: + return MESSAGE("EPEMessageWaitingNotification"); + case MEngineMonitor::EPEMessageAlsStatusChanged: + return MESSAGE("EPEMessageAlsStatusChanged"); + + // Miscellaneous messages 12600 - 12799 + case MEngineMonitor::EPEMessageSIMChanged: + return MESSAGE("EPEMessageSIMChanged"); + case MEngineMonitor::EPEMessageSIMStateChanged: + return MESSAGE("EPEMessageSIMStateChanged"); + default: + TEFLOGSTRING2( KTAINT, "pe: cpephonemodel::namebymessagefromphoneengine, unknown message = %d", static_cast(aMessage)); + return MESSAGE("Unknown message"); + } + } +#else +TPtrC CPEPhoneModel::NameByMessageFromPhoneEngine( + const TInt /*aMessage*/ ) const + { + return MESSAGE("Not available"); + } +#endif // TEF_LOGGING_ENABLED + +// ----------------------------------------------------------------------------- +// CPEPhoneModel::HandleMessage +// Handles messages from phone application. +// ----------------------------------------------------------------------------- +// +void CPEPhoneModel::HandleMessage( + const TInt aMessage ) + { + TInt errorCode( ECCPErrorNone ); + #ifdef TEF_LOGGING_ENABLED + TInt callId; + callId = iEngineInfo->CallId(); // Get CallId + TPtrC messageName = NameByMessageToPhoneEngine( aMessage ); + TEFLOGSTRING3( KTAINT, + "PE cpephonemodel::handlemessage, messageName=%s, callId=%d", + messageName.Ptr( ), + callId ); + #endif + + if ( !iMessageHandler ) + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::HandleMessage: Not ready" ); + return; + } + + switch ( aMessage ) + { + case MPEPhoneModel::EPEMessageTerminateAllConnections: + errorCode = iMessageHandler->HandleTerminateAllConnections( ); + break; + case MPEPhoneModel::EPEMessageDial: + //Make a dial request + errorCode = iMessageHandler->HandleDialCall( EFalse ); + break; + case MPEPhoneModel::EPEMessageReleaseAll: //Make HangUp requests to all calls + errorCode = iMessageHandler->HandleReleaseAll( ); + break; + case MPEPhoneModel::EPEMessageRelease: //Make HangUp request + case CPEPhoneModelIF::EPEMessageHangUpConference: + errorCode = iMessageHandler->HandleReleaseCall( ); + break; + case MPEPhoneModel::EPEMessageAnswer: //Make Answer request + errorCode = iMessageHandler->HandleAnswerCall( EFalse ); + break; + case MPEPhoneModel::EPEMessageReject: //Make Reject request + errorCode = iMessageHandler->HandleRejectCall( ); + break; + case MPEPhoneModel::EPEMessageSetAudioMute: //Make Mute microphone request + iMessageHandler->HandleSetAudioMute( ); + break; + case MPEPhoneModel::EPEMessageSetAudioOutput: + errorCode = iMessageHandler->HandleSetAudioOutput(); + break; + case MPEPhoneModel::EPEMessageSetAudioVolume: //Sets audio volume. + iMessageHandler->HandleSetAudioVolume( ); + break; + case CPEPhoneModelIF::EPEMessageHold: //Make Hold request + case CPEPhoneModelIF::EPEMessageHoldConference: + errorCode = iMessageHandler->HandleHoldCall( ); + break; + case CPEPhoneModelIF::EPEMessageSwap: //Make Swap request + case CPEPhoneModelIF::EPEMessageSwapConference: + errorCode = iMessageHandler->HandleSwapCalls( ); + break; + case CPEPhoneModelIF::EPEMessageResume: //Make Resume request + case CPEPhoneModelIF::EPEMessageResumeConference: + errorCode = iMessageHandler->HandleResumeCall( ); + break; + case CPEPhoneModelIF::EPEMessageDropConferenceMember: // Drop conference member. + errorCode = iMessageHandler->HandleDropConferenceMember( ); + break; + case CPEPhoneModelIF::EPEMessageTransfer: //Make Transfer request + errorCode = iMessageHandler->HandleTransferCalls( ); + break; + case CPEPhoneModelIF::EPEMessageCreateConference: // Build conference call. + errorCode = iMessageHandler->HandleBuildConferenceCall( ); + break; + case CPEPhoneModelIF::EPEMessageGoOneToOne: // Go one to one. + errorCode = iMessageHandler->HandleGoOneToOne( ); + break; + case CPEPhoneModelIF::EPEMessageAddConferenceMember: //Add call to conference request + errorCode = iMessageHandler->HandleAddConferenceMember(); + break; + case MPEPhoneModel::EPEMessageSendDTMF: //Send dtmf string + errorCode = iMessageHandler->HandleSendDtmf( ); + break; + case MPEPhoneModel::EPEMessagePlayDTMF: //Play DTMF + TRAP( errorCode, iMessageHandler->HandlePlayDTMFL() ); + break; + case MPEPhoneModel::EPEMessageEndDTMF: //End DTMF playing + errorCode = iMessageHandler->HandleEndDTMF(); + break; + case MPEPhoneModel::EPEMessageStopTonePlay: //Stop InBand tone playing. + iMessageHandler->HandleStopInbandTonePlay( ); + break; + case MPEPhoneModel::EPEMessageClientDial: //Make Dial request(Client originated) + errorCode = iMessageHandler->HandleDialCall( ETrue ); + break; + case MPEPhoneModel::EPEMessageClientDialEmergency: + //Make emergency dial request(Client originated) + errorCode = iMessageHandler->HandleDialEmergencyCall( ETrue ); + break; + case MPEPhoneModel::EPEMessageContinueEmergencyCallInitialization: + //Make emergency dial request + iMessageHandler->ContinueDialEmergency(); + break; + case MPEPhoneModel::EPEMessageContinueDTMFSending: //Continue DTMF sending. + iMessageHandler->HandleContinueDtmfSending( ETrue ); + break; + case MPEPhoneModel::EPEMessageStopDTMFSending: //Stop DTMF sending. + iMessageHandler->HandleContinueDtmfSending( EFalse ); + break; + case CPEPhoneModelIF::EPEMessageCancelSSstringCommand: + errorCode = iMessageHandler->HandleCancelSSstringCommand( ); + break; + case MPEPhoneModel::EPEMessagePhoneNumberEdited: + TRAP( errorCode, iMessageHandler->HandlePhoneNumberEditedL( ) ); + break; + case MPEPhoneModel::EPEMessageCheckEmergencyNumber: + errorCode = iMessageHandler->HandleEmergencyCheck( ); + break; + case MPEPhoneModel::EPEMessageAutomaticAnswerOff: + iMessageHandler->HandleAutomaticAnswerOff( ); + break; + case CPEPhoneModelIF::EPEMessageSetALSLine: + iCallHandling->SetActiveLine(); + break; + case CPEPhoneModelIF::EPEMessageSwitchToVideoOrVoice: + iEngineInfo->SetIsSwitchToOperationOngoing( ETrue ); + errorCode = iMessageHandler->HandleSwitchToVideoOrVoice( iEngineInfo->CallId() ); + break; + case MPEPhoneModel::EPEMessageSatCallRequestCompleted: + iMessageHandler->HandleSatCallRequestCompleted(); + break; + case MPEPhoneModel::EPEMessageReplaceActive: + errorCode = iMessageHandler->HandleReplaceActive(); + break; + case MPEPhoneModel::EPEMessageAcceptUnattendedTransfer: + errorCode = iMessageHandler-> + HandleUnattendedTransferRequestResponse( ETrue ); + break; + case MPEPhoneModel::EPEMessageRejectUnattendedTransfer: + errorCode = iMessageHandler-> + HandleUnattendedTransferRequestResponse( EFalse ); + break; + + case MPEPhoneModel::EPEMessageDoUnattendedTransfer: + errorCode = iMessageHandler->HandleUnattendedTransfer(); + break; + case MPEPhoneModel::EPEMessageForwardCallToAddress: + errorCode = iMessageHandler->ForwardCallToAddress(); + break; + case MPEPhoneModel::EPEMessageDisableService: + iMessageHandler->HandleDisableService(); + break; + case MPEPhoneModel::EPEMessageDialServiceCall: //Make Dial request + errorCode = iMessageHandler->HandleDialCall( EFalse ); + break; + default: + errorCode = ECCPErrorNotFound; + break; + } + + if( errorCode ) + { + TPEErrorInfo errorInfo; + errorInfo.iErrorCode = errorCode; + errorInfo.iCallId = KPECallIdNotUsed; + errorInfo.iErrorType = EPECcp; + iEngineMonitor.HandleError( errorInfo ); + } + }// HandleMessage + +// ----------------------------------------------------------------------------- +// CPEPhoneModel::SendMessage +// Reroutes messages to the over loaded SendMessage( TInt aMessage, TInt aCallId ) method. +// Method creates new callid and calls overloaded method. +// ----------------------------------------------------------------------------- +// +void CPEPhoneModel::SendMessage( + const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage ) + { + SendMessage( aMessage, KPECallIdNotUsed ); + }// SendMessage( 1 param ) + +// ----------------------------------------------------------------------------- +// CPEPhoneModel::SendMessage +// Sends messages to the phone application +// Method sets call parameters to the CPEEngineInfo object and +// Method reroutes messages to the phone application. +// ----------------------------------------------------------------------------- +// +void CPEPhoneModel::SendMessage( + const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage, + const TInt aCallId ) + { + TInt errorCode( ECCPErrorNone ); + TPEState callState; + //Save message to local variable so that it can be modified + TInt message( aMessage ); + + #ifdef TEF_LOGGING_ENABLED + TPtrC messageName = NameByMessageFromPhoneEngine( + static_cast( aMessage ) ); + TEFLOGSTRING3( KTAINT, + "PE cpephonemodel::sendmessage, messageName=%s, callId=%d" + , messageName.Ptr( ) + , aCallId ); + #endif + + if ( iMessageHandler ) + { + errorCode = ProcessMessage( aMessage, aCallId ); + } + + if ( DelayMessageSending( aMessage, aCallId ) ) + { + message = KPEDontSendMessage; + } + + // Set Call State to the EngineInfo + if ( CallIdCheck::IsConference( aCallId )) + { + callState = iCallHandling->GetCallState( aCallId ); + if ( callState > EPEStateUnknown && callState < EPEStateMaximumState ) + { + iEngineInfo->SetConferenceCallState( static_cast( callState ) ); + } + else + { + iEngineInfo->SetConferenceCallState( EPEStateUnknown ); + } + } + if ( CallIdCheck::IsValid( aCallId )) + { + callState = iCallHandling->GetCallState( aCallId ); + if ( callState > EPEStateUnknown && callState < EPEStateMaximumState ) + { + iEngineInfo->SetCallState( static_cast( callState ), aCallId ); + } + else + { + iEngineInfo->SetCallState( EPEStateUnknown, aCallId ); + } + } + + if ( ( message == MEngineMonitor::EPEMessageIncoming ) ) + { + if ( FeatureManager::FeatureSupported( KFeatureIdDriveMode ) ) + { + //Check for Drive mode + if ( iEngineInfo->ProfileId() == KDriveProfile ) + { + //Drive mode is enabled, do not forward message + message = KPEDontSendMessage; + } + } + } + + if ( message == MEngineMonitor::EPEMessageChangedCallDuration ) + { + TInt callTimerSetting( EFalse ); + // safe to ignore error code here, duration display equals to zero == off if it fails + iExternalDataHandler->Get( EPECallDurationDisplaySetting, callTimerSetting ); + // Message EPEMessageChangedCallDuration send supressed, if duration display is OFF + if ( callTimerSetting == KPECallTimerOff ) + { + message = KPEDontSendMessage; + } + } + + //MessageHandler may return error code + if ( errorCode != ECCPErrorNone && errorCode != KPEDontSendMessage ) + { + #ifdef TEF_LOGGING_ENABLED + TPtrC messageName2 = + NameByMessageFromPhoneEngine( + static_cast( message ) ); + TEFLOGSTRING3( + KTAERROR, + "PE cpephonemodel::sendmessage > iEngineMonitor.HandleError: messageName=%s, CallId=%d", + messageName2.Ptr( ), aCallId ); + #endif + TPEErrorInfo errorInfo; + errorInfo.iErrorCode = errorCode; + errorInfo.iCallId = aCallId; + errorInfo.iErrorType = EPECcp; + iEngineMonitor.HandleError( errorInfo ); + } + else if ( message == MEngineMonitor::EPEMessageCallHandlingError ) + { + TEFLOGSTRING2( + KTAERROR, + "PE cpephonemodel::sendmessage > iEngineMonitor.HandleError: messageName=EPEMessageCallHandlingError, CallId=%d" + , aCallId ); + TPEErrorInfo errorInfo = iEngineInfo->ErrorInfo(); + errorInfo.iCallId = aCallId; + errorInfo.iErrorType = EPECcp; + iEngineMonitor.HandleError( errorInfo ); + } + else if ( message == MEngineMonitor::EPEMessageServiceHandlingError ) + { + TEFLOGSTRING( + KTAERROR, + "PE cpephonemodel::sendmessage > iEngineMonitor.HandleError: messageName=EPEMessageServiceHandlingError" ); + TPEErrorInfo errorInfo = iEngineInfo->ErrorInfo(); + errorInfo.iCallId = aCallId; + errorInfo.iErrorType = EPECch; + iEngineMonitor.HandleError( errorInfo ); + } + else if ( message != KPEDontSendMessage && errorCode != KPEDontSendMessage ) + { + // Map message for PhoneApplication, since it doesn't use + // EPEMessageDisconnectingWithInband message + if( message == MEngineMonitor::EPEMessageDisconnectingWithInband ) + { + message = MEngineMonitor::EPEMessageDisconnecting; + } + else if ( message == MEngineMonitor::EPEMessageConnectingWithInband ) + { + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + message = MEngineMonitor::EPEMessageConnecting; + } + #ifdef TEF_LOGGING_ENABLED + TPtrC messageName2 = NameByMessageFromPhoneEngine + ( static_cast( message ) ); + TEFLOGSTRING3( + KTAINT, + "PE cpephonemodel::sendmessage > iEngineMonitor HandleMessage: messageName=%s, CallId=%d" + , messageName2.Ptr( ), aCallId ); + #endif + + __ASSERT_DEBUG( + ( KPEDontSendMessage <= message < KPEMessagesFromPhoneEngineGsmLast ), + Panic( EPEPanicIllegalCommand ) ); + iEngineMonitor.HandleMessage( + static_cast( message ), + aCallId ); + } + + if( iParserRecognizer ) + { + iParserRecognizer->sendMessage( aMessage, aCallId ); + } + + }// SendMessage( 2 params ) + +// ----------------------------------------------------------------------------- +// CPEPhoneModel::ProcessMessage +// Process messages from the subsystems by passing them to message handlder. +// ----------------------------------------------------------------------------- +TInt CPEPhoneModel::ProcessMessage( + const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage, + const TInt aCallId ) + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ProcessMessage" ); + TInt errorCode( ECCPErrorNone ); + + //Get Message + switch ( aMessage ) + { + case MEngineMonitor::EPEMessageDialing: + TRAP( errorCode, iMessageHandler->HandleDialingStateL( aCallId ) ); + break; + + case MEngineMonitor::EPEMessageIncoming: + TRAP( errorCode, iMessageHandler->HandleIncomingCallL( aCallId ) ); + // Since it is possible that incoming call interrupts switch to operation + // we need to reset this value. + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + break; + + case MEngineMonitor::EPEMessageAnswering: + if ( CallIdCheck::IsVideo( aCallId ) ) + { + // Answering video calls + iMessageHandler->HandleStopInbandTonePlay( ); + iMessageHandler->HandleAudioRouting( ETrue, aCallId ); + } + else if ( iEngineInfo->CallType( aCallId ) == EPECallTypeCSVoice || + iEngineInfo->CallType( aCallId ) == EPECallTypeVoIP ) + { + iMessageHandler->HandleAudioRouting( EFalse, aCallId); + } + + break; + + case MEngineMonitor::EPEMessageConnected: + // Switch to status needs to be set false here because some networks + // do not use connecting state. + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + iEngineInfo->SetResumeHeldCall( ETrue, aCallId ); + if ( CallIdCheck::IsVoice( aCallId )) + { + errorCode = iMessageHandler->HandleConnectedState( aCallId ); + } + else if ( CallIdCheck::IsVideo( aCallId )) + { + // Video call : for video call logging and duration + errorCode = iMessageHandler->HandleVideoCallConnected( aCallId ); + + } + // VoIP call audio routing happens when 'connected' message is + // received because of differences in VoIP and CS call audio + // activation. + if ( EPECallTypeVoIP == iEngineInfo->CallType( aCallId ) ) + { + iMessageHandler->HandleAudioRouting( EFalse, aCallId ); + } + + break; + + case MEngineMonitor::EPEMessageIdle: + if ( CallIdCheck::IsVoice( aCallId )) + { + errorCode = iMessageHandler->HandleVoiceCallIdleState( aCallId ); + } + else if ( CallIdCheck::IsVideo( aCallId )) + { + // Video call : for video call logging and duration + errorCode = iMessageHandler->HandleVideoCallIdle( aCallId ); + } + if ( errorCode == ECCPErrorNone && iEngineInfo->IsSwitchToOperationOngoing() ) + { + errorCode = iMessageHandler->ContinueSwitchToCall( aCallId ); + } + break; + + case MEngineMonitor::EPEMessageRemoteBusy: + if ( CallIdCheck::IsVoice( aCallId )) + { + // Set video/voice boolean to false because error occured. + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + iMessageHandler->HandleCallHandlingError( aCallId, ETrue ); + } + break; + + case MEngineMonitor::EPEMessageCallHandlingError: + // Set video/voice boolean to false because error occured. + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + iMessageHandler->HandleCallHandlingError( aCallId, EFalse ); + break; + + case MEngineMonitor::EPEMessageAudioOutputPreferenceChanged: + errorCode = iMessageHandler->HandleRoutePreferenceChanged(); + break; + + case MEngineMonitor::EPEMessageConferenceIdle: + if ( CallIdCheck::IsConference( aCallId ) ) + { + errorCode = iMessageHandler->HandleConferenceIdleState( aCallId ); + } + break; + + case MEngineMonitor::EPEMessageAnswer: // Automatic answer complete + errorCode = iMessageHandler->HandleAnswerCall( ETrue ); + break; + + case MEngineMonitor::EPEMessageAlsStatusChanged: + case MEngineMonitor::EPEMessageSIMStateChanged: + iMessageHandler->HandleSimStateChanged( ); + break; + + case MEngineMonitor::EPEMessagePEConstructionReady: + iMessageHandler->HandleStartUp( ); + break; + + case MEngineMonitor::EPEMessageDisconnecting: + errorCode = iMessageHandler->HandleDisconnecting( aCallId ); + break; + + case MEngineMonitor::EPEMessageDisconnectingWithInband: + errorCode = iMessageHandler->HandleDisconnectingWithInband( aCallId ); + break; + + case MEngineMonitor::EPEMessageConnectedConference: + iEngineInfo->SetResumeHeldCall( ETrue, aCallId ); + break; + + case MEngineMonitor::EPEMessageSentDTMF: + errorCode = iMessageHandler->HandleDtmfSent(); + break; + + case MEngineMonitor::EPEMessageActivateWarrantyMode: + errorCode = iMessageHandler->HandleGetLifeTimerData( ); + break; + + case MEngineMonitor::EPEMessageStartATDialing: + errorCode = iMessageHandler->HandleDialCall( EFalse ); + iMessageHandler->HandleATDialingStarted( errorCode ? EFalse : ETrue ); + break; + + // MO call connecting. + case MEngineMonitor::EPEMessageConnecting: + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + iEngineInfo->SetInbandTone( ECCPRemoteAlerting ); + iAudioData->PlayInbandTone(); + break; + /* + case MEngineMonitor::EPEMessageInitiatedEmergencyCall: + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + if ( iCallStackCutter ) + { + delete iCallStackCutter; + iCallStackCutter = NULL; + } + TRAPD( err, iCallStackCutter = CIdle::NewL( CActive::EPriorityHigh ) ); + if ( !err ) + { + iCallBackMessage = aMessage; + iCallBackCallId = aCallId; + iCallStackCutter->Start( TCallBack( CallBackMessageSend , this ) ); + } + message = KPEDontSendMessage; + break; + */ + case MEngineMonitor::EPEMessageDroppedConferenceMember: + iMessageHandler->HandleDroppedConferenceMember(); + break; + + case MEngineMonitor::EPEMessageDTMFSendingAborted: + iEngineInfo->SetDtmfString( KNullDesC() ); + break; + + case MEngineMonitor::EPEMessageServiceEnabled: + errorCode = iMessageHandler->HandleServiceEnabled(); + break; + + case MEngineMonitor::EPEMessageRemotePartyInfoChanged: + iMessageHandler->HandleRemotePartyInfoChanged( ); + break; + + default: + break; + } + + return errorCode; + } + +// ----------------------------------------------------------------------------- +// CPEPhoneModel::DelayMessageSending +// Determines which messages needs to be delayed and delays sending them +// to Engine monitor. +// ----------------------------------------------------------------------------- +TBool CPEPhoneModel::DelayMessageSending( + const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage, + const TInt aCallId ) + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::DelayMessageSending" ); + + TBool sendingDelayed( EFalse ); + + if ( MEngineMonitor::EPEMessageInitiatedEmergencyCall == aMessage ) + { + iEngineInfo->SetIsSwitchToOperationOngoing( EFalse ); + if ( iCallStackCutter ) + { + delete iCallStackCutter; + iCallStackCutter = NULL; + } + TRAPD( err, iCallStackCutter = CIdle::NewL( CActive::EPriorityHigh ) ); + if ( !err ) + { + iCallBackMessage = aMessage; + iCallBackCallId = aCallId; + iCallStackCutter->Start( TCallBack( CallBackMessageSend , this ) ); + } + sendingDelayed = ETrue; + } + return sendingDelayed; + } + +// ----------------------------------------------------------------------------- +// CPEPhoneModel::RecallSteps +// Method informs about failures in starting modules. +// ----------------------------------------------------------------------------- +// +void CPEPhoneModel::RecallSteps() + { + SendMessage( MEngineMonitor::EPEMessagePEConstructionFailed ); + iActiveStarter = NULL; + } + +// ----------------------------------------------------------------------------- +// CPEPhoneModel::StepL +// Method starts and connects modules asynchronically. +// ----------------------------------------------------------------------------- +// +TBool CPEPhoneModel::StepL() + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 1" ); + TBool continueStepping = ETrue; + + switch ( iStep ) + { + case CPEPhoneModel::EPEInitializeCceConnection: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 2.1" ); + iConvergedCallEngine = CCCE::NewL(); + MCCEDtmfObserver* tempPointer( NULL ); + MCCEDtmfInterface& tempReference = iConvergedCallEngine->DtmfInterfaceL( *tempPointer ); + iDtmfInterface = &tempReference; + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 2.2" ); + break; + } + case CPEPhoneModel::EPEExternalData: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 3.1" ); + iExternalDataHandler = CPEExternalDataHandler::NewL( *this ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 3.2" ); + break; + } + case CPEPhoneModel::EPECallHandling: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 4.1" ); + iCallHandling = CPECallHandling::NewL( *this, *iConvergedCallEngine, *iDtmfInterface ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 4.2" ); + break; + } + case CPEPhoneModel::EPEAudioHandling: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 5.1" ); + if ( iAudioFactory ) + { + iAudioData = CPEGsmAudioData::NewL( + *this, iFsSession, *iAudioFactory ); + } + else + { + iAudioData = CPEGsmAudioData::NewL( *this, iFsSession ); + } + iDtmfInterface->AddObserverL( *iAudioData ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 5.2" ); + break; + } + case CPEPhoneModel::EPELogHandlingPhaseOne: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 6.1" ); + // Create Log Handling proxy along with dummy implementation + iLogHandling = CPELogHandlingProxy::CreateFirstPhaseL(); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 6.2" ); + break; + } + case CPEPhoneModel::EPEContactHandlingPhaseOne: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 7.1" ); + // Create Contact Handling proxy along with dummy implementation + iContactHandling = CPEContactHandlingProxy::CreateFirstPhaseL(); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 7.2" ); + break; + } + case CPEPhoneModel::EPESimStateMonitor: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 9.1" ); + //started after message handler construction + iSimStatusMonitor = CPESimStateMonitor::NewL( + *this, + CPESimStateMonitor::EEventSimStatus ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 9.2" ); + break; + } + case CPEPhoneModel::EPEServiceHandling: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 10.1" ); + iServiceHandling = CPEServiceHandling::NewL( *this ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 10.2" ); + break; + } + case CPEPhoneModel::EPEMessageHandler: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 11.1" ); + iMessageHandler = CPEMessageHandler::NewL( *this, + *iCallHandling, + iEngineMonitor, + *iAudioData, + *iLogHandling, + *iContactHandling, + *iSimStatusMonitor, + *iExternalDataHandler, + *iServiceHandling, + iFsSession ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 11.2" ); + break; + } + case CPEPhoneModel::EPESimChangedMonitor: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 12.1" ); + iSimChangedMonitor = CPESimStateMonitor::NewL( + *this, + CPESimStateMonitor::EEventSimChanged ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 12.2" ); + iSimChangedMonitor->Start(); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 12.3" ); + break; + } + case CPEPhoneModel::EPESimStatusMonitorStart: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 13.1" ); + iSimStatusMonitor->Start(); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 13.2" ); + break; + } + case CPEPhoneModel::EPELogHandlingPhaseTwo: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 14.1" ); + // Finalize Log Handling contruction + static_cast< CPELogHandlingProxy* > ( iLogHandling )->CreateSecondPhaseL( + *this, + iFsSession ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 14.2" ); + break; + } + case CPEPhoneModel::EPEContactHandlingPhaseTwo: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 15.1" ); + static_cast< CPEContactHandlingProxy* >( iContactHandling )-> + CreateSecondPhaseL( *this, iFsSession ); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 15.2" ); + break; + } + case CPEPhoneModel::EPEMediatorCommandHandler: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 16.1" ); + // Start Mediator command listener + iMediatorCommunicationHandler = CPERemotePartyInfoMediator::NewL( *this ); + break; + } + case CPEPhoneModel::EPEPhoneServices: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 16.1" ); + __ASSERT_DEBUG( iMessageHandler, Panic( EPEPanicNullPointer ) ); + __ASSERT_DEBUG( iEngineInfo, Panic( EPEPanicNullPointer ) ); + iPhoneServices = new PhoneServices( + *iMessageHandler, *iEngineInfo, *iMessageHandler); + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 16.2" ); + break; + } + + case CPEPhoneModel::EPEParserRecognizer: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 17.1" ); + iParserRecognizer = new ParserRecognizer; + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 17.2" ); + break; + } + + case CPEPhoneModel::EPENetworkHandling: + { + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 18.1" ); + XQServiceRequest request("com.nokia.services.networkhandling","start()"); + bool res = request.send(); + if (!res) { + int error = request.latestError(); + TEFLOGSTRING2( + KTAOBJECT, + "CPEPhoneModel::StepL 18.2 error %d", + error ); + } + TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 18.2" ); + continueStepping = EFalse; + break; + } + + default: + { + Panic( EPEPanicIndexOutOfRange ); + break; + } + } + + if ( !continueStepping ) + { + // Note, if you add cases, you have to set + // continueStepping = EFalse into the last case. + SendMessage( MEngineMonitor::EPEMessagePEConstructionReady ); + iActiveStarter = NULL; + } + else + { + ++iStep; + } + return continueStepping; + }// StepL + +// ----------------------------------------------------------------------------- +// Handle internal messages +// ----------------------------------------------------------------------------- +// +void CPEPhoneModel::HandleInternalMessage( + const TInt aMessage ) + { + HandleMessage( aMessage ); + } + +// ----------------------------------------------------------------------------- +// ConstructContactHandlingPhaseTwoL +// ----------------------------------------------------------------------------- +// +void CPEPhoneModel::ConstructContactHandlingPhaseTwoL() + { + TEFLOGSTRING( KTAOBJECT, + "PE CPEPhoneModel::ConstructContactHandlingPhaseTwo, start" ); + // Finalize Contact Handling contruction + static_cast< CPEContactHandlingProxy* >( iContactHandling )-> + CreateSecondPhaseL( *this, iFsSession ); + TEFLOGSTRING( KTAOBJECT, + "PE CPEPhoneModel::ConstructContactHandlingPhaseTwo, complete" ); + SendMessage( MEngineMonitor::EPEMessagePEConstructionTwoPhaseReady ); + // not need any more + delete iIdleStatusMonitor; + iIdleStatusMonitor = NULL; + } + +// ----------------------------------------------------------------------------- +// CallBackSendMessage +// ----------------------------------------------------------------------------- +// +TInt CPEPhoneModel::CallBackMessageSend( TAny* aSelf ) + { + TEFLOGSTRING( KTAINT, + "PE CPEPhoneModel::CallBackMessageSend, start" ); + + CPEPhoneModel* self = static_cast( aSelf ); + + self->iEngineMonitor.HandleMessage( self->iCallBackMessage, self->iCallBackCallId ); + + return KErrNone; + } + +// End of File