1 /*

     2 * Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Message handler

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include "cpecenrepmonitor.h"

    20 #include "cpeclientcallrequestmonitor.h"

    21 #include "cpeclientcallrequestmonitor.h"

    22 #include "cpeclientcommandhandlermonitor.h"

    23 #include "cpeclientservices.h"

    24 #include "cpeexternaldatahandler.h"

    25 #include "cpemanualcallcontrolhandler.h"

    26 #include "cpemessagehandler.h"

    27 #include "cpeparseremergencynumberhandler.h"

    28 #include "cpeparsermanufacturerhandler.h"

    29 #include "cpeparsermischandler.h"

    30 #include "cpeparserphonenumberhandler.h"

    31 #include "cpeparsersimcontrolhandler.h"

    32 #include "cpeparsersscallhandler.h"

    33 #include "cpeparsersshandler.h"

    34 #include "cpeparservoipnumberhandler.h"

    35 #include "cpepcnparserprocedurehandler.h"

    36 #include "cpesimstatemonitor.h"

    37 #include "cpetimer.h"

    38 #include "mpephonemodelinternal.h"

    39 #include "mpeservicehandling.h"

    40 #include "cperemotepartyinfomediator.h"

    41 

    42 #include <apacmdln.h>

    43 #include <apgcli.h>

    44 #include <apgtask.h>

    45 #include <AudioPreference.h>

    46 #include <barsc.h> 

    47 #include <barsread.h>

    48 #include <bldvariant.hrh>

    49 #include <ccpdefs.h>

    50 #include <coreapplicationuisdomainpskeys.h>

    51 #include <cpeclientinformation.h>

    52 #include <cpegsmaudiodata.h>

    53 #include <CPhoneGsmHandlerContainer.h>

    54 #include <CPhoneGsmOptionContainerBase.h>

    55 #include <CPhoneGsmParserBase.h>

    56 #include <CPhoneGsmParserResult.h>

    57 #include <featmgr.h>

    58 #include <mccecall.h>

    59 #include <mpeaudiodata.h>

    60 #include <mpecallhandling.h>

    61 #include <mpecontacthandling.h>

    62 #include <mpedatastore.h>

    63 #include <mpeloghandling.h>

    64 #include <pathinfo.h>

    65 #include <pepanic.pan>

    66 #include <PhCltTypes.h>

    67 #include <PhoneGsmParser.h>

    68 #include <ProfileEngineDomainConstants.h>

    69 #include <talogger.h>

    70 #include <w32std.h>

    71 

    72 // EXTERNAL DATA STRUCTURES

    73 // None.

    74 

    75 // EXTERNAL FUNCTION PROTOTYPES  

    76 // None.

    77 

    78 // CONSTANTS

    79 // Prefix change off. See SettingsInternalCRKeys.h

    80 const TInt KPEPrefixChangeOff = 0;

    81 // Prefix change on. See SettingsInternalCRKeys.h

    82 const TInt KPEPrefixChangeOn = 1;

    83 // International prefix

    84 _LIT( KPEIntPrefix, "+" );

    85 // Japan prefix

    86 _LIT( KPEJapanPrefix, "+81" );

    87 // Zero prefix

    88 _LIT( KPEZeroPrefix, "0" );

    89 // Valid dtmf sting

    90 _LIT( KValidDtmfChars, "0123456789pw*+#" );

    91 

    92 // Timeout for automatic answer. 

    93 const TInt KPEAutomaticAnswerTimeOut = 5000000;

    94 

    95 _LIT( KPEClirSuppress, "*31#" );

    96 _LIT( KPEClirInvoke, "#31#" );

    97 

    98 const TInt KPENumberPlus = '+';

    99 const TInt KPENumberHash = '#'; 

   100 const TInt KPENumberAsterisk = '*'; 

   101 

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

   103 

   104 // -----------------------------------------------------------------------------

   105 // CPEMessageHandler::NewL

   106 // Two-phased constructor.

   107 // -----------------------------------------------------------------------------

   108 //

   109 CPEMessageHandler* CPEMessageHandler::NewL

   110         ( 

   111         MPEPhoneModelInternal& aModel,

   112         MPECallHandling& aCallHandling,

   113         MEngineMonitor& aEngineMonitor,

   114         CPEGsmAudioData& aAudioData,

   115         MPELogHandling& aLogHandling,

   116         MPEContactHandling& aContactHandling,

   117         CPESimStateMonitor& aSimStateMonitor,

   118         CPEExternalDataHandler& aGsmExternalDataHandler,

   119         MPEServiceHandling& aServiceHandling,

   120         RFs& aFsSession )

   121     {

   122     CPEMessageHandler* self = new ( ELeave ) CPEMessageHandler( 

   123         aModel, 

   124         aCallHandling, 

   125         aEngineMonitor, 

   126         aAudioData, 

   127         aLogHandling, 

   128         aContactHandling, 

   129         aSimStateMonitor,

   130         aGsmExternalDataHandler,

   131         aServiceHandling,

   132         aFsSession );

   133     CleanupStack::PushL( self );

   134     self->ConstructL();

   135     CleanupStack::Pop( self );

   136     return self;

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CPEMessageHandler::CPEMessageHandler

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

   142 // might leave.

   143 // -----------------------------------------------------------------------------

   144 //

   145 CPEMessageHandler::CPEMessageHandler( 

   146         MPEPhoneModelInternal& aModel,                 // The model of the phone object which owns this object

   147         MPECallHandling& aCallHandling,              // The reference parameter of the phone data object which is used to create call handling request

   148         MEngineMonitor& aEngineMonitor,        // The reference parameter of the engine monitor object which is used to communication with phone application

   149         CPEGsmAudioData& aAudioData,              // The reference parameter of the audio data object which is used to handle audio requests

   150         MPELogHandling& aLogHandling,                // The reference parameter of the logs data object which is used to handle log requests   

   151         MPEContactHandling& aContactHandling,          // The reference parameter of the contact data object which is used to handle contact requests

   152         CPESimStateMonitor& aSimStateMonitor,

   153         CPEExternalDataHandler& aExternalDataHandler, // The reference parameter of external data handler object

   154         MPEServiceHandling& aServiceHandling,

   155         RFs& aFsSession )                // The reference parameter of CustomAPI

   156         : iModel( aModel ), 

   157             iCallHandling( aCallHandling ),

   158             iEngineMonitor( aEngineMonitor ),

   159             iGsmAudioData( aAudioData ),

   160             iLogHandling( aLogHandling ),

   161             iContactHandling( aContactHandling ),

   162             iExternalDataHandler( aExternalDataHandler ),

   163             iSimStateMonitor( aSimStateMonitor ),

   164             iFsSession( aFsSession ),

   165             iServiceHandling( aServiceHandling ),

   166             iDataStore( *aModel.DataStore() )

   167     {

   168     }

   169 

   170 // -----------------------------------------------------------------------------

   171 // CPEMessageHandler::BaseConstructL

   172 // Performs base construction of the object.

   173 // -----------------------------------------------------------------------------

   174 //

   175 void CPEMessageHandler::ConstructL()

   176     {

   177     iClientInformation = CPEClientInformation::NewL();

   178 

   179     iParser = PhoneGsmParser::CreateParserL();

   180     iOptions = PhoneGsmParser::CreateOptionContainerL();

   181     iManualCallControlHandler = CPEManualCallControlHandler::NewL( iCallHandling, *this, iDataStore );

   182     iClientServices = CPEClientServices::NewL( iModel, *this, iCallHandling, *iManualCallControlHandler );

   183     iParserHandlerContainer = CPhoneGsmHandlerContainer::NewL();

   184 

   185     // NOTE: The handler objects will break some CleanUpStack usage rules:

   186     // CPEMessageHandler class construct handler objects but ownership will be 

   187     // transfered to Handler Container. And therefore CleanUpStack will be 

   188     // used to member object because if iParserHandlerContainer->AddHandlerL 

   189     // leaves CPEMessageHandler don't delete handler object hence CleanUpStack

   190     // must delete handler object. 

   191 

   192     // Handles manufacturer specific codes from the parser.

   193     CPEParserManufacturerHandler* manufacturerHandler = 

   194         new ( ELeave ) CPEParserManufacturerHandler( iModel, iCallHandling, iFsSession );

   195     CleanupStack::PushL( manufacturerHandler );

   196     iParserHandlerContainer->AddHandlerL( *manufacturerHandler ); // ownership will be transfered to Handler Container.

   197     CleanupStack::Pop( manufacturerHandler );

   198 

   199     // Handles misc codes from the parser.

   200     CPEParserMiscHandler* miscHandler = new ( ELeave ) CPEParserMiscHandler( 

   201         *this, 

   202         iCallHandling );

   203     CleanupStack::PushL( miscHandler );

   204     iParserHandlerContainer->AddHandlerL( *miscHandler );// ownership will be transfered to Handler Container.

   205     CleanupStack::Pop( miscHandler );

   206 

   207     CPEParserPhoneNumberHandler* tempPhoneNumberHandler = 

   208         new ( ELeave ) CPEParserPhoneNumberHandler( *this, 

   209                                                        iCallHandling, 

   210                                                        iDataStore );

   211     CleanupStack::PushL( tempPhoneNumberHandler );

   212     iParserHandlerContainer->AddHandlerL( *tempPhoneNumberHandler ); // ownership will be transfered to Handler Container.

   213     CleanupStack::Pop( tempPhoneNumberHandler );

   214     iPhoneNumberHandler = tempPhoneNumberHandler;

   215 

   216     // Handles sim control procedures from the parser.

   217     CPEParserSimControlHandler* simControlHandler = CPEParserSimControlHandler::NewL( 

   218         iModel, 

   219         iContactHandling );

   220     CleanupStack::PushL( simControlHandler );

   221     iParserHandlerContainer->AddHandlerL( *simControlHandler );// ownership will be transfered to Handler Container.

   222     CleanupStack::Pop( simControlHandler );

   223 

   224     // Handles supplementary services during calls from the parser.

   225     CPEParserSSCallHandler* sSCallHandler = new ( ELeave ) CPEParserSSCallHandler( 

   226         *this, 

   227         iModel, 

   228         *iManualCallControlHandler );

   229     CleanupStack::PushL( sSCallHandler );

   230     iParserHandlerContainer->AddHandlerL( *sSCallHandler );// ownership will be transfered to Handler Container.

   231     CleanupStack::Pop( sSCallHandler );

   232 

   233     iSSHandler = CPEParserSSHandler::NewL( *this, iModel ); 

   234     iParserHandlerContainer->AddHandlerL( *iSSHandler );// ownership will be transfered to Handler Container.

   235 

   236     // Handles pcn service requests from the parser.

   237     CPEPcnParserProcedureHandler* pcnProcedureHandler = CPEPcnParserProcedureHandler::NewL( 

   238         *this, 

   239         iModel ); 

   240     CleanupStack::PushL( pcnProcedureHandler );

   241     iParserHandlerContainer->AddHandlerL( *pcnProcedureHandler );// ownership will be transfered to Handler Container.

   242     CleanupStack::Pop( pcnProcedureHandler );

   243     

   244     // Handles emergency phone number

   245     CPEParserEmergencyNumberHandler* tempEmergencyNumberHandler 

   246         = new ( ELeave ) CPEParserEmergencyNumberHandler( *this, 

   247                                                           iCallHandling, 

   248                                                           iDataStore );

   249     CleanupStack::PushL( tempEmergencyNumberHandler );

   250     iParserHandlerContainer->AddHandlerL( *tempEmergencyNumberHandler ); // ownership will be transfered to Handler Container.

   251     CleanupStack::Pop( tempEmergencyNumberHandler );

   252     iEmergencyNumberHandler = tempEmergencyNumberHandler;

   253 

   254     CPEParserVoipNumberHandler* tempVoipNumberHandler

   255         = CPEParserVoipNumberHandler::NewLC( *this, 

   256                                                iCallHandling, 

   257                                                iServiceHandling,

   258                                                iDataStore );

   259 

   260     iParserHandlerContainer->AddHandlerL( *tempVoipNumberHandler ); // ownership will be transfered to Handler Container.

   261     CleanupStack::Pop( tempVoipNumberHandler );

   262     iVoipNumberHandler = tempVoipNumberHandler;

   263     

   264     iAutomaticAnswerTimer = CPETimer::NewL( iModel );

   265  

   266     // Reserve needed callinfo and remoteinfo from heap.

   267     iCallInfo = new ( ELeave ) RMobileCall::TMobileCallInfoV3;

   268     

   269     iResult = PhoneGsmParser::CreateResultL();

   270     }

   271         

   272 // Destructor

   273 CPEMessageHandler::~CPEMessageHandler()

   274     {

   275     delete iClientInformation;

   276     delete iAsyncCallBack;

   277     delete iCallInfo;

   278     delete iAutomaticAnswerTimer;

   279     delete iParserHandlerContainer;

   280     delete iClientServices;

   281     delete iManualCallControlHandler;

   282     delete iOptions;

   283     delete iParser;

   284     delete iResult;

   285     }

   286 

   287 // -----------------------------------------------------------------------------

   288 // CPEMessageHandler::HandleAnswerCall

   289 // Handles answer message from phone application. Method calls AnswerCall 

   290 // method from the CallHandling subsystem.

   291 // -----------------------------------------------------------------------------

   292 //

   293 TInt CPEMessageHandler::HandleAnswerCall(

   294         const TBool aAutomaticAnswer ) // Informs is this automatic answer or not

   295     {

   296     // Stop DTMF sending and empty buffers if answer was requested in the

   297     // middle of DTMF sequence.

   298     StopDtmfSending();

   299     

   300     //Check if this is automatic answer and play redialCompletedTone (confusing naming)

   301     if( !aAutomaticAnswer )

   302         {

   303         iAutomaticAnswerTimer->Cancel();

   304         }

   305 

   306     return iCallHandling.AnswerCall();

   307     }

   308 

   309 // -----------------------------------------------------------------------------

   310 // CPEMessageHandler::HandleAudioRouting

   311 // Handles accessory mode changed message from AudioHandling subsystem. Method 

   312 // fecths accessory mode from AudioHandling subsystem and method sets new accessory

   313 // mode value to the CPEEngineInfo class. Method finds previously used volume

   314 // values for accessory and changes volume accordingly.

   315 // -----------------------------------------------------------------------------

   316 //

   317 TInt CPEMessageHandler::HandleAudioRouting( TBool aVideoCall, TInt aCallId )

   318     {

   319     TInt error( ECCPErrorNone );

   320     

   321     if ( aCallId == KPEEmergencyCallId )     

   322          {

   323          error = iGsmAudioData.HandleEnergencyCallStarting();

   324          }

   325      else

   326          {

   327          error = iGsmAudioData.HandleCallStarting( aVideoCall );

   328          }

   329     

   330     return error;

   331     }

   332 

   333 // -----------------------------------------------------------------------------

   334 // CPEMessageHandler::HandleRoutePreferenceChanged

   335 // Handles route preference changed message from AudioHandling subsystem. 

   336 // -----------------------------------------------------------------------------

   337 //

   338 TInt CPEMessageHandler::HandleRoutePreferenceChanged()

   339     {

   340     TInt error( ECCPErrorNone );

   341     

   342     TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleRoutePreferenceChanged()" );

   343     

   344     error = iGsmAudioData.CallAudioRoutePreferenceChanged();

   345      

   346     return error;

   347     }    

   348 // -----------------------------------------------------------------------------

   349 // CPEMessageHandler::HandleContinueDtmfSending

   350 // Handles continue dtmf sending after 'w' character in the dtmf string

   351 // Method calls ContinueDtmfSending or StopDtmfSending method from the 

   352 // CallHandling subsystem.

   353 // -----------------------------------------------------------------------------

   354 //

   355 void CPEMessageHandler::HandleContinueDtmfSending( 

   356         const TBool aContinue )

   357     {

   358     if ( aContinue )

   359         {

   360         HandleSendDtmf();

   361         }

   362     else

   363         {

   364         StopDtmfSending();

   365         }

   366     }

   367 

   368 // -----------------------------------------------------------------------------

   369 // CPEMessageHandler::HandleReleaseAll

   370 // Handles release all message from phone application

   371 // Method calls ReleaseAll method from the CallHandling subsystem object..

   372 // -----------------------------------------------------------------------------

   373 //

   374 TInt CPEMessageHandler::HandleReleaseAll()

   375     {

   376     return iCallHandling.ReleaseAll();

   377     }

   378 

   379 // -----------------------------------------------------------------------------

   380 // CPEMessageHandler::HandleReleaseCall

   381 // Handles release message from phone application

   382 // Method fecths call id number from the CPEEngineInfo structure and then

   383 // Method calls HangUp method from the CallHandling subsystem.

   384 // -----------------------------------------------------------------------------

   385 //

   386 TInt CPEMessageHandler::HandleReleaseCall( TPEHangUpOptions aAutoResumeOption )

   387     {

   388     TInt callId;

   389     TInt errorCode( ECCPErrorNone );

   390     callId = iDataStore.CallId();

   391     

   392     if ( CallIdCheck::IsVideo( callId ) )

   393         {

   394         //Video call

   395         iGsmAudioData.StopInbandTonePlay();

   396         errorCode = iCallHandling.HangUp( callId, ETPEHangUpNotResumeHeldCall );

   397         }

   398     else

   399         {

   400         errorCode = iCallHandling.HangUp( callId, aAutoResumeOption );

   401         }

   402     return errorCode;

   403     }

   404 

   405 // -----------------------------------------------------------------------------

   406 // CPEMessageHandler::HandleSendDtmf

   407 // Handles send dtmf message from phone application

   408 // Method fetches dtmf string from the CPEEngineInfo class and then

   409 // Method parses the DTMF string and then take action properly: 

   410 // hard pause: triggers sending MEngineMonitor::EPEMessageStoppedDTMF 

   411 //      to phone model

   412 // '+': triggers substitution speed dial digit with speed dial number. 

   413 //

   414 // Method calls SendDtmf method from the CallHandling subsystem.

   415 // -----------------------------------------------------------------------------

   416 //

   417 TInt CPEMessageHandler::HandleSendDtmf()

   418     {

   419     TInt errorCode( ECCPErrorNone );

   420     TPEDtmfString dtmfString = iDataStore.DtmfStringCommand();

   421 

   422     RemoveInvalidChars( dtmfString, KPEClientValidChars, EFalse );

   423 

   424     if ( dtmfString.Length() == 0 )

   425         {

   426         iDataStore.SetDtmfString( KNullDesC() ); 

   427         errorCode = KErrArgument;

   428         }

   429     // Parse the first character of the string

   430     else if ( dtmfString[ 0 ] == KPEDtmfStopCharLowercase || 

   431               dtmfString[ 0 ] == KPEDtmfStopCharUppercase ) // hard pause

   432         {

   433         TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Processing W" );

   434         // remove the hard pause char from the string

   435         iDataStore.SetDtmfString( dtmfString.Mid( 1 ) );

   436         iDataStore.SetDtmfStringCommand( dtmfString.Mid( 1 ) );

   437         

   438         // Send EPEMessageStoppedDTMF message asynchronic.

   439 

   440         TCallBack callBack( CallbackSendMessageStoppedDTMF, this );

   441         delete iAsyncCallBack;

   442         iAsyncCallBack = NULL;

   443         // Function does not allow to leave.

   444         iAsyncCallBack = new CAsyncCallBack( callBack, CActive::EPriorityHigh );

   445         if ( iAsyncCallBack )

   446             {

   447             iAsyncCallBack->CallBack();

   448             }

   449         else

   450             {

   451             iModel.SendMessage( MEngineMonitor::EPEMessageStoppedDTMF );

   452             }

   453         

   454         dtmfString = KNullDesC;

   455         }    

   456     else if ( dtmfString[ 0 ] == KPEDtmfPlusChar ) // speed-dial substitution

   457         {

   458         TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Processing +" );

   459         HandlePlusSignInDtmf( dtmfString );

   460         dtmfString = KNullDesC;

   461         }

   462     else if ( dtmfString[ 0 ] == KPEDtmfPauseCharLowercase || 

   463               dtmfString[ 0 ] == KPEDtmfPauseCharUppercase ) // soft pause

   464         {

   465         TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Processing P" );

   466         

   467         // store the full string for UI to display 

   468         iDataStore.SetDtmfString( dtmfString );

   469 

   470         if ( dtmfString.Length() > 1 )

   471             {

   472             // store the remainder of the string to be processed later

   473             iDataStore.SetDtmfStringCommand( dtmfString.Mid( 1 ) ); 

   474             }

   475         else

   476             {

   477             // nothing left to process

   478             iDataStore.SetDtmfStringCommand( KNullDesC() );

   479             }

   480         // set the dtmf string to send 

   481         dtmfString = dtmfString.Left( 1 );

   482         }

   483     else 

   484         {

   485         // store the full string for UI to display 

   486         iDataStore.SetDtmfString( dtmfString );

   487         

   488         // Find the next stop point

   489         TInt stopPoint = ECCPErrorNotFound;

   490         TPtrC validDtmfStringStopChars( KPEValidDTMFStringStopChars );

   491         for ( TInt index = 0 ; index < dtmfString.Length(); index++ )

   492             {

   493             if ( validDtmfStringStopChars.Locate( dtmfString[index] ) != ECCPErrorNotFound )

   494                 {

   495                 stopPoint = index;

   496                 break; 

   497                 }

   498             }

   499 

   500         if ( stopPoint != ECCPErrorNotFound ) 

   501             {

   502             // store the remainder of the string to be processed later

   503             iDataStore.SetDtmfStringCommand( dtmfString.Mid( stopPoint ) ); 

   504             // set the dtmf string to send 

   505             dtmfString = dtmfString.Left( stopPoint );            

   506             }

   507         else

   508             {

   509             // nothing left to process

   510             iDataStore.SetDtmfStringCommand( KNullDesC() );

   511             }

   512         }

   513 

   514     if ( dtmfString.Length() )  

   515         {

   516         TEFLOGSTRING2( KTAMESINT, "PE CPEMessageHandler::HandleSendDtmf(), Starting to play %S", &dtmfString );

   517         // send the dtmf string to call handling subsystem

   518         errorCode = iCallHandling.SendDtmf( dtmfString );

   519         }

   520     return errorCode;

   521     }

   522 

   523 // -----------------------------------------------------------------------------

   524 // CPEMessageHandler::CallBackHandleSendDtmf

   525 // Asyncronous callback for HandleSendDtmf() function.

   526 // -----------------------------------------------------------------------------

   527 //

   528 TInt CPEMessageHandler::CallBackHandleSendDtmf( TAny* aAny )

   529     {

   530     __ASSERT_ALWAYS( aAny , Panic( EPEPanicNullPointer ) );

   531     CPEMessageHandler* self = static_cast<CPEMessageHandler*>(aAny);

   532 

   533     delete self->iAsyncCallBack;

   534     self->iAsyncCallBack = NULL;

   535     return self->HandleSendDtmf();  

   536     }

   537 

   538 // -----------------------------------------------------------------------------

   539 // CPEMessageHandler::HandlePlusSignInDtmf

   540 // Handles plus (+) sign in a DTMF string.

   541 // -----------------------------------------------------------------------------

   542 //

   543 void CPEMessageHandler::HandlePlusSignInDtmf(const TPEDtmfString& aDtmfString )

   544     {

   545     TEFLOGSTRING2( KTAMESINT, "PE CPEMessageHandler::HandlePlusSignInDtmf(), aDtmfString: %S", &aDtmfString ); 

   546           

   547     // Find the SD index after the plus sign

   548     TPtrC validManualDTMFChars( KPEValidSpeedDialChars );

   549     TInt index = ECCPErrorNotFound;

   550     for ( index = 1 ; index < aDtmfString.Length() ; index++ )

   551         {

   552         if ( validManualDTMFChars.Locate( aDtmfString[index] ) == ECCPErrorNotFound )

   553             {

   554             TEFLOGSTRING( KTAMESINT, "PE CPEMessageHandler::HandlePlusSignInDtmf(), Not Found" ); 

   555             break; 

   556             }

   557         }

   558     TPESpeedDialSubstituionStatus sdStatus = EPEDtmfSpeedDialOk;

   559     

   560     // Empty string after the plus sign

   561     if ( index == 1 )

   562         {

   563         if ( aDtmfString.Length() > 1 )

   564             {

   565             // pw+ after the plus sign.

   566             sdStatus = EPEDtmfSpeedDialInvalidSpeedDial;

   567             }

   568         else

   569             {

   570             // string ended with the plus sign.

   571             sdStatus = EPEDtmfSpeedDialPromptUser;

   572             }

   573         // Clear DTMF string.

   574         iDataStore.SetDtmfString( KNullDesC() );

   575         }

   576     // Else if the SD location ends the DTMF string, move the index to the

   577     // last character instead of one over.

   578     else if ( index == aDtmfString.Length() )

   579         {

   580         index--;

   581         }

   582     

   583     // Check that the index is valid

   584     TInt sdIndex = ECCPErrorNotFound; 

   585     if ( sdStatus == EPEDtmfSpeedDialOk )

   586         {

   587         TLex lexer( aDtmfString.Mid( 1, index ) );

   588         // convert it to a number

   589         if ( lexer.Val(sdIndex) == ECCPErrorNone )

   590             {

   591             // Is it out of range

   592             if ( sdIndex < KPESpeedDialIndexMin  ||

   593                 sdIndex > KPESpeedDialIndexMax )

   594                 {

   595                 sdStatus = EPEDtmfSpeedDialInvalidSpeedDial;

   596                 }

   597             }

   598         else

   599             {

   600             sdStatus = EPEDtmfSpeedDialInvalidSpeedDial;

   601             }

   602         }

   603     

   604     // Fetch the SD location

   605     TPEPhoneNumber speedDialLocationString;

   606     if ( sdStatus == EPEDtmfSpeedDialOk )

   607         {

   608         TEFLOGSTRING2( KTAMESINT, "PE CPEMessageHandler::HandlePlusSignInDtmf(), SD location %i", sdIndex ); 

   609         if ( iContactHandling.GetSpeedDialLocation( 

   610             sdIndex, speedDialLocationString ) == ECCPErrorNone )

   611             {

   612             // Is content found

   613             if ( speedDialLocationString.Length() == 0)

   614                 {

   615                 sdStatus = EPEDtmfSpeedDialNotAssigned;

   616                 }

   617             else if ( speedDialLocationString[0] == KPEDtmfPlusChar)  

   618                 {

   619                 // plus char must be removed from dtmf string before sending

   620                 RemovePlusPrefix( speedDialLocationString );

   621                 }

   622             }

   623         else

   624             {

   625             sdStatus = EPEDtmfSpeedDialInvalidSpeedDial;

   626             }

   627         }

   628     

   629     // Now interpret the sdStatus to the next action

   630     switch ( sdStatus )

   631         {

   632         case EPEDtmfSpeedDialOk:

   633             {

   634             TEFLOGSTRING2( KTAMESINT, "PE CPEMessageHandler::HandlePlusSignInDtmf(), SD result: %S", &speedDialLocationString ); 

   635             // Take the SD location string and use that as new DTMF string

   636             iDataStore.SetDtmfStringCommand( speedDialLocationString );

   637             

   638             // Do recursion asyncronously                        

   639             TCallBack callBack( CallBackHandleSendDtmf, this );

   640             delete iAsyncCallBack;

   641             iAsyncCallBack = NULL;

   642             // Function does not allow to leave.

   643             iAsyncCallBack = new CAsyncCallBack( callBack, CActive::EPriorityStandard );

   644             if ( iAsyncCallBack )

   645                 {

   646                 iAsyncCallBack->CallBack();

   647                 }

   648             else

   649                 {

   650                 iModel.SendMessage( MEngineMonitor::EPEMessageDTMFSendingAborted );

   651                 }

   652             }

   653             break;

   654         case EPEDtmfSpeedDialPromptUser:

   655             // Speed dial location not given.

   656             iDataStore.SetDtmfString( KNullDesC() );

   657             iModel.SendMessage( MEngineMonitor::EPEMessagePromptSpeedDial );

   658             break;

   659         case EPEDtmfSpeedDialNotAssigned:

   660             // Speed dial location valid but not assigned

   661             iDataStore.SetDtmfString( KNullDesC() );

   662             iDataStore.SetDtmfStringCommand( KNullDesC() );

   663             iModel.SendMessage( MEngineMonitor::EPEMessageDTMFSendingAborted);

   664             iModel.SendMessage( MEngineMonitor::EPEMessageSpeedDialNotAssigned );

   665             break;

   666         case EPEDtmfSpeedDialInvalidSpeedDial:

   667             // Speed dial location invalid

   668             iDataStore.SetDtmfString( KNullDesC() );

   669             iDataStore.SetDtmfStringCommand( KNullDesC() );

   670             iModel.SendMessage( MEngineMonitor::EPEMessageDTMFSendingAborted);

   671             iModel.SendMessage( MEngineMonitor::EPEMessageInvalidSpeedDial );

   672             break;

   673         default:

   674             Panic( EPEPanicInvalidState );

   675             break;

   676         } // end switch

   677     }

   678 

   679 // -----------------------------------------------------------------------------

   680 // CPEMessageHandler::CheckPrefix

   681 // Checks the status of phone number prefix change setting

   682 // and calls CPEMessageHandler::ChangePrefix for execution.

   683 // If error occurs the phone number is left untouched

   684 // -----------------------------------------------------------------------------

   685 //

   686 void CPEMessageHandler::CheckPrefix()

   687     {

   688     TInt err = ECCPErrorNone;

   689     TBool checkPrefix = 

   690         FeatureManager::FeatureSupported( KFeatureIdJapanPrefixChange );

   691 

   692     if ( checkPrefix )

   693         {

   694         TInt prefixMode = KPEPrefixChangeOff; // Default is "off"

   695 

   696         err = iExternalDataHandler.Get(

   697             EPEDialPrefixChangeSetting,

   698             prefixMode );

   699 

   700         if ( !err )

   701             {

   702             if ( prefixMode == KPEPrefixChangeOn )

   703                 {

   704                 TPEPrefixText prefixText;

   705                 

   706                 err = iExternalDataHandler.GetText(

   707                     EPEDialPrefixTextSetting,

   708                     prefixText );

   709 

   710                 if ( !err )

   711                     {

   712                     err = ChangePrefix( prefixText );

   713                     }

   714                 }

   715             }

   716         }

   717     }

   718 

   719 // -----------------------------------------------------------------------------

   720 // CPEMessageHandler::ChangePrefix

   721 // Executes phone number prefix change.

   722 // -----------------------------------------------------------------------------

   723 //

   724 TInt CPEMessageHandler::ChangePrefix(

   725     const TPEPrefixText& aPrefixText )

   726     {

   727     TInt err = ECCPErrorNone;

   728 

   729     const TInt beginning = 0; // The beginning for replacement.

   730     TInt replaceLength = 0; // The string length to be replaced.

   731     TInt location = ECCPErrorNotFound; // The location of searched string.

   732     TPEPhoneNumber phoneNumber = iDataStore.PhoneNumber();

   733 

   734     // Try to find Japan prefix.

   735     location = phoneNumber.Find( KPEJapanPrefix );

   736     if ( location == beginning )

   737         {

   738         // The string was found, so make replacement. 

   739         // Safe because KPEZeroPrefix < KPEJapanPrefix.

   740         replaceLength = KPEJapanPrefix().Length();

   741         phoneNumber.Replace( beginning, replaceLength, KPEZeroPrefix );

   742         }

   743     else

   744         {

   745         // Try to find international prefix.

   746         location = phoneNumber.Find( KPEIntPrefix );

   747         if ( location == beginning )

   748             {

   749             replaceLength = KPEIntPrefix().Length();

   750             // The string was found, so try to make replacement. 

   751             const TInt phoneNumLength = phoneNumber.Length();

   752             const TInt prefixLength = aPrefixText.Length();

   753 

   754             TInt stringLength = 

   755                 ( phoneNumLength + prefixLength - replaceLength );

   756 

   757             if ( phoneNumber.MaxLength() >= stringLength )

   758                 {

   759                 // There is enough space to make this replace.

   760                 phoneNumber.Replace( beginning, replaceLength, aPrefixText );

   761                 }

   762             else

   763                 {

   764                 // There is no space to combine the strings, so inform it.

   765                 err = KErrOverflow;

   766                 }

   767             }

   768         }

   769 

   770     if ( err == ECCPErrorNone )

   771         {

   772         iDataStore.SetPhoneNumber( phoneNumber );

   773         }

   774 

   775     return err;

   776     }

   777 

   778 // -----------------------------------------------------------------------------

   779 // CPEMessageHandler::HandleDtmfSent

   780 // Handles DTMF sent message from the CallHandling subsystem.

   781 // -----------------------------------------------------------------------------

   782 //

   783 TInt CPEMessageHandler::HandleDtmfSent()

   784     {

   785     TInt errorCode( ECCPErrorNone );

   786 

   787     // check if there are still parts of the string left to process

   788     if ( iDataStore.DtmfStringCommand().Length() ) 

   789         {

   790         HandleSendDtmf();

   791         errorCode = KPEDontSendMessage;

   792         }

   793     else 

   794         {

   795         // dtmf sending complete

   796         iDataStore.SetDtmfString( KNullDesC() );

   797         }

   798     return errorCode;

   799     }

   800 

   801 // -----------------------------------------------------------------------------

   802 // CPEMessageHandler::StopPlayingDtmf

   803 // Stops/Cancels playing dtmf tones and string (audio feedback and network)

   804 // -----------------------------------------------------------------------------

   805 //

   806 void CPEMessageHandler::StopDtmfSending()

   807     {

   808     // cancel subtitution callback:

   809     if ( iAsyncCallBack )

   810         {

   811         iAsyncCallBack->Cancel();

   812         delete iAsyncCallBack;

   813         iAsyncCallBack = NULL;

   814         }

   815 

   816     iCallHandling.StopDtmfSending();

   817     

   818     iDataStore.SetDtmfString( KNullDesC() ); 

   819     iDataStore.SetDtmfStringCommand( KNullDesC() );

   820     }

   821 

   822 // -----------------------------------------------------------------------------

   823 // CPEMessageHandler::HandleSetAudioMute

   824 // Handles audio mute message from the phone application.

   825 // Method fecths mute value from the CPEEngineInfo and then

   826 // Method sets mute value to the AudioHandling subsystem.

   827 // (other items were commented in a header).

   828 // -----------------------------------------------------------------------------

   829 //

   830 void CPEMessageHandler::HandleSetAudioMute()

   831     {

   832     TEFLOGSTRING( KTAGENERAL, "PE: CPEMessageHandler::HandleSetAudioMute" );

   833     TBool mute = iDataStore.AudioMuteCommand();

   834     iGsmAudioData.SetAudioMuteSync( mute );

   835     }

   836 

   837 // -----------------------------------------------------------------------------

   838 // CPEMessageHandler::HandleSetAudioOutput

   839 // Handles audio output from the phone application.

   840 // Method fecths output and note values from the CPEEngineInfo and then

   841 // -----------------------------------------------------------------------------

   842 //

   843 TInt CPEMessageHandler::HandleSetAudioOutput()

   844     {

   845     TEFLOGSTRING( KTAGENERAL, "PE: CPEMessageHandler::HandleSetAudioOutput" );

   846     return iGsmAudioData.SetAudioOutput( iDataStore.AudioOutputCommand(),

   847                                       iDataStore.ShowNoteCommand() );

   848     }

   849 

   850 // -----------------------------------------------------------------------------

   851 // CPEMessageHandler::HandleSetAudioVolume

   852 // Handles change volume message from the phone application.

   853 // Method fecths volume value from the CPEEngineInfo and then

   854 // Method sets volume value to the AudioHandling subsystem.

   855 // -----------------------------------------------------------------------------

   856 //

   857 void CPEMessageHandler::HandleSetAudioVolume()

   858     {    

   859     TInt volume = iDataStore.AudioVolumeCommand();

   860     TEFLOGSTRING2( KTAGENERAL, "PE: CPEMessageHandler::HandleSetAudioVolume %d", volume );

   861     iGsmAudioData.SetAudioVolumeSync( volume );

   862     }

   863 

   864 // -----------------------------------------------------------------------------

   865 // CPEMessageHandler::HandlePlayDTMFL

   866 // Handles key down event.

   867 // -----------------------------------------------------------------------------

   868 //

   869 void CPEMessageHandler::HandlePlayDTMFL()

   870     {

   871     ProcessPlayDTMFL();

   872     }

   873 

   874 // -----------------------------------------------------------------------------

   875 // CPEMessageHandler::HandleEndDTMF

   876 // Handles key up event.

   877 // -----------------------------------------------------------------------------

   878 //

   879 TInt CPEMessageHandler::HandleEndDTMF()

   880     {

   881     return ProcessEndDTMF();

   882     }

   883     

   884 // -----------------------------------------------------------------------------

   885 // CPEMessageHandler::SetClientInformation

   886 // Sets client information.

   887 // -----------------------------------------------------------------------------

   888 // 

   889 void CPEMessageHandler::SetClientInformation(

   890         const TInt aCallId,  

   891         const TDesC& aMainPartOfPhoneNumber ) 

   892     {

   893     // Other ClientInformation it was already set before, in SetClientData

   894     // method. Methods is called from HandleClientCallDataL before CallId is known.

   895     iClientInformation->SetNumber( aMainPartOfPhoneNumber );

   896     

   897     iDataStore.SetCallClientInformation( *iClientInformation, aCallId );

   898     

   899     const TPECallOrigin& origin = iDataStore.CallOriginCommand();    

   900     iDataStore.SetCallOrigin( origin, aCallId );    

   901     }

   902  

   903 // -----------------------------------------------------------------------------

   904 // CPEMessageHandler::SetClientData

   905 // Sets client dial data to member variable.

   906 // -----------------------------------------------------------------------------

   907 // 

   908 void CPEMessageHandler::SetClientData(

   909         const CPhCltDialData& aClientDialData ) 

   910     {

   911     CCCECallParameters& params = iDataStore.CallParameters();

   912     

   913     iClientDialData = &const_cast<CPhCltDialData&>( aClientDialData );

   914 

   915     iClientInformation->SetName( iClientDialData->Name() );

   916     

   917     if ( iClientDialData->CallType() == EPhCltVideo || 

   918         iClientDialData->CallType() == EPhCltForcedVideo )

   919         {

   920         iClientInformation->SetCallType( EPECallTypeVideo );

   921         iDataStore.SetCallTypeCommand( EPECallTypeVideo );

   922         params.SetCallType( CCPCall::ECallTypeVideo );

   923         }

   924     else if ( iClientDialData->CallType() == EPhCltCallVoIP )

   925         {

   926         iClientInformation->SetCallType( EPECallTypeVoIP );

   927         iDataStore.SetCallTypeCommand( EPECallTypeVoIP );        

   928         params.SetCallType( CCPCall::ECallTypePS );

   929         }

   930     else

   931         {

   932         iClientInformation->SetCallType( EPECallTypeCSVoice );

   933         iDataStore.SetCallTypeCommand( EPECallTypeCSVoice );

   934         params.SetCallType( CCPCall::ECallTypeCSVoice );

   935         }

   936       

   937     iClientInformation->SetEndOtherCalls( iClientDialData->EndOtherCalls() );

   938     

   939     iClientInformation->SetAllowMatch( iClientDialData->AllowMatch() );

   940     

   941     iClientInformation->SetContactLink( iClientDialData->ContactLink() );

   942    

   943     iClientInformation->SetShowNumber( iClientDialData->ShowNumber() );

   944 

   945     // Not accept 0, TODO Requirement clarification needed, 

   946     // does service id 0 need special handling!

   947     if ( iClientDialData->ServiceId() != 0 )

   948         {

   949         iDataStore.SetServiceIdCommand( iClientDialData->ServiceId() );

   950         params.SetServiceId( iClientDialData->ServiceId() );

   951         }

   952         

   953     iDataStore.SetUserToUserInformation( iClientDialData->UUI() );

   954     

   955     params.SetBearer( iClientDialData->Bearer() );

   956     params.SetSubAddress( iClientDialData->SubAddress() );

   957     

   958     if ( iClientDialData->SATCall() )

   959         {

   960         params.SetOrigin( CCCECallParameters::ECCECallOriginSAT );

   961         }

   962     else

   963         {

   964         params.SetOrigin( CCCECallParameters::ECCECallOriginPhone );

   965         }

   966     }

   967      

   968 // -----------------------------------------------------------------------------

   969 // CPEMessageHandler::HandleTerminateAllConnections

   970 // Method resets redial timer if active and calls TerminateAllConnection 

   971 // method from the CallHandling subsytem object.

   972 // -----------------------------------------------------------------------------

   973 //

   974 TInt CPEMessageHandler::HandleTerminateAllConnections()

   975     {

   976     TInt errorCode( ECCPErrorNone );

   977     errorCode = iCallHandling.TerminateAllConnections();

   978     TEFLOGSTRING2( 

   979         KTAGENERAL, 

   980         "PE: CPEMessageHandler::HandleTerminateAllConnections: Callhandling::TerminateAllConnections() called, Error code: %d", 

   981         errorCode );

   982 

   983     return errorCode;

   984     }

   985 

   986 // -----------------------------------------------------------------------------

   987 // CPEMessageHandler::IsItCharThatCanDelete

   988 // Checks if character can be delete. If given charter can be located from 

   989 // KPECharsThatCanBeDelete, method returns ETrue else EFalse.

   990 // -----------------------------------------------------------------------------

   991 //

   992 TBool CPEMessageHandler::IsItCharThatCanDelete( 

   993         const TChar& aChar ) const

   994     {

   995     TPtrC Invalid( KPECharsThatCanBeDelete );

   996 

   997     return Invalid.Locate( aChar ) != ECCPErrorNotFound;

   998     }

   999 

  1000 // -----------------------------------------------------------------------------

  1001 // CPEMessageHandler::IsValidChar

  1002 // Checks if character is acceptable. If given charter can be located from 

  1003 // KPEClientValidChars, method returns ETrue else EFalse.

  1004 // -----------------------------------------------------------------------------

  1005 //

  1006 TBool CPEMessageHandler::IsValidChar( 

  1007         const TChar& aChar, //character to be checked

  1008         const TDesC& aValidChars ) const

  1009     {

  1010     return aValidChars.Locate( aChar ) != ECCPErrorNotFound;

  1011     }

  1012 

  1013 // -----------------------------------------------------------------------------

  1014 // CPEMessageHandler::RemoveInvalidChars

  1015 // Check all characters validity from descriptor one by one. 

  1016 //    (1) If chater is valid then OK and next charter... 

  1017 //    (2) If invalid check if that can be delete from string.

  1018 //    (3) If it can be delete then DELETE and next charter... 

  1019 //    (4) But if charter can NOT be delete then return value is EFalse.

  1020 // -----------------------------------------------------------------------------

  1021 //

  1022 TBool CPEMessageHandler::RemoveInvalidChars( 

  1023         TDes& aString, //string to be processed

  1024         const TDesC& aValidChars,

  1025         const TBool aCheckForDelete ) const

  1026     {

  1027     TBool returnValue = ETrue;

  1028     TInt index = aString.Length() - 1;

  1029 

  1030     TEFLOGSTRING2( KTAGENERAL, 

  1031         "PE: CPEMessageHandler::RemoveInvalidChars, String to parse = %S", &aString );

  1032 

  1033     for ( ; index >= 0; index-- )

  1034         {

  1035         if ( !IsValidChar( aString[ index ], aValidChars ) )//(1)

  1036             {

  1037             if ( !aCheckForDelete 

  1038                 || ( aCheckForDelete && IsItCharThatCanDelete( aString[index] ) ) )//(2)

  1039                 {

  1040                 aString.Delete( index, 1 ); // one character  //(3)

  1041                 }

  1042             else

  1043                 {

  1044                 returnValue = EFalse;//(4) //if String includes alphabets or other forbidden characters return TFalse

  1045                 }

  1046             }

  1047         }

  1048     if ( aCheckForDelete )

  1049         {

  1050         TLex input( aString );

  1051 

  1052         TLexMark start;

  1053         input.Mark( start );

  1054 

  1055         while ( input.Peek().IsDigit() ) 

  1056             {

  1057             input.Inc();

  1058             }

  1059 

  1060         TPtrC mainpart( input.MarkedToken( start ) );

  1061         if ( mainpart.Length() )

  1062             {

  1063             aString = mainpart;

  1064             }

  1065     

  1066         if ( input.Remainder().Length() > 0 )

  1067             {

  1068             TPEDtmfString dtmfString = input.Remainder();

  1069             iDataStore.SetDtmfStringCommand( dtmfString );

  1070             }

  1071         else

  1072             {

  1073             TPEDtmfString dtmfString( KNullDesC );

  1074             iDataStore.SetDtmfStringCommand( dtmfString );

  1075             } 

  1076         

  1077         }

  1078     TEFLOGSTRING2( 

  1079         KTAGENERAL, 

  1080         "PE: CPEMessageHandler::RemoveInvalidChars, Parsed string = %S", 

  1081         &aString);

  1082     return returnValue;

  1083     }

  1084 

  1085 

  1086 // -----------------------------------------------------------------------------

  1087 // CPEMessageHandler::HandleGetLifeTimerData

  1088 // Reads lifetimerdata from custom api and stores it to engine info

  1089 // -----------------------------------------------------------------------------

  1090 //

  1091 TInt CPEMessageHandler::HandleGetLifeTimerData() const

  1092     {

  1093     TCCPLifeTimeData lifeTimeData; 

  1094     TCCPLifeTimeDataPckg pckg( lifeTimeData );

  1095 

  1096     if ( iCallHandling.GetLifeTime( pckg ) )

  1097         {

  1098         TEFLOGSTRING2( 

  1099             KTAGENERAL, 

  1100             "PE: CPEMessageHandler::HandleGetLifeTimerData, iHours = %d", 

  1101             lifeTimeData.iHours);

  1102         TEFLOGSTRING2( 

  1103             KTAGENERAL, 

  1104             "PE: CPEMessageHandler::HandleGetLifeTimerData, iMinutes = %d", 

  1105             lifeTimeData.iMinutes);

  1106             

  1107         iDataStore.SetLifeTimerData( pckg );

  1108         }

  1109     

  1110     return ECCPErrorNone;

  1111     }

  1112     

  1113 // -----------------------------------------------------------------------------

  1114 // CPEMessageHandler::CallbackSendMessageStoppedDTMF

  1115 // -----------------------------------------------------------------------------

  1116 //

  1117 TInt CPEMessageHandler::CallbackSendMessageStoppedDTMF( TAny* aAny )

  1118     {

  1119     __ASSERT_ALWAYS( aAny , Panic( EPEPanicNullPointer ) );

  1120     CPEMessageHandler* self = static_cast<CPEMessageHandler*>(aAny);

  1121 

  1122     delete self->iAsyncCallBack;

  1123     self->iAsyncCallBack = NULL;

  1124     self->iModel.SendMessage( MEngineMonitor::EPEMessageStoppedDTMF ); 

  1125 

  1126     return ECCPErrorNone;

  1127     }

  1128     

  1129 // -----------------------------------------------------------------------------

  1130 // CPEMessageHandler::RemovePlusPrefix

  1131 // Remove '+' from begin of the string

  1132 // -----------------------------------------------------------------------------

  1133 //

  1134 void CPEMessageHandler::RemovePlusPrefix(