1 /*

     2 * Copyright (c) 2005-2009 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: Implementation of CPhoneState class.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <avkon.rsg>

    21 #include <bautils.h>

    22 #include <eikenv.h>

    23 #include <StringLoader.h>

    24 #include <pevirtualengine.h>

    25 #include <mpeclientinformation.h>

    26 #include <mpeengineinfo.h>

    27 #include <cpephonemodelif.h>

    28 #include <featmgr.h>

    29 #include <rconnmon.h>

    30 #include <Profile.hrh>

    31 #include <PUAcodes.hrh>

    32 #include <AknUtils.h>

    33 #include <telephonyvariant.hrh>

    34 #include <aknsoundsystem.h>

    35 #include <wlaninternalpskeys.h>

    36 #include <btengdomainpskeys.h>

    37 #include <btengdomaincrkeys.h>

    38 #include <settingsinternalcrkeys.h>

    39 #include <starterclient.h>

    40 #include <rsssettings.h>

    41 #include <UikonInternalPSKeys.h>

    42 #include <telephonydomainpstypes.h>

    43 #include <telinformationpskeys.h>

    44 #include <coreapplicationuisdomainpskeys.h>

    45 #include <mccecall.h>

    46 #include <ccpdefs.h>

    47 #include <LogsDomainCRKeys.h>

    48 #include <spsettings.h>

    49 #include <startupdomainpskeys.h>

    50 #include <MediatorDomainUIDs.h>

    51 #include <videotelcontrolmediatorapi.h>

    52 #include <textresolver.h>

    53 #include <phoneappvoipcommands.hrh>

    54 #include <hwrmdomainpskeys.h>

    55 

    56 #include "phoneui.pan"

    57 #include "cphonestate.h"

    58 #include "mphonestatemachine.h"

    59 #include "mphoneviewcommandhandle.h"

    60 #include "tphonecmdparamboolean.h"

    61 #include "tphonecmdparaminteger.h"

    62 #include "tphonecmdparamkeyevent.h"

    63 #include "tphonecmdparamdynmenu.h"

    64 #include "tphonecmdparamcallheaderdata.h"

    65 #include "tphonecmdparamincallindicatordata.h"

    66 #include "tphonecmdparamnote.h"

    67 #include "tphonecmdparamkeycapture.h"

    68 #include "tphonecmdparamglobalnote.h"

    69 #include "tphonecmdparamquery.h"

    70 #include "tphonecmdparamstring.h"

    71 #include "tphonecmdparamcallstatedata.h"

    72 #include "tphonecmdparambitmap.h"

    73 #include "tphonecmdparamaudiooutput.h"

    74 #include "tphonecmdparamaudioavailability.h"

    75 #include "tphonecmdparamappinfo.h"

    76 #include "tphonecmdparamtranseffect.h"

    77 #include "tphonecmdparamringtone.h"

    78 #include "tphonecmdparamcustomdialer.h"

    79 #include "cphonekeys.h"

    80 #include "phoneui.hrh"

    81 #include "phonerssbase.h"

    82 #include "cphonebtaadisconnecthandler.h"

    83 #include "cphonemainresourceresolver.h"

    84 #include "cphonecenrepproxy.h"

    85 #include "cphonepubsubproxy.h"

    86 #include "phoneviewcommanddefinitions.h"

    87 #include "phonelogger.h"

    88 #include "phonestatedefinitions.h"

    89 #include "cphonetimer.h"

    90 #include "cphonereconnectquery.h"

    91 #include "mphoneerrormessageshandler.h"

    92 #include "cphoneclearblacklist.h"

    93 #include "mphonecustomization.h"

    94 #include "cphonemainerrormessageshandler.h"

    95 #include "cphoneaccessorybthandler.h"

    96 #include "cphonemediatorfactory.h"

    97 #include "mphonemediatormessage.h"

    98 #include "cphonemediatorsender.h"

    99 #include "cphonereleasecommand.h"

   100 #include "cphonecontinueemergencycallcommand.h"

   101 #include "cphonecallheadermanager.h"

   102 #include "cphonenumberentrymanager.h"

   103 #include "tphonecmdparamsfidata.h" 

   104 #include "mphonestorage.h"

   105 #include "phoneconstants.h"

   106 #include "cphoneclearblacklist.h"

   107 

   108 // ================= MEMBER FUNCTIONS =======================

   109 

   110 EXPORT_C CPhoneState::CPhoneState(

   111     MPhoneStateMachine* aStateMachine,

   112     MPhoneViewCommandHandle* aViewCommandHandle,

   113     MPhoneCustomization* aCustomization) :

   114     iStateMachine( aStateMachine ),

   115     iViewCommandHandle( aViewCommandHandle ),

   116     iCustomization( aCustomization ),

   117     iEnv( *CEikonEnv::Static() )

   118     {

   119     // Need to get current SimState for inherited classis

   120     iPreviousSimState = SimState();

   121     __ASSERT_ALWAYS(

   122         aStateMachine && aViewCommandHandle,

   123         Panic( EPhoneCtrlParameterNotInitialized ) );

   124     if ( FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) )

   125         {

   126         iOnScreenDialer = ETrue;

   127         }

   128     }

   129 

   130 EXPORT_C void CPhoneState::BaseConstructL()

   131     {

   132     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::BaseConstructL() ");

   133     if ( !iCbaManager )

   134         {

   135         iCbaManager = CPhoneCbaManager::NewL(

   136                         this,

   137                         *iViewCommandHandle,

   138                         *iStateMachine );

   139         }

   140     }

   141 

   142 EXPORT_C CPhoneState::~CPhoneState()

   143     {

   144     if( iAlsLineChangeKeyPressTimer )

   145         {

   146         if( iAlsLineChangeKeyPressTimer->IsActive() )

   147             {

   148             iAlsLineChangeKeyPressTimer->CancelTimer();

   149             }

   150         delete iAlsLineChangeKeyPressTimer;

   151         }

   152     delete iNumberEntryManager;

   153     delete iCallHeaderManager;

   154     delete iCbaManager;

   155     }

   156 

   157 // <-------------------------- PHONE ENGINE EVENTS --------------------------->

   158 

   159 // -----------------------------------------------------------

   160 // CPhoneState::HandlePhoneEngineMessageL

   161 // Default handling for Phone Engine messages

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

   163 // -----------------------------------------------------------

   164 //

   165 EXPORT_C void CPhoneState::HandlePhoneEngineMessageL(

   166     const TInt aMessage,

   167     TInt aCallId )

   168     {

   169     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandlePhoneEngineMessageL() ");

   170 

   171     CPhoneAccessoryBTHandler* accessoryBtHandler;

   172 

   173     switch ( aMessage )

   174         {

   175         case MEngineMonitor::EPEMessageNetworkRegistrationStatusChange:

   176             {

   177             __PHONELOG1( EBasic, EPhoneControl,

   178                "PHONEUI_ERROR: EPEMessageNetworkRegistrationStatusChange - RegistrationStatus =%d ",

   179                iStateMachine->PhoneEngineInfo()->NetworkRegistrationStatus());

   180             }

   181             break;

   182 

   183         case MEngineMonitor::EPEMessageAudioMuteChanged:

   184             HandleAudioMuteChangedL();

   185             break;

   186 

   187         case MEngineMonitor::EPEMessageAudioOutputChanged:

   188             HandleAudioOutputChangedL();

   189             // Go to current state implementation

   190             iCbaManager->UpdateInCallCbaL();

   191             break;

   192 

   193         case MEngineMonitor::EPEMessageAvailableAudioOutputsChanged:

   194             HandleAudioAvailableOutputChangedL();

   195             if ( iStateMachine->PhoneEngineInfo()->AudioOutput() != EPENotActive )

   196                 {

   197                 // Go to current state implementation

   198                 iCbaManager->UpdateInCallCbaL();

   199                 }

   200             break;

   201 

   202         case MEngineMonitor::EPEMessageChangedCallDuration:

   203             HandleChangedCallDurationL( aCallId );

   204             break;

   205 

   206         case MEngineMonitor::EPEMessageRemoteBusy:

   207             HandleRemoteBusyL( aCallId );

   208             break;

   209 

   210         case MEngineMonitor::EPEMessageCallWaiting:

   211             SendGlobalInfoNoteL( EPhoneWaitingText );

   212             break;

   213 

   214         case MEngineMonitor::EPEMessageProfileChanged:

   215             {

   216             TPhoneCmdParamBoolean keypadVolumeParam;

   217             if ( iStateMachine->PhoneEngineInfo()->KeypadVolume() == 0 )

   218                 {

   219                 iViewCommandHandle->ExecuteCommandL( EPhoneViewKeypadAudioDisabled );

   220                 }

   221             else

   222                 {

   223                 iViewCommandHandle->ExecuteCommandL( EPhoneViewKeypadAudioEnabled );

   224                 }

   225             UpdateProfileDisplayL();

   226             }

   227             break;

   228 

   229         case MEngineMonitor::EPEMessageRemoteTerminated:

   230             // Close menu bar, if it is displayed, for call ending note

   231             iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   232             /* Flow through */

   233         case MEngineMonitor::EPEMessageDisconnecting:

   234             HandleDisconnectingL( aCallId );

   235             break;

   236 

   237         case MEngineMonitor::EPEMessageTransferDone:

   238             SendGlobalInfoNoteL( EPhoneInCallTransferred );

   239             break;

   240 

   241        case MEngineMonitor::EPEMessageInitiatedEmergencyCall:

   242             HandleInitiatedEmergencyCallL( aCallId );

   243             break;

   244 

   245        case MEngineMonitor::EPEMessageInitiatedEmergencyWhileActiveVideo:

   246            HandleInitiatedEmergencyWhileActiveVideoL();

   247            break;

   248 

   249         case MEngineMonitor::EPEMessageShowIMEI:

   250             // Stop playing DTMF tone

   251             iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

   252             HandleShowImeiL();

   253             break;

   254 

   255         case MEngineMonitor::EPEMessageCallSecureStatusChanged:

   256             HandleCallSecureStatusChangeL( aCallId );

   257 

   258             if ( iCustomization )

   259                 {

   260                 iCustomization->HandlePhoneEngineMessageL( aMessage,

   261                     aCallId );

   262                 }

   263             break;

   264 

   265         case MEngineMonitor::EPEMessageActivateWarrantyMode:

   266             // Stop playing DTMF tone

   267             iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

   268             HandleShowLifeTimerL();

   269             break;

   270 

   271         case MEngineMonitor::EPEMessageIssuingUSSDRequest:

   272             {

   273              // Enable global notes

   274             TPhoneCmdParamBoolean globalNotifierParam;

   275             globalNotifierParam.SetBoolean( EFalse );

   276             iViewCommandHandle->ExecuteCommandL(

   277                 EPhoneViewSetGlobalNotifiersDisabled,

   278                 &globalNotifierParam );

   279 

   280             if ( !IsOnScreenDialerSupported() && IsNumberEntryUsedL() )

   281                 {

   282                 // Remove number entry from screen

   283                 iViewCommandHandle->ExecuteCommandL(

   284                     EPhoneViewRemoveNumberEntry );

   285                 }

   286             else if ( IsOnScreenDialerSupported() )

   287                 {

   288                 NumberEntryClearL();

   289                 }

   290             }

   291             break;

   292 

   293         case MEngineMonitor::EPEMessageIssuedUSSDRequest:

   294             // Go to current state implementation

   295             iCbaManager->UpdateInCallCbaL();

   296             break;

   297 

   298         // *#9990#

   299         case MEngineMonitor::EPEMessageShowBTLoopback:

   300             // Stop playing DTMF tone

   301             iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

   302             accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(

   303                 iViewCommandHandle, iStateMachine, this );

   304             accessoryBtHandler->ShowBTLoopbackL();

   305             CleanupStack::PopAndDestroy( accessoryBtHandler );

   306             break;

   307 

   308         // *#2820#

   309         case MEngineMonitor::EPEMessageShowBTDeviceAddress:

   310             // Stop playing DTMF tone

   311             iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

   312             accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(

   313                 iViewCommandHandle, iStateMachine, this );

   314             accessoryBtHandler->ShowBTAddressL();

   315             CleanupStack::PopAndDestroy( accessoryBtHandler );

   316             break;

   317 

   318         // *#7370#

   319         case MEngineMonitor::EPEMessageActivateRfsDeep:

   320             // Stop playing DTMF tone

   321             iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

   322             // Launch RFS

   323             iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsDeep );

   324             if ( !IsOnScreenDialerSupported() )

   325                 {

   326                 // Do state-specific operation when number entry is cleared

   327                 HandleNumberEntryClearedL();

   328                 }

   329             break;

   330 

   331         // *#7780#

   332         case MEngineMonitor::EPEMessageActivateRfsNormal:

   333             // Stop playing DTMF tone

   334             iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

   335             // Launch RFS

   336             iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsNormal );

   337             if ( !IsOnScreenDialerSupported() )

   338                 {

   339                 // Do state-specific operation when number entry is cleared

   340                 HandleNumberEntryClearedL();

   341                 }

   342             break;

   343         // *#62209526#

   344         case MEngineMonitor::EPEMessageShowWlanMacAddress:

   345             // Stop playing DTMF tone

   346             iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );

   347             ShowWlanMacAddressL();

   348             break;

   349 

   350         case MEngineMonitor::EPEMessageThumbnailLoadingCompleted:

   351             // Update call buble

   352             UpdateRemoteInfoDataL( aCallId );

   353             break;

   354 

   355         case MEngineMonitor::EPEMessageRemotePartyInfoChanged:

   356             UpdateRemoteInfoDataL ( aCallId );

   357             break;

   358 

   359         case MEngineMonitor::EPEMessageSIMStateChanged:

   360             __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::HandlePhoneEngineMessageL - simStateChanged =%d", SimState()  );

   361             HandleSimStateChangedL();

   362             break;

   363 

   364         case MEngineMonitor::EPEMessageShowIncCallGroupIndex:

   365             HandleCugInUseNoteL();

   366             break;

   367 

   368         // *#2873#

   369         case MEngineMonitor::EPEMessageBTDebugMode:

   370             accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(

   371                 iViewCommandHandle, iStateMachine, this );

   372             accessoryBtHandler->SetBTDebugModeL();

   373             CleanupStack::PopAndDestroy( accessoryBtHandler );

   374             break;

   375 

   376         default:

   377 

   378             TBool handled( EFalse );

   379 

   380             if ( iCustomization )

   381                 {

   382                 handled = iCustomization->HandlePhoneEngineMessageL(

   383                                 aMessage, aCallId );

   384                 }

   385 

   386             if ( EFalse == handled )

   387                 {

   388                 MPhoneMediatorMessage* mediatorMessage = CPhoneMediatorFactory::Instance()->MediatorMessage( aMessage, aCallId );

   389                 if( mediatorMessage )

   390                     {

   391                     CleanupDeletePushL( mediatorMessage );

   392                     mediatorMessage->ExecuteL();

   393                     CleanupStack::PopAndDestroy( mediatorMessage );

   394                     mediatorMessage = NULL;

   395                     }

   396                 }

   397             break;

   398         }

   399     }

   400 

   401 // -----------------------------------------------------------

   402 // CPhoneState::HandleAudioMuteChangedL

   403 // Default handling for EPEMessageAudioMuteChanged message

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

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

   406 //

   407 EXPORT_C void CPhoneState::HandleAudioMuteChangedL()

   408     {

   409     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleAudioMuteChangedL() ");

   410     __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),

   411         Panic( EPhoneCtrlInvariant ) );

   412 

   413     TPhoneCmdParamBoolean booleanParam;

   414     const TBool audioMute = iStateMachine->PhoneEngineInfo()->AudioMute();

   415     booleanParam.SetBoolean( audioMute );

   416     iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateMuteUIChanges,

   417         &booleanParam );

   418     }

   419 

   420 // -----------------------------------------------------------

   421 // CPhoneState::HandleAudioOutputChangedL

   422 // Default handling for EPEMessageAudioOutputChanged message

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

   424 // -----------------------------------------------------------

   425 //

   426 EXPORT_C void CPhoneState::HandleAudioOutputChangedL()

   427     {

   428     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleAudioOutputChangedL() ");

   429     __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),

   430         Panic( EPhoneCtrlInvariant ) );

   431 

   432     TPhoneCmdParamAudioOutput outputParam;

   433 

   434     // Output

   435     const TPEAudioOutput audioOutput =

   436         iStateMachine->PhoneEngineInfo()->AudioOutput();

   437     outputParam.SetAudioOutput( audioOutput );

   438 

   439     // view update

   440     iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateAudioPathUIChanges,

   441         &outputParam );

   442 

   443     // Previous Output

   444     TPEPhoneAudioRouteParameters RouteParameters = iStateMachine->

   445         PhoneEngineInfo()->RouteParameters();

   446     const TPEAudioOutput previousOutput =

   447         RouteParameters.iPreviousOutput;

   448 

   449     // BT availability

   450     TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(

   451             EPEBTAudioAccessory );

   452 

   453     // Show note or BT disconnect handler

   454     if ( audioOutput != EPENotActive &&

   455          previousOutput == EPEBTAudioAccessory &&

   456          !btAvailable )

   457         {

   458         CPhoneBtaaDisconnectHandler::InstanceL()->HandleConnectionLostL();

   459         }

   460     else if ( audioOutput == EPEBTAudioAccessory && 

   461             previousOutput != EPEBTAudioAccessory &&

   462             btAvailable )

   463         {

   464         CPhoneAccessoryBTHandler* bt = CPhoneAccessoryBTHandler::NewLC(

   465             iViewCommandHandle, iStateMachine, this );

   466         bt->ShowBTActivatedL();

   467         CleanupStack::PopAndDestroy( bt );

   468         }

   469     else if ( audioOutput == EPENotActive &&

   470               CPhoneBtaaDisconnectHandler::InstanceL()->IsQuery() )

   471         {

   472         CPhoneBtaaDisconnectHandler::InstanceL()->Cancel();

   473         }

   474     else if ( RouteParameters.iShowNote && audioOutput == EPELoudspeaker )

   475         {

   476         CAknKeySoundSystem* keySounds =

   477                static_cast<CAknAppUi*>( iEnv.EikAppUi() )->KeySounds();

   478         keySounds->PlaySound( EAvkonSIDIHFActive );

   479         }

   480     }

   481 

   482 // -----------------------------------------------------------

   483 // CPhoneState::HandleSimStateChangedL

   484 // Handles changes in the SIM card state.

   485 // -----------------------------------------------------------

   486 //

   487 void CPhoneState::HandleSimStateChangedL()

   488     {

   489     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::HandleSimStateChangedL()" );

   490     CPhoneMainResourceResolver& resolver = *CPhoneMainResourceResolver::Instance();

   491     TPESimState simState = SimState();

   492 

   493     __PHONELOG2( EBasic, EPhoneControl, "SIM state was changed from %d to %d", iPreviousSimState, simState );

   494 

   495     switch ( simState )

   496         {

   497         case EPESimUsable: // Falls through.

   498         case EPESimReadable: // Falls through.

   499         case EPESimNotReady:

   500             {

   501             if ( iPreviousSimState == EPESimNotPresent )

   502                 {

   503                 __PHONELOG( EBasic, EPhoneControl, "SIM card was inserted, rebooting the phone" );

   504                 RStarterSession starterSession;

   505                 User::LeaveIfError( starterSession.Connect() );

   506                 CleanupClosePushL( starterSession );

   507 

   508                 HBufC* queryText = StringLoader::LoadLC( resolver.ResolveResourceID( EPhoneRebootRequired ) );

   509 

   510                 TPhoneCmdParamQuery queryParams;

   511                 queryParams.SetCommandParamId( TPhoneCommandParam::EPhoneParamRebootQuery );

   512                 queryParams.SetQueryPrompt( *queryText );

   513                 queryParams.SetDefaultCba( R_AVKON_SOFTKEYS_OK_EMPTY );

   514                 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery, &queryParams );

   515 

   516                 starterSession.Reset( RStarterSession::ESIMStatusChangeReset );

   517                 CleanupStack::PopAndDestroy( 2, &starterSession ); // queryText

   518                 }

   519             break;

   520             }

   521         case EPESimNotPresent:

   522             {

   523             if ( iPreviousSimState == EPESimUsable ||

   524                  iPreviousSimState == EPESimReadable ||

   525                  iPreviousSimState == EPESimNotReady )

   526                 {

   527                 __PHONELOG( EBasic, EPhoneControl, "SIM card was removed" );

   528 

   529                 TPhoneCmdParamGlobalNote globalNoteParam;

   530                 globalNoteParam.SetType( EAknGlobalInformationNote );

   531                 globalNoteParam.SetTone( EAvkonSIDNoSound );

   532 

   533                 globalNoteParam.SetTextResourceId(

   534                     CPhoneMainResourceResolver::Instance()->

   535                     ResolveResourceID( EPhoneSimRemoved ) );

   536 

   537                 iViewCommandHandle->ExecuteCommandL(

   538                     EPhoneViewShowGlobalNote, &globalNoteParam );

   539 

   540                 }

   541             // Show security note, if SIM not present and KFeatureIdFfSimlessOfflineSupport is disabled.

   542             else if ( !FeatureManager::FeatureSupported( KFeatureIdFfSimlessOfflineSupport ) &&

   543                     ( iPreviousSimState != EPESimNotSupported ) )

   544                 {

   545                 StartShowSecurityNoteL();

   546                 }

   547             break;

   548             }

   549         default:

   550             break;

   551         }

   552 

   553     iPreviousSimState = simState;

   554     }

   555 

   556 // -----------------------------------------------------------------------------

   557 // CPhoneState::IsValidAlphaNumericKey

   558 // Checks is the key event a number, a special character

   559 // or if VoIP is enabled some other character

   560 // -----------------------------------------------------------------------------

   561 //

   562 TBool CPhoneState::IsValidAlphaNumericKey( const TKeyEvent& aKeyEvent,

   563         TEventCode aEventCode )

   564     {

   565     TBool ret(EFalse);

   566 

   567     const TBool numericKeyEntered( CPhoneKeys::IsNumericKey(

   568           aKeyEvent, aEventCode ) );

   569 

   570     // a numeric key (1,2,3,4,6,7,8,9,0,+,*,p,w )

   571     // or

   572     // a letter from fullscreen qwerty, miniqwerty or handwriting

   573     // when voip is enabled

   574     if ( numericKeyEntered

   575         || IsAlphanumericSupportedAndCharInput( aKeyEvent ) )

   576         {

   577         ret= ETrue;

   578         }

   579 

   580     return ret;

   581     }

   582 

   583 // -----------------------------------------------------------------------------

   584 // CPhoneState::CustomizeCBAForPhoneNumber

   585 //

   586 // -----------------------------------------------------------------------------

   587 //

   588 void CPhoneState::CustomizeCbaForPhoneNumberL()

   589     {

   590     if ( !FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) &&

   591          iCustomization &&

   592          iCustomization->AllowAlphaNumericMode() )

   593         {

   594         // Get the number entry contents

   595         HBufC* phoneNumber = PhoneNumberFromEntryLC();

   596 

   597         TPhoneCmdParamInteger integerParam;

   598 

   599         //only charaters from set { 0, .., 9, *, #, +, p, w, P, W } used

   600         if ( CPhoneKeys::Validate( phoneNumber->Des()) )

   601             {

   602             integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->

   603                                     ResolveResourceID( EPhoneNumberAcqCBA ) );

   604             }

   605         //other characters

   606         else

   607             {

   608             integerParam.SetInteger( iCustomization->CustomizeSoftKeys() );

   609             }

   610 

   611         iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateCba, &integerParam );

   612         CleanupStack::PopAndDestroy( phoneNumber );

   613         }

   614 

   615     }

   616 

   617 // -----------------------------------------------------------------------------

   618 // CPhoneState::IsTouchDTmfDialerOn

   619 // -----------------------------------------------------------------------------

   620 //

   621 TBool CPhoneState::IsTouchDTmfDialerOn() const

   622     {

   623     TBool status( EFalse );

   624     if ( IsOnScreenDialerSupported() )

   625         {

   626         TBool isDialerVisible( EFalse );

   627         TRAP_IGNORE( isDialerVisible = IsDTMFEditorVisibleL() );

   628 

   629         if ( isDialerVisible )

   630             {

   631             status = ETrue;

   632             }

   633         }

   634     return status;

   635     }

   636 // -----------------------------------------------------------------------------

   637 // CPhoneState::SendDtmfKeyEventL

   638 // send dtmf event when,

   639 // -touch dtmf dialer is NOT visible

   640 // -query is not active

   641 // -menubar is not open

   642 // -----------------------------------------------------------------------------

   643 //

   644 void CPhoneState::SendDtmfKeyEventL( const TKeyEvent& aKeyEvent,

   645                TEventCode aEventCode  )

   646     {

   647 

   648     if ( !IsTouchDTmfDialerOn()

   649         && !IsAnyQueryActiveL()

   650         && !IsMenuBarVisibleL() )

   651         {

   652         // Send the key event to the phone engine.

   653         SendKeyEventL( aKeyEvent, aEventCode );

   654         }

   655     }

   656 

   657 // -----------------------------------------------------------------------------

   658 // CPhoneState::IsKeyEventFurtherProcessed

   659 // -----------------------------------------------------------------------------

   660 //

   661 TBool CPhoneState::IsKeyEventFurtherProcessedL( const TKeyEvent& aKeyEvent ) const

   662     {

   663     // While being in some special keyboard mode (Full Screen&mini QWERTY,

   664     // handwriting mode) FEP sends only EEventKey -event and thus manual

   665     // DTMFs can not be played with the user specified tone lengths. Also,

   666     // in general, DTMFs are tried to play only in numeric mode.

   667     TBool numericMode = iViewCommandHandle->HandleCommandL(

   668       EPhoneViewIsNumberEntryNumericMode ) == EPhoneViewResponseSuccess;

   669 

   670     if ( ( aKeyEvent.iModifiers & EModifierSpecial ) != 0 || !numericMode )

   671         {

   672         return EFalse;

   673         }

   674 

   675     return ETrue;

   676     }

   677 

   678 // -----------------------------------------------------------

   679 // CPhoneState::HandleErrorL

   680 // Default handling for HandleError message

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

   682 // -----------------------------------------------------------

   683 //

   684 EXPORT_C void CPhoneState::HandleErrorL( const TPEErrorInfo& aErrorInfo )

   685     {

   686     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleErrorL()");

   687 

   688     __PHONELOG1( EBasic, EPhoneControl,

   689             "PhoneUIControl: CPhoneState::HandleErrorL - aErrorInfo.iErrorCode =%d ",

   690             aErrorInfo.iErrorCode );

   691 

   692     __PHONELOG1( EBasic, EPhoneControl,

   693         "PhoneUIControl: CPhoneState::HandleErrorL - aErrorInfo.iCallId =%d ",

   694         aErrorInfo.iCallId );

   695 

   696 

   697     // Sets touch buttons to correct status if error has occured.

   698     if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )

   699         {

   700         iViewCommandHandle->ExecuteCommand( EPhoneResetTouchButtons );

   701         }

   702 

   703     // Do the common error handling (display proper notes etc)

   704     CPhoneMainErrorMessagesHandler::Instance()->ShowErrorSpecificNoteL( aErrorInfo );

   705 

   706     switch( aErrorInfo.iErrorCode )

   707         {

   708         case ECCPErrorCCUserAlertingNoAnswer:

   709         case ECCPErrorCCResourceNotAvailable:

   710             {

   711             if( aErrorInfo.iCallId > KErrNotFound )

   712                 {

   713                 if ( iStateMachine->PhoneEngineInfo()->CallDirection(

   714                         aErrorInfo.iCallId ) != RMobileCall::EMobileTerminated )

   715                     {

   716                     if( IsVideoCall( aErrorInfo.iCallId ) )

   717                         {

   718                         // Active MO video call lost 3G network.

   719                         __PHONELOG1( EBasic, EPhoneControl,

   720                         "PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 1, callid%d ",

   721                         aErrorInfo.iCallId );

   722                         CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );

   723                         }

   724                     else

   725                         {

   726                          __PHONELOG1( EBasic, EPhoneControl,

   727                             "PhoneUIControl: CPhoneState::HandleErrorL - No video call =%d ",

   728                             aErrorInfo.iCallId );

   729                         }

   730                     }

   731                 }

   732             }

   733             break;

   734 

   735             case ECCPErrorCCServiceNotAvailable:

   736                 {

   737                 if( IsVideoCall( aErrorInfo.iCallId ) )

   738                     {

   739                     CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( EFalse );

   740                     }

   741                 }

   742                 break;

   743 

   744             case ECCPErrorBadRequest:

   745                 {

   746                 TPECallType callType =

   747                     iStateMachine->PhoneEngineInfo()->CallTypeCommand();

   748 

   749                 if( callType == EPECallTypeVideo )

   750                     {

   751                         // Dialling MO video call cannot reach 3G network.

   752                         __PHONELOG1( EBasic, EPhoneControl,

   753                             "PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 2, callid%d ",

   754                             aErrorInfo.iCallId );

   755                         CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );

   756                     }

   757                 }

   758                 break;

   759 

   760         case ECCPErrorVideoCallNotSupportedByNetwork:

   761         case ECCPErrorVideoCallSetupFailed:

   762         case ECCPErrorNotReached:

   763            // If call id found and seems to be Video Call

   764             if ( IsVideoCall( aErrorInfo.iCallId ) )

   765                 {

   766                 // Get active call count

   767                 TPhoneCmdParamInteger activeCallCount;

   768                 iViewCommandHandle->ExecuteCommandL(

   769                     EPhoneViewGetCountOfActiveCalls, &activeCallCount );

   770 

   771                 if ( activeCallCount.Integer() == 0

   772                      || iStateMachine->PhoneEngineInfo()->CallDirection(

   773                         aErrorInfo.iCallId ) != RMobileCall::EMobileTerminated )

   774                     {

   775                     // Dialling MO video call attempted in 2G network or

   776                     // dialing MO video to unvalid number

   777                     // Reconnect query include video label if errorcode is unvalid number.

   778                     __PHONELOG1( EBasic, EPhoneControl,

   779                     "PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 3, callid%d ",

   780                     aErrorInfo.iCallId );

   781                     CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL(

   782                               ECCPErrorNotReached == aErrorInfo.iErrorCode );

   783                     }

   784                 }

   785             break;

   786 

   787         case ECCPErrorNoService:

   788             // No network -> hide volume popup

   789             iViewCommandHandle->ExecuteCommandL( EPhoneViewHideNaviPaneAudioVolume );

   790             break;

   791 

   792         case ECCPErrorSatControl:

   793             {

   794             // check, that there really was a call established before completing SAT request

   795             if( aErrorInfo.iCallId != KPECallIdNotUsed )

   796                 {

   797                 }

   798 

   799             // remove number entry

   800             if ( !IsOnScreenDialerSupported() && IsNumberEntryUsedL() )

   801                 {

   802                 iViewCommandHandle->ExecuteCommandL(

   803                     EPhoneViewRemoveNumberEntry );

   804                 }

   805             else if ( IsOnScreenDialerSupported() )

   806                 {

   807                 NumberEntryClearL();

   808                 }

   809             }

   810             break;

   811 

   812         default:

   813             break;

   814         }

   815 

   816     // clear call blacklist if call failure occurs

   817     CPhoneClearBlacklist::Instance()->ClearBlackListOnNextKey();

   818     }

   819 

   820 // -----------------------------------------------------------

   821 // CPhoneState::HandleChangedCallDurationL

   822 // Default handling for EPEMessageChangedCallDuration message

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

   824 // -----------------------------------------------------------

   825 void CPhoneState::HandleChangedCallDurationL( TInt aCallId )

   826     {

   827      __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleChangedCallDurationL() ");

   828     // Get the call duration

   829     TTimeIntervalSeconds seconds =

   830         iStateMachine->PhoneEngineInfo()->CallDuration( aCallId );

   831 

   832     TPhoneCmdParamInteger time;

   833     time.SetInteger(seconds.Int());

   834     iViewCommandHandle->ExecuteCommandL(EPhoneViewUpdateCallHeaderCallDuration, aCallId, &time);

   835     }

   836 

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

   838 // CPhoneState::HandleRemoteBusyL

   839 // -----------------------------------------------------------------------------

   840 //

   841 void CPhoneState::HandleRemoteBusyL( TInt aCallId )

   842     {

   843     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleRemoteBusyL( ) ");

   844     ShowNumberBusyNoteL();

   845 

   846     const TPECallType callType =

   847         iStateMachine->PhoneEngineInfo()->CallTypeCommand();

   848 

   849     if( callType == EPECallTypeVideo )

   850         {

   851          // Launch reconnect query including video call menu item

   852          __PHONELOG1( EBasic, EPhoneControl,

   853             "PhoneUIControl: CPhoneState::HandleRemoteBusyL - ShowReconnectQueryL vid 5, callid%d ",

   854                 aCallId );

   855         CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );

   856         }

   857     }

   858 

   859 // -----------------------------------------------------------

   860 // CPhoneState::HandleDisconnectingL

   861 // -----------------------------------------------------------

   862 //

   863 EXPORT_C void CPhoneState::HandleDisconnectingL( TInt aCallId )

   864     {

   865     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleDisconnectingL( ) ");

   866     // If there is no call in connected state then EPhoneDtmfTextQuery and EPhoneDtmfListQueryDialog

   867     // must be dismmissed from UI, therefore we must set EPhoneViewSetNoConnectedCalls to ETrue this

   868     // way we can ensure that CPhoneQueryController doesnt relaunch EPhoneDtmfListQueryDialog.

   869     if ( !IsAnyConnectedCalls() )

   870         {

   871         TPhoneCmdParamBoolean booleanParam;

   872         booleanParam.SetBoolean(ETrue);

   873         iViewCommandHandle->ExecuteCommandL( EPhoneViewSetNoConnectedCalls, &booleanParam );

   874         }

   875 

   876     TPhoneCmdParamCallHeaderData callHeaderParam;

   877     callHeaderParam.SetCallState( EPEStateDisconnecting );

   878 

   879     TBuf<KPhoneCallHeaderLabelMaxLength> labelText( KNullDesC );

   880     LoadResource( labelText, EPhoneInCallDisconnected );

   881 

   882     callHeaderParam.SetLabelText( labelText );

   883 

   884     iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );

   885 

   886     iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId,

   887         &callHeaderParam );    

   888 

   889     CPhoneClearBlacklist::Instance()->ClearBlackListOnNextKey();

   890     }

   891 

   892 // -----------------------------------------------------------

   893 // CPhoneState::IsCustomizedDialerVisibleL()

   894 // -----------------------------------------------------------

   895 //

   896 EXPORT_C TBool CPhoneState::IsCustomizedDialerVisibleL() const

   897     {

   898     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsCustomizedDialerVisibleL( ) ");

   899     return iViewCommandHandle->HandleCommandL(

   900         EPhoneIsCustomizedDialerVisible ) == EPhoneViewResponseSuccess;

   901     }

   902 

   903 // <------------------------------- KEY EVENTS ------------------------------->

   904 

   905 // -----------------------------------------------------------

   906 // CPhoneState::HandleKeyMessageL( aMessage, aKeyCode )

   907 // -----------------------------------------------------------

   908 //

   909 EXPORT_C void CPhoneState::HandleKeyMessageL(

   910     TPhoneKeyEventMessages /*aMessage*/,

   911     TKeyCode /*aKeyCode*/ )

   912     {

   913     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleKeyMessageL( ) ");

   914     }

   915 

   916 // -----------------------------------------------------------

   917 // CPhoneState::HandleKeyEventL( aKeyEvent, aEventCode )

   918 // -----------------------------------------------------------

   919 //

   920 EXPORT_C void CPhoneState::HandleKeyEventL(

   921     const TKeyEvent& aKeyEvent,

   922     TEventCode aEventCode )

   923     {

   924     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleKeyEventL( ) ");

   925     if ( ( IsNumberEntryVisibleL() ) || OnlySideVolumeKeySupported() )

   926         {

   927         // Handle numeric keys when key events are received in single state

   928         HandleNumericKeyEventL( aKeyEvent, aEventCode );

   929         }

   930     else if ( aKeyEvent.iScanCode == EStdKeyUpArrow &&

   931               aEventCode == EEventKey )

   932         {

   933         // Increace audio volume

   934         IncreaseAudioVolumeL();

   935         }

   936     else if ( aKeyEvent.iScanCode == EStdKeyDownArrow &&

   937             aEventCode == EEventKey )

   938         {

   939         // Decreace audio volume

   940         DecreaseAudioVolumeL();

   941         }

   942     else

   943         {

   944         // Handle numeric keys when key events are received in single state

   945         HandleNumericKeyEventL( aKeyEvent, aEventCode );

   946         }

   947     }

   948 

   949 // -----------------------------------------------------------

   950 // CPhoneState::OnlySideVolumeKeySupported

   951 // -----------------------------------------------------------

   952 //

   953 TBool CPhoneState::OnlySideVolumeKeySupported()

   954     {

   955     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::OnlySideVolumeKeySupported( ) ");

   956     TBool onlySideVolumeKeySupported(EFalse);

   957     if ( !CPhoneCenRepProxy::Instance()->

   958             IsTelephonyFeatureSupported( KTelephonyLVFlagScrollVolumeKeys ) &&

   959          FeatureManager::FeatureSupported( KFeatureIdSideVolumeKeys ) )

   960         {

   961         onlySideVolumeKeySupported = ETrue;

   962         }

   963     __PHONELOG1( EBasic, EPhoneControl,

   964             "OnlySideVolumeKeySupported: %d",

   965             onlySideVolumeKeySupported );

   966     return onlySideVolumeKeySupported;

   967     }

   968 

   969 // -----------------------------------------------------------

   970 // CPhoneState::HandleKeyPressDurationL( aScanCode, aKeyPressDuration )

   971 // -----------------------------------------------------------

   972 //

   973 EXPORT_C void CPhoneState::HandleKeyPressDurationL(

   974     TKeyCode aCode,

   975     TTimeIntervalMicroSeconds /*aKeyPressDuration*/ )

   976     {

   977     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleKeyPressDurationL( ) ");

   978 

   979     if( aCode == KPhoneDtmfHashCharacter )

   980         {

   981         if( iAlsLineChangeKeyPressTimer )

   982             {

   983             if( iAlsLineChangeKeyPressTimer->IsActive() )

   984                 {

   985                 iAlsLineChangeKeyPressTimer->Cancel();

   986                 }

   987             }

   988         }

   989     }

   990 

   991 // -----------------------------------------------------------

   992 // CPhoneState::IsNoteVisibleL

   993 // -----------------------------------------------------------

   994 //

   995 EXPORT_C TBool CPhoneState::IsNoteVisibleL()

   996     {

   997     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsNoteVisibleL( ) ");

   998     TPhoneCmdParamBoolean booleanParam;

   999     iViewCommandHandle->ExecuteCommandL(

  1000         EPhoneViewGetIsNoteVisible, &booleanParam );

  1001     return booleanParam.Boolean();

  1002     }

  1003 

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

  1005 // CPhoneState::IsMenuBarVisibleL

  1006 // -----------------------------------------------------------

  1007 //

  1008 EXPORT_C TBool CPhoneState::IsMenuBarVisibleL() const

  1009     {

  1010     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsMenuBarVisibleL( ) ");

  1011     return iViewCommandHandle->HandleCommandL(

  1012         EPhoneViewIsMenuBarVisible ) ==

  1013         EPhoneViewResponseSuccess;

  1014     }

  1015 

  1016 // -----------------------------------------------------------

  1017 // CPhoneState::HandleNumericKeyEventL

  1018 // -----------------------------------------------------------

  1019 //

  1020 EXPORT_C void CPhoneState::HandleNumericKeyEventL(

  1021     const TKeyEvent& aKeyEvent,

  1022     TEventCode aEventCode )

  1023     {

  1024     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleNumericKeyEventL( ) ");

  1025 

  1026     TBool numberEntryUsed = IsNumberEntryUsedL();

  1027 

  1028     if ( numberEntryUsed && ( aKeyEvent.iRepeats == 0 ||

  1029               aKeyEvent.iScanCode == EStdKeyBackspace ||

  1030               aKeyEvent.iScanCode ==EStdKeyLeftArrow  ||

  1031               aKeyEvent.iScanCode ==EStdKeyRightArrow ))

  1032         {

  1033         // Number entry exists but may be hidden

  1034         KeyEventForExistingNumberEntryL( aKeyEvent, aEventCode );

  1035         }

  1036 

  1037     }

  1038 

  1039 // -----------------------------------------------------------------------------

  1040 // CPhoneState::IsAnyQueryActiveL

  1041 // -----------------------------------------------------------------------------

  1042 //

  1043 EXPORT_C TBool CPhoneState::IsAnyQueryActiveL()

  1044     {

  1045     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsAnyQueryActiveL( ) ");

  1046     TBool isActive( EFalse );

  1047 

  1048     // If IsNoteDismissableL returns true then shown note is dismissable by key event

  1049     // and then there is no actual query and IsAnyQueryActiveL returns false.

  1050     if ( !IsNoteDismissableL() )

  1051         {

  1052         // Check is query displayed

  1053         TPhoneCmdParamBoolean isQueryDisplayed;

  1054         iViewCommandHandle->ExecuteCommandL( EPhoneViewIsQuery, &isQueryDisplayed );

  1055         // Check is Blocking Dialog active ( e.g. RFS query )

  1056         TPhoneCmdParamBoolean blockingDialogStatus;

  1057         iViewCommandHandle->ExecuteCommandL( EPhoneViewGetBlockingDialogStatus,

  1058             &blockingDialogStatus );

  1059         // Check is note displayed

  1060         TPhoneCmdParamBoolean isNoteActive;

  1061         iViewCommandHandle->ExecuteCommandL(

  1062             EPhoneViewIsNoteActive, &isNoteActive );

  1063 

  1064         if ( isQueryDisplayed.Boolean() || blockingDialogStatus.Boolean() || isNoteActive.Boolean() )

  1065             {

  1066             isActive = ETrue;

  1067             }

  1068         }

  1069     __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::IsAnyQueryActiveL: %d ", isActive );

  1070     return isActive;

  1071     }

  1072 

  1073 // -----------------------------------------------------------------------------

  1074 // CPhoneState::IsNoteDismissable

  1075 // -----------------------------------------------------------------------------

  1076 //

  1077 TBool CPhoneState::IsNoteDismissableL()

  1078     {

  1079     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsNoteDismissableL( ) ");

  1080     TBool dismiss = EFalse;

  1081     if ( !FeatureManager::FeatureSupported( KFeatureIdFfSimlessOfflineSupport ) ||

  1082          (FeatureManager::FeatureSupported( KFeatureIdFfSimlessOfflineSupport ) &&

  1083                   SimSecurityStatus() == ESimRejected )  )

  1084         {

  1085         // Check if note is dismissed by key event.

  1086         TPhoneCmdParamBoolean isNoteDismissed;

  1087         iViewCommandHandle->ExecuteCommandL(

  1088                 EPhoneViewIsActiveNoteDissmissableByKeyEvent, &isNoteDismissed );

  1089         if ( isNoteDismissed.Boolean() )

  1090             {

  1091             dismiss = ETrue;

  1092             }

  1093         }

  1094     __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::IsNoteDismissableL: %d ", dismiss );

  1095     return dismiss;

  1096     }

  1097 

  1098 // -----------------------------------------------------------

  1099 // CPhoneState::SendKeyEventL

  1100 // -----------------------------------------------------------

  1101 //

  1102 void CPhoneState::SendKeyEventL(

  1103     const TKeyEvent& aKeyEvent,

  1104     TEventCode aEventCode )

  1105     {

  1106     __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SendKeyEventL( ) ");

  1107     switch( aEventCode )

  1108         {

  1109         // EEventKey

  1110         case EEventKey:

  1111             // Send the key press to the phone engine, if applicable

  1112             SendKeyPressL( aKeyEvent, aEventCode );

  1113             break;

  1114 

  1115         // EEventKeyUp

  1116         case EEventKeyUp:

  1117             // Send a key up event for the last key code sent to

  1118             // the phone engine

  1119             iStateMachine->SendPhoneEngineMessage(

  1120                 MPEPhoneModel::EPEMessageEndDTMF );

  1121             break;

  1122 

  1123         default:

  1124             break;

  1125         }

  1126     }

  1127 

  1128 // -----------------------------------------------------------

  1129 // CPhoneState::SendKeyPressL

  1130 // -----------------------------------------------------------

  1131 //

  1132 void CPhoneState::SendKeyPressL(

  1133     const TKeyEvent& aKeyEvent,

  1134     TEventCode aEventCode )