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

equal deleted inserted replaced

-:41a7f70b3818
+:5266b1f337bd
 //  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 <cpeloghandlingproxy.h>
 #include <featmgr.h>
 #include <mccedtmfinterface.h>
 #include <mpecontacthandling.h>
 #include <mpeloghandling.h>
-#include <xqservicerequest.h>
-#include <xqappmgr.h>
-#include "phoneservices.h"
 // CONSTANTS
 const TInt KDriveProfile ( 6 );
 const TInt KPECallTimerOff = 0;
-const TInt KTimesToSplitValue = 16;
 // ==================== LOCAL FUNCTIONS ====================
 // ================= MEMBER FUNCTIONS =======================
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 4" );
 iActiveStarter = CPEActiveStarter::NewL( this );
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 5" );
 iActiveStarter->StartUp();
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::ConstructL: 6" );
-// Reserve needed callinfo and remoteinfo from heap.
-iCallInfo = new ( ELeave ) RMobileCall::TMobileCallInfoV3;
 }// ConstructL
 // -----------------------------------------------------------------------------
 // CPEPhoneModel::NewL
 // Two-phased constructor.
 delete iLogHandling;
 delete iAudioData;
 delete iCallHandling;
 delete iExternalDataHandler;
 delete iCallStackCutter;
-delete iCallInfo;
 if ( iActiveStarter )
 {
 delete iActiveStarter;
 }
 FeatureManager::UnInitializeLib();
 iFsSession.Close();
 delete iEngineInfo;
 delete iConvergedCallEngine;
-delete iPhoneServices;
+if ( iIdleStatusMonitor )
+{
+delete iIdleStatusMonitor;
+}
 }// ~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");
-case MPEPhoneModel::EPEMessageDialServiceCall:
-return MESSAGE("EPEMessageDialServiceCall");
 case MPEPhoneModel::EPEMessageContinueEmergencyCallInitialization:
 return MESSAGE("EPEMessageContinueEmergencyCallInitialization");
 case MPEPhoneModel::EPEMessageContinueDTMFSending:
 return MESSAGE("EPEMessageContinueDTMFSending");
 case MPEPhoneModel::EPEMessageDial:
 return MESSAGE("EPEMessageIncoming");
 case MEngineMonitor::EPEMessageInitiatedEmergencyCall:
 return MESSAGE("EPEMessageInitiatedEmergencyCall");
 case MEngineMonitor::EPEMessageInitiatedEmergencyWhileActiveVideo:
 return MESSAGE("EPEMessageInitiatedEmergencyWhileActiveVideo");
+case MEngineMonitor::EPEMessageInitiatedMoCall:
+return MESSAGE("EPEMessageInitiatedMoCall");
 case MEngineMonitor::EPEMessagePacketNetworkDetached:
 return MESSAGE("EPEMessagePacketNetworkDetached");
 case MEngineMonitor::EPEMessageRemoteBusy:
 return MESSAGE("EPEMessageRemoteBusy");
 case MEngineMonitor::EPEMessageSendingDTMF:
 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::EPEMessageMultipleChoices:
 return MESSAGE("EPEMessageMultipleChoices");
 case MEngineMonitor::EPEMessageRemotePartyInfoChanged:
 return MESSAGE("EPEMessageRemotePartyInfoChanged");
 case MEngineMonitor::EPEMessageConnectingWithInband:
 return MESSAGE("EPEMessageConnectingWithInband");
+case MEngineMonitor::EPEMessageColpNumberAvailable:
+return MESSAGE("EPEMessageColpNumberAvailable");
+case MEngineMonitor::EPEMessageTransferCallBackRequest:
+return MESSAGE("EPEMessageTransferCallBackRequest");
 // Contact messages                   3000 - 3999
 case MEngineMonitor::EPEMessageThumbnailLoadingCompleted:
 return MESSAGE("EPEMessageThumbnailLoadingCompleted");
 // Error messages                     4000 - 4999
 // 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:
 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:
 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");
-case MEngineMonitor::EPEMessageOutgoingCallBarred:
-return MESSAGE("EPEMessageOutgoingCallBarred");
 // Contact messages                       11400 - 11599
 // Error messages                         11600 - 11799
 // Network messages                       11800 - 12999
 // 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");
 {
 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;
 case MPEPhoneModel::EPEMessageRelease:     //Make HangUp request
+errorCode = iMessageHandler->HandleReleaseCall( );
+break;
 case CPEPhoneModelIF::EPEMessageHangUpConference:
-errorCode = iMessageHandler->HandleReleaseCall( );
+errorCode = iMessageHandler->HandleReleaseConference();
 break;
 case MPEPhoneModel::EPEMessageAnswer:                        //Make Answer request
 errorCode = iMessageHandler->HandleAnswerCall( EFalse );
 break;
 case MPEPhoneModel::EPEMessageReject:                        //Make Reject request
 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;
+	    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.
 {
 iEngineInfo->SetCallState( EPEStateUnknown, aCallId );
 }
 }
-if ( message == MEngineMonitor::EPEMessageOutgoingCallBarred )
-{
-iEngineInfo->SetOutgoingCallBarringActivated( ETrue );
-message = KPEDontSendMessage;
-}
 if ( ( message == MEngineMonitor::EPEMessageIncoming ) )
 {
 if ( FeatureManager::FeatureSupported( KFeatureIdDriveMode ) )
 {
 //Check for Drive mode
 }
 }
 }
 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
 TEFLOGSTRING3(
 KTAERROR,
 "PE cpephonemodel::sendmessage > iEngineMonitor.HandleError: messageName=%s, CallId=%d",
 messageName2.Ptr( ), aCallId );
 #endif
-SetCallError( aCallId );
 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 );
-SetCallError( aCallId );
 	    TPEErrorInfo errorInfo = iEngineInfo->ErrorInfo();
 	errorInfo.iCallId = aCallId;
 	errorInfo.iErrorType = EPECcp;
 if ( ECCPErrorCCCallRejected == errorInfo.iErrorCode )
 // Call direction is not set if the call was rejected before Dialing-state
 iEngineInfo->SetCallDirection( RMobileCall::EMobileOriginated, aCallId );
 iMessageHandler->AddSIMRejectedMoCsCallToLog( aCallId );
 }
 	iEngineMonitor.HandleError( errorInfo );
-}
+	    }
 else if ( message == MEngineMonitor::EPEMessageServiceHandlingError )
 {
 TEFLOGSTRING(
 KTAERROR,
 "PE cpephonemodel::sendmessage > iEngineMonitor.HandleError: messageName=EPEMessageServiceHandlingError" );
-SetCallError( aCallId );
 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 )
 }
 if ( errorCode == ECCPErrorNone && iEngineInfo->IsSwitchToOperationOngoing() )
 {
 errorCode = iMessageHandler->ContinueSwitchToCall( aCallId );
 }
-iEngineInfo->SetOutgoingCallBarringActivated( EFalse );
 break;
 case MEngineMonitor::EPEMessageRemoteBusy:
 if ( CallIdCheck::IsVoice( aCallId ))
 {
 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;
 case MEngineMonitor::EPEMessageColpNumberAvailable:
 {
 sendingDelayed = ETrue;
 }
 break;
+case MEngineMonitor::EPEMessageTransferCallBackRequest:
+{
+sendingDelayed = ETrue;
+}
+break;
 default:
 // Other messages cause no action.
 break;
 }
 break;
 }
 case CPEPhoneModel::EPEContactHandlingPhaseTwo:
 {
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 15.1" );
-static_cast< CPEContactHandlingProxy* >( iContactHandling )->
+// Start Idle State monitor to finalize ContactHandling contruction
-CreateSecondPhaseL( *this, iFsSession );
+iIdleStatusMonitor = CPEIdleStatusMonitor::NewL (*this );
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 15.2" );
 break;
 }
 case CPEPhoneModel::EPEMediatorCommandHandler:
 {
 TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 16.1" );
 // Start Mediator command listener
 iMediatorCommunicationHandler = CPERemotePartyInfoMediator::NewL( *this );
+// This should be set after the last case
+continueStepping = EFalse;
 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);
-TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 16.2" );
-break;
-}
-case CPEPhoneModel::EPENetworkHandling:
-{
-TEFLOGSTRING( KTAOBJECT, "CPEPhoneModel::StepL: 18.1" );
-continueStepping = EFalse;
-QString service("networkhandlingstarter");
-QString interface("com.nokia.symbian.IStart");
-QString operation("start()");
-XQApplicationManager appManager;
-QScopedPointer<XQAiwRequest> request(
-appManager.create(service, interface, operation, false));
-if (request == NULL) {
-TEFLOGSTRING(KTAOBJECT,
-"CPEPhoneModel::StepL 18.2 error, service not found");
-break;
-}
-XQRequestInfo info;
-info.setForeground(false);
-request->setInfo(info);
-request->setSynchronous(false);
-if (!request->send()) {
-int error = request->lastError();
-TEFLOGSTRING2(KTAOBJECT,
-"CPEPhoneModel::StepL 18.3 error %d", error);
-break;
-}
-TEFLOGSTRING(KTAOBJECT, "CPEPhoneModel::StepL: 18.4");
-break;
-}
 default:
 {
 Panic( EPEPanicIndexOutOfRange );
 break;
 }
 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
 // -----------------------------------------------------------------------------
 self->iEngineMonitor.HandleMessage( self->iCallBackMessage, self->iCallBackCallId );
 return KErrNone;
 }
-// -----------------------------------------------------------------------------
-// SetCallError
-// -----------------------------------------------------------------------------
-//
-void CPEPhoneModel::SetCallError( TInt aCallId )
-{
-TInt callError = KErrNone;
-if ( iCallHandling )
-{
-TInt err = iCallHandling->GetCallInfo( *iCallInfo, aCallId );
-if ( err == KErrNone && ( iCallInfo->iExitCode & 0xFFFF0000 ) )
-{
-callError = ( iCallInfo->iExitCode >> KTimesToSplitValue );
-//Set protocol spesific error code to TPEErrorInfo
-EngineInfo()->SetProtocolError( callError, aCallId );
-}
-}
-}
 // End of File

branch	RCL_3
changeset 62	5266b1f337bd
parent 61	41a7f70b3818
child 69	8baf28733c3d