FCL/sf/app/phone: comparison phoneengine/phonemodel/src/cpephonemodel.cpp

equal deleted inserted replaced

-:c84cf270c54f
+:92ab7f8d0eab
 #include <cpeloghandlingproxy.h>
 #include <featmgr.h>
 #include <mccedtmfinterface.h>
 #include <mpecontacthandling.h>
 #include <mpeloghandling.h>
+// <-- QT PHONE START -->
+#include "phoneservices.h"
+#include "parserrecognizer.h"
+// <-- QT PHONE END -->
 // CONSTANTS
 const TInt KDriveProfile ( 6 );
 const TInt KPECallTimerOff = 0;
 delete iConvergedCallEngine;
 if ( iIdleStatusMonitor )
 {
 delete iIdleStatusMonitor;
 }
+// <-- QT PHONE START -->
+delete iPhoneServices;
+delete iParserRecognizer;
+// <-- QT PHONE END -->
 }// ~CPEPhoneModel
 // -----------------------------------------------------------------------------
 // CPEPhoneModel::EngineInfo
 // Returns the pointer of the CPEEngineInfo object.
 return MESSAGE("EPEMessageAnswer");
 case MPEPhoneModel::EPEMessageClientDial:
 return MESSAGE("EPEMessageClientDial");
 case MPEPhoneModel::EPEMessageClientDialEmergency:
 return MESSAGE("EPEMessageClientDialEmergency");
+// <-- QT PHONE START -->
+case MPEPhoneModel::EPEMessageDialServiceCall:
+return MESSAGE("EPEMessageDialServiceCall");
+// <-- QT PHONE END -->
 case MPEPhoneModel::EPEMessageContinueEmergencyCallInitialization:
 return MESSAGE("EPEMessageContinueEmergencyCallInitialization");
 case MPEPhoneModel::EPEMessageContinueDTMFSending:
 return MESSAGE("EPEMessageContinueDTMFSending");
 case MPEPhoneModel::EPEMessageDial:
 case MEngineMonitor::EPEMessageALSLineChanged:
 return MESSAGE("EPEMessageALSLineChanged");
 case MEngineMonitor::EPEMessageCallBarred:
 return MESSAGE("EPEMessageCallBarred");
 case MEngineMonitor::EPEMessageIncCallIsForw:
-	return MESSAGE("EPEMessageIncCallIsForw");
+return MESSAGE("EPEMessageIncCallIsForw");
 case MEngineMonitor::EPEMessageIncCallForwToC:
-	return MESSAGE("EPEMessageIncCallForwToC");
+return MESSAGE("EPEMessageIncCallForwToC");
 case MEngineMonitor::EPEMessageOutCallForwToC:
-	return MESSAGE("EPEMessageOutCallForwToC");
+return MESSAGE("EPEMessageOutCallForwToC");
 case MEngineMonitor::EPEMessageForwardUnconditionalModeActive:
-	return MESSAGE( "EPEMessageForwardUnconditionalModeActive" );
+return MESSAGE( "EPEMessageForwardUnconditionalModeActive" );
 case MEngineMonitor::EPEMessageForwardConditionallyModeActive:
-	return MESSAGE( "EPEMessageForwardConditionallyModeActive" );
+return MESSAGE( "EPEMessageForwardConditionallyModeActive" );
 case MEngineMonitor::EPEMessageDroppedConferenceMember:
 return MESSAGE("EPEMessageDroppedConferenceMember");
 case MEngineMonitor::EPEMessageGoingOneToOne:
 return MESSAGE("EPEMessageGoingOneToOne");
 case MEngineMonitor::EPEMessageIssuedUSSDRequest:
 {
 case MPEPhoneModel::EPEMessageTerminateAllConnections:
 errorCode = iMessageHandler->HandleTerminateAllConnections( );
 break;
 case MPEPhoneModel::EPEMessageDial:
-	//Make a dial request
+//Make a dial request
 errorCode = iMessageHandler->HandleDialCall( EFalse );
 break;
 case MPEPhoneModel::EPEMessageReleaseAll: //Make HangUp requests to all calls
 errorCode = iMessageHandler->HandleReleaseAll( );
 break;
 errorCode = iMessageHandler->ForwardCallToAddress();
 break;
 case MPEPhoneModel::EPEMessageDisableService:
 iMessageHandler->HandleDisableService();
 break;
+// <-- QT PHONE START -->
+case MPEPhoneModel::EPEMessageDialServiceCall:  //Make Dial request
+errorCode = iMessageHandler->HandleDialCall( EFalse );
+break;
+// <-- QT PHONE END -->
 default:
 errorCode = ECCPErrorNotFound;
 break;
 }
 if( errorCode )
-	    {
+{
-	    TPEErrorInfo errorInfo;
+TPEErrorInfo errorInfo;
-	    errorInfo.iErrorCode = errorCode;
+errorInfo.iErrorCode = errorCode;
-	    errorInfo.iCallId = KPECallIdNotUsed;
+errorInfo.iCallId = KPECallIdNotUsed;
-	    errorInfo.iErrorType = EPECcp;
+errorInfo.iErrorType = EPECcp;
-	    iEngineMonitor.HandleError( errorInfo );
+iEngineMonitor.HandleError( errorInfo );
-	    }
+}
 }// HandleMessage
 // -----------------------------------------------------------------------------
 // CPEPhoneModel::SendMessage
 // Reroutes messages to the over loaded SendMessage( TInt aMessage, TInt aCallId ) method.
 }
 }
 }
 if ( message == MEngineMonitor::EPEMessageChangedCallDuration )
-	    {
+{
-	    TInt callTimerSetting( EFalse );
+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
 KTAERROR,
 "PE cpephonemodel::sendmessage > iEngineMonitor.HandleError: messageName=%s, CallId=%d",
 messageName2.Ptr( ), aCallId );
 #endif
 TPEErrorInfo errorInfo;
-	errorInfo.iErrorCode = errorCode;
+errorInfo.iErrorCode = errorCode;
-	errorInfo.iCallId = aCallId;
+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();
+TPEErrorInfo errorInfo = iEngineInfo->ErrorInfo();
-	errorInfo.iCallId = aCallId;
+errorInfo.iCallId = aCallId;
-	errorInfo.iErrorType = EPECcp;
+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 )
 Panic( EPEPanicIllegalCommand ) );
 iEngineMonitor.HandleMessage(
 static_cast<MEngineMonitor::TPEMessagesFromPhoneEngine>( message ),
 aCallId );
 }
+// <-- QT PHONE START -->
+if( iParserRecognizer )
+{
+iParserRecognizer->sendMessage( aMessage, aCallId );
+}
+// <-- QT PHONE END -->
 }// SendMessage( 2 params )
 // -----------------------------------------------------------------------------
 // CPEPhoneModel::ProcessMessage
 // Process messages from the subsystems by passing them to message handlder.
 case MEngineMonitor::EPEMessageServiceEnabled:
 errorCode = iMessageHandler->HandleServiceEnabled();
 break;
 case MEngineMonitor::EPEMessageRemotePartyInfoChanged:
-iMessageHandler->HandleRemotePartyInfoChanged( aCallId );
+iMessageHandler->HandleRemotePartyInfoChanged( );
 break;
 default:
 break;
 }
 break;
 }
 case CPEPhoneModel::EPEContactHandlingPhaseTwo:
 {
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 15.1" );
+// <-- QT PHONE START -->
 // Start Idle State monitor to finalize ContactHandling contruction
-iIdleStatusMonitor = CPEIdleStatusMonitor::NewL (*this );
+//iIdleStatusMonitor = CPEIdleStatusMonitor::NewL (*this );
+static_cast< CPEContactHandlingProxy* >( iContactHandling )->
+CreateSecondPhaseL( *this, iFsSession );
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 15.2" );
+// This should be set after the last case
+//            continueStepping = EFalse;
+// <-- QT PHONE END -->
+break;
+}
+case CPEPhoneModel::EPEMediatorCommandHandler:
+{
+TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 16.1" );
+// Start Mediator command listener
+// <-- QT PHONE START -->
+iMediatorCommunicationHandler = CPERemotePartyInfoMediator::NewL( *this );
 break;
 }
-case CPEPhoneModel::EPEMediatorCommandHandler:
+case CPEPhoneModel::EPEPhoneServices:
 {
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 16.1" );
-// Start Mediator command listener
+__ASSERT_DEBUG( iMessageHandler, Panic( EPEPanicNullPointer ) );
-iMediatorCommunicationHandler = CPERemotePartyInfoMediator::NewL( *this );
+__ASSERT_DEBUG( iEngineInfo, Panic( EPEPanicNullPointer ) );
+iPhoneServices = new PhoneServices (*iMessageHandler, *iEngineInfo);
-// This should be set after the last case
+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" );
 continueStepping = EFalse;
 break;
 }
+// <-- QT PHONE END -->
 default:
 {
 Panic( EPEPanicIndexOutOfRange );
 break;
 }

changeset 21	92ab7f8d0eab
parent 1	838b0a10d15b
child 22	6bb1b21d2484