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

equal deleted inserted replaced

-:40a3f856b14d
+:41a7f70b3818
 //  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;
-if ( iIdleStatusMonitor )
+delete iPhoneServices;
-{
-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->HandleReleaseConference();
+errorCode = iMessageHandler->HandleReleaseCall( );
 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" );
-// Start Idle State monitor to finalize ContactHandling contruction
+static_cast< CPEContactHandlingProxy* >( iContactHandling )->
-iIdleStatusMonitor = CPEIdleStatusMonitor::NewL (*this );
+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);
+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;
-// This should be set after the last case
+QScopedPointer<XQAiwRequest> request(
-continueStepping = EFalse;
+appManager.create(service, interface, operation, false));
-break;
+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 61	41a7f70b3818
parent 44	3c221667e687
child 62	5266b1f337bd