1 /*

     2 * Copyright (c) 2005-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:  This file defines the protocol independent interface of the Phone Engine.

    15 *

    16 */

    17 

    18 #ifndef PEVIRTUALENGINE_H

    19 #define PEVIRTUALENGINE_H

    20 

    21 // INCLUDES

    22 #include <badesca.h>

    23 #include <bldvariant.hrh>   //protocol definition, component configuration definitions

    24 #include <cphcntcontactid.h>

    25 #include <ctsydomainpskeys.h>

    26 #include <etelmm.h>

    27 #include <exterror.h>

    28 #include <fbs.h>

    29 #include <mccecall.h>

    30 #include <mmtsy_names.h>

    31 #include <networkhandlingdomainpskeys.h>

    32 #include <phclttypes.h>

    33 #include <Profile.hrh>

    34 #include <rmmcustomapi.h>

    35 #include <rsssettings.h>

    36 #include <sysutil.h>

    37 

    38 

    39 // CONSTANTS

    40 

    41 //Call origin types

    42 enum TPECallOrigin

    43     {

    44     EPECallOriginPhone,

    45     EPECallOriginClient,

    46     EPECallOriginSAT

    47     };

    48 

    49 //Output types

    50 enum TPEAudioOutput

    51     {

    52     EPENotActive,

    53     EPEHandset,

    54     EPELoudspeaker,

    55     EPEWiredAudioAccessory,

    56     EPEBTAudioAccessory,

    57     EPETTY

    58     };

    59 

    60 //Error types

    61 enum TPEErrorType

    62     {

    63     EPECcp = 0,

    64     EPECch

    65     };

    66 

    67 // PhoneEngine Errors

    68 const TInt KErrPhoneEngineErrorBase = -30000;

    69 const TInt KErrPhoneEngineNoWcdmaNetwork = KErrPhoneEngineErrorBase - 1;

    70 const TInt KErrPhoneEngineVideoCallNotAllowedDuringRestore = KErrPhoneEngineErrorBase - 2;

    71 const TInt KErrPhoneEngineVideoCallSetupFailed = KErrPhoneEngineErrorBase - 3;

    72 

    73 // Phone Engine dll uid

    74 const TUid KUidPhoneEngine = { 0x1000A86C };

    75 

    76 // Maximum length of phone number 

    77 const TInt KPEPhoneNumberMaxLength = 100;

    78 //Phone number type defined using the custom maximum length

    79 typedef TBuf<KPEPhoneNumberMaxLength> TPEPhoneNumber;

    80 //Maximum length of dtmf string        

    81 const TInt KPEDtmfMaxLength = KPEPhoneNumberMaxLength;

    82 

    83 //Maximum number of the SS service groups

    84 const TInt KPEMaxServiceGroup = 53; // Maximum value taken from etelmm.h(TMobileService)    

    85 

    86 const TInt KPEAutomaticAnswerTimeout = 5000000; // 5 seconds;

    87 

    88 // Enumerations for variant messages

    89 // For enumeration TPEMessagesToPhoneEngine

    90 const TInt KPEMessagesToPhoneEngineGsmFirst = 11000;

    91 const TInt KPEMessagesToPhoneEngineGsmLast = 12999;

    92 const TInt KPEMessagesToPhoneEngineVariantFirst = KPEMessagesToPhoneEngineGsmFirst;

    93 

    94 // For enumeration TPEMessagesFromPhoneEngine

    95 const TInt KPEMessagesFromPhoneEngineGsmFirst = 11000;

    96 const TInt KPEMessagesFromPhoneEngineGsmLast = 12999;

    97 const TInt KPEMessagesFromPhoneEngineVariantFirst = KPEMessagesFromPhoneEngineGsmFirst;

    98 

    99 // Lifetimer data in hours and minutes

   100 NONSHARABLE_STRUCT( TPELifeTimeData )                      

   101     {

   102     TUint32 iHours;                         //range 0-999999 

   103     TUint8 iMinutes;                        //range 0-59

   104     };

   105 

   106 // Used when initializing number variables with non negative value range.

   107 const TInt KPENumberInitValue = -1; 

   108 //CallId not used in SendErrorMessageL

   109 const TInt KPECallIdNotUsed = -1;            

   110 //ErrorCode not used in SendErrorMessageL

   111 const TInt KPEErrorCodeNotUsed = -1;        

   112 // Informs to phone engine that dont send message to the phone application

   113 const TInt KPEDontSendMessage = 1;

   114  

   115 // Maximum lenght of timer

   116 const TInt KPESsTimerMaxLength = 2;

   117 

   118 // Audio player repeats tone forever

   119 const TInt KPEAudioPlayerRepeatForever = -2;

   120 // Default Audio volume value

   121 const TInt KPEDefaultAudioVolume = 7;

   122 // Default volume value for accessory

   123 const TInt KPEDefaultAccessoryVolume = 5;

   124 // Default keypad volume

   125 const TProfileKeypadVolume KPEDefaultKeypadVolume = EProfileKeypadVolumeLevel2;

   126 

   127 // Dtmf stop character, PE handles internally DTMF characters as lowercase.

   128 const TUint KPEDtmfStopCharLowercase = 'w';

   129 const TUint KPEDtmfStopCharUppercase = 'W';

   130 const TUint KPEDtmfPauseCharLowercase = 'p';

   131 const TUint KPEDtmfPauseCharUppercase = 'P';

   132 const TUint KPEDtmfPlusChar = '+';

   133 

   134 enum TPELoggingIndicator

   135     {

   136     EPENormalLogging = 0,

   137     EPEContinuousLogging 

   138     };

   139 

   140 // Maximum Length of profile name

   141 const TInt KPEProfileNameLength = 64;

   142 // Profile is alerting all incoming calls.

   143 _LIT( KPEAlertForAllCalls, "1");

   144 // Informs how many profiles there are

   145 const TInt KPEProfileGroups = 3;

   146 // Informs how much time it take's to change ringing tone volume from minimum to maximum(Ascending)

   147 const TInt KPERingingToneRampDuration = 5000000;

   148 // Informs how many ringing tone volume levels there are in the profile db

   149 const TInt KPEProfileRingingToneLevels = 10;

   150 // Includes default tone volume

   151 const TInt KPEDefaultToneVolume = 30000;

   152 // Contact group id string length

   153 const TInt KPEContactGroupString = 100;

   154 

   155 //The length of a pause created during dialling by the comma character (',') measured in seconds.  

   156 const TUint KPEDefaultInterval = 2;

   157 

   158 // CommDB constants for Data calls

   159 // Internet Access Point service type

   160 _LIT( KPEIAPServiceTypeName, "IAP\\IAPServiceType" );

   161 // Dial Out Internet Serivce Provider Table name

   162 _LIT( KPEIAPDialOutISPTableName, "DialOutISP" );

   163 // Dial In Internet Service Provider Table name

   164 _LIT( KPEIAPDialInISPTableName, "DialInISP" );

   165 // Access Point Name column on IAP table

   166 _LIT( KPEIAPAccessPointName, "IAP\\NAME" );

   167 

   168 const TInt KPEMaxAudioOutputs = EPETTY + 1; // enum count

   169 

   170 // DATA TYPES

   171 

   172 // Contact name definition

   173 typedef TBuf<KCntMaxTextFieldLength> TPEContactName;

   174 // Contact company definition

   175 typedef TBuf<KCntMaxTextFieldLength> TPEContactCompany;

   176 // Contact group definition

   177 typedef TBuf<KCntMaxTextFieldLength> TPEContactGroup;

   178 // Contact filename definition

   179 typedef TBuf<KMaxFileName>         TPEContactFileName;

   180 // Contact group ids sting

   181 typedef TBuf<KPEContactGroupString> TPEContactGroupId;

   182 //Dtmf-string definition

   183 typedef TBuf<KPEDtmfMaxLength> TPEDtmfString;

   184 //Profile name definition

   185 typedef TBuf<KPEProfileNameLength> TPEProfileName;

   186 //Call control caps

   187 typedef TUint32 TPECallControlCaps;

   188 //User to user info

   189 typedef TBuf<KPhCltUUILength> TPEUserToUserInfo;

   190 

   191 // Phone identity parameters type.

   192 typedef TBuf<RMobilePhone::KPhoneManufacturerIdSize> TPEManufacturer;

   193 typedef TBuf<RMobilePhone::KPhoneModelIdSize> TPEModel;

   194 typedef TBuf<KSysUtilVersionTextLength> TPERevision;

   195 typedef TBuf<RMobilePhone::KPhoneSerialNumberSize> TPESerialNumber;

   196 

   197 //Call States

   198 typedef TUint TPEState;

   199 

   200 enum

   201     {

   202     // Call states                        0 - 499

   203     EPEStateUnknown                     = 0,

   204     EPEStateIdle,

   205     EPEStateDialing,

   206     EPEStateEmergencyDialing,

   207     EPEStateRinging,

   208     EPEStateConnecting,

   209     EPEStateConnected,

   210     EPEStateHangingUp,

   211     EPEStateHeld,

   212     EPEStateAnswering,

   213     EPEStateRejecting,

   214     EPEStateDisconnecting,

   215     // conference call states

   216     EPEStateConferenceIdle,

   217     EPEStateConnectedConference,

   218     EPEStateHeldConference,

   219     EPEStateCreatingConference,

   220     EPEStateHangingUpConference,

   221     EPEStateSwappingConference,

   222     EPEStateResumeHoldConference,        

   223     EPEStateGoingOneToOne,

   224     EPEStateAddingConferenceMember,

   225     EPEStateAddedConferenceMember,

   226     EPEStateDroppingConferenceMember,

   227     EPEStateDroppedConferenceMember,

   228     // maximum value for boundary checks

   229     EPEStateMaximumState                = 1000

   230     };

   231 

   232 NONSHARABLE_STRUCT( TPEErrorInfo )

   233     {

   234     //Symbian OS error code

   235     TInt iErrorCode;

   236     //Call Id number, equals KPECallIdNotUsed if call id is not available or is

   237     //invalid for this error condition

   238     TInt iCallId;

   239     // Error type( Cch or Ccp )

   240     TPEErrorType iErrorType;

   241     };

   242     

   243 enum TPECallType

   244     { // maintain compatibility with P&S type enum

   245     // Used to initialize call type information

   246     EPECallTypeUninitialized    = EPSCTsyCallTypeUninitialized,

   247     // Circuit switched voice call

   248     EPECallTypeCSVoice          = EPSCTsyCallTypeCSVoice,

   249     // Circuit switched multimedia call

   250     EPECallTypeVideo            = EPSCTsyCallTypeH324Multimedia,

   251     // Packet switched voice call

   252     EPECallTypeVoIP             = EPSCTsyCallTypeVoIP

   253     };

   254 

   255 enum TPEPinCode 

   256     {

   257     EPEPinCode,

   258     EPEPin2Code

   259     };

   260 

   261 enum TPEPhoneCommandType

   262     {

   263     EPESendingFlash

   264     };

   265 

   266 // Enumeration which defines the search keys with which

   267 // contact information is searched

   268 enum TPEFindContactKey

   269     {

   270     //Search keys

   271     EPEFindWithPhoneNumber = 0,

   272     EPEFindWithContactId,

   273     EPEFindKeyNotDefined

   274     };

   275 

   276 enum TPESecurityCommand 

   277     {

   278     EPESecurityCommandUnknown,

   279     EPESecurityCommandChangePinCode,

   280     EPESecurityCommandUnblockPinCode,

   281     EPESecurityCommandChangeBarringPassword,

   282     EPESecurityCommandChangeSimLock

   283     };

   284 

   285 enum TPEPhoneNumberIdType

   286     {

   287     EPEUnknownNumber,

   288     EPEMobileNumber,

   289     EPEPager,

   290     EPETelephoneNumber,

   291     EPEVmbxNumberLine1,

   292     EPEVmbxNumberLine2,

   293     EPEPrivateNumber,

   294     EPEEmergencyNumber,

   295     EPEFaxNumber,

   296     EPEVoipNumber,

   297     EPEVideoNumber,

   298     EPEAssistantNumber,

   299     EPECarNumber,

   300     EPEHomeNumber,

   301     EPEWorkNumber

   302     };

   303 

   304 enum TPERxTimeSlots

   305     {

   306     EPERxSlots1 = 1,

   307     EPERxSlots2 = 2,

   308     EPERxSlots3 = 3

   309     };

   310 

   311 //VoiceMailBoxNumbers

   312 NONSHARABLE_STRUCT( TPEVoiceMailBoxNumberInfo )

   313     {

   314     TPEPhoneNumber iVMBXL1; // Line 1 VoiceMailBoxNumber

   315     TPEPhoneNumber iVMBXL2; // Line 2 VoiceMailBoxNumber

   316     TPEPhoneNumber iDTMFVMBXL1; // Line 1 DTMFVoiceMailBoxNumber

   317     TPEPhoneNumber iDTMFVMBXL2; // Line 2 DTMFVoiceMailBoxNumber

   318     };

   319 

   320 

   321 // Contains information of PhoneIdentity paramteres

   322 NONSHARABLE_STRUCT( TPEPhoneIdentityParameters )

   323     {

   324     TPEManufacturer iManufacturer;

   325     TPEModel iModel;

   326     TPERevision iRevision;

   327     TPESerialNumber iSerialNumber;

   328     };

   329 

   330 // Contains information of call audio route parameters

   331 NONSHARABLE_STRUCT( TPEPhoneAudioRouteParameters )

   332     {

   333     TPEAudioOutput iAudioOutput;

   334     TPEAudioOutput iPreviousOutput;

   335     TBool iShowNote;

   336     };

   337 

   338 // Enumerate definitions for MMI Service Codes from MMETel API:

   339 

   340 // FUNCTION PROTOTYPES

   341 // None.

   342 

   343 // FORWARD DECLARATIONS

   344 

   345 class MPEEngineInfo;

   346 

   347 // CLASS DECLARATION

   348 

   349 /**

   350 *  Offers message interface from phone engine to phone application.

   351 *  

   352 *  @lib phonenegine.lib

   353 *  @since S60 v.4.0

   354 */

   355 NONSHARABLE_CLASS( MEngineMonitor )

   356     {

   357 

   358     public:

   359 

   360         enum TPEMessagesFromPhoneEngine

   361         {

   362         // Audio messages                     1000 - 1999

   363         EPEMessageAudioDtmfEvent            = 1000,

   364         EPEMessageAudioDTMFPlayComplete,

   365         EPEMessageAudioMuteChanged,

   366         EPEMessageAudioOutputChanged,

   367         EPEMessageAudioOutputPreferenceChanged,

   368         EPEMessageAudioPlayStopped,

   369         EPEMessageAudioVolumeChanged,

   370         EPEMessageAvailableAudioOutputsChanged,

   371 

   372         // Call messages                      2000 - 2999

   373         EPEMessageAnswer                    = 2000,

   374         EPEMessageAnswering,

   375         EPEMessageCallAdded,

   376         EPEMessageCallControlCapsChanged,

   377         EPEMessageCallWaiting,

   378         EPEMessageCallWaitingAnswered,

   379         EPEMessageChangedCallDuration,

   380         EPEMessageConferenceCapsChange,        

   381         EPEMessageConferenceIdle,

   382         EPEMessageConnected,

   383         EPEMessageConnectedConference,                

   384         EPEMessageConnecting,

   385         EPEMessageContinuingDTMFSending,

   386         EPEMessageDialing,

   387         EPEMessageDialingError,

   388         EPEMessageDisconnecting,

   389         EPEMessageDisconnectingConference,        

   390         EPEMessageDisconnectingWithInband,  //UI doesn't get this message, it is mapped as EPEMessageDisconnecting

   391         EPEMessageDTMFSendingAborted,

   392         EPEMessageHeld,

   393         EPEMessageHeldConference,        

   394         EPEMessageIdle,

   395         EPEMessageIncoming,

   396         EPEMessageInitiatedEmergencyCall,

   397         EPEMessageInitiatedEmergencyWhileActiveVideo,

   398         EPEMessageInvalidSpeedDial,

   399         EPEMessageIssuingUSSDRequest,

   400         EPEMessageIssuedUSSDRequest,

   401         EPEMessagePacketNetworkDetached,   

   402         EPEMessagePromptSpeedDial,

   403         EPEMessageRemoteBusy,

   404         EPEMessageRemoteTerminated,               

   405         EPEMessageSendingDTMF,

   406         EPEMessageSentDTMF,

   407         EPEMessageSentSSString,

   408         EPEMessageSpeedDialNotAssigned,

   409         EPEMessageStoppedDTMF,

   410         EPEMessageSwapped,

   411         EPEMessageTransferDone,

   412         EPEMessageTransferring,

   413         EPEMessageUnknown,

   414         EPEMessageWentOneToOne,        

   415         EPEMessageRemotePartyInfoChanged,

   416         EPEMessageConnectingWithInband, //UI doesn't get this message, it is mapped as EPEMessageConnecting

   417 

   418         EPEMessageUnattendedTransferRequest,

   419 

   420         EPEMessageRemoteForwarding,

   421         EPEMessageMovedPermanently,        

   422         EPEMessageMultipleChoices,        

   423 

   424         // Contact messages                   3000 - 3999

   425         EPEMessageThumbnailLoadingCompleted  = 3000,

   426 

   427         // Error messages                     4000 - 4999

   428         EPEMessageError                     = 4000,

   429         EPEMessageAudioHandlingError,

   430         EPEMessageCallHandlingError,

   431         EPEMessageConferenceErrorAddCall,

   432         EPEMessageConferenceErrorRemoveCall,

   433         EPEMessageConferenceErrorSwap,

   434         EPEMessageConferenceErrorHold,

   435         EPEMessageConferenceErrorResume,

   436         EPEMessageConferenceErrorGoOneToOne,

   437         EPEMessageConferenceErrorCurrentCallsToConference,

   438         EPEMessageConferenceErrorHangUp,

   439         EPEMessageContactHandlingError,

   440         EPEMessageLogHandlingError,

   441         EPEMessageServiceHandlingError,

   442 

   443         // Network messages                   5000 - 5999

   444         EPEMessageCallSecureStatusChanged= 5000,

   445         EPEMessageNetworkRegistrationStatusChange,

   446 

   447         // Parser messages                    6000 - 6999

   448         EPEMessageActivateRfsDeep           = 6000,

   449         EPEMessageActivateRfsNormal,

   450         EPEMessageActivateWarrantyMode,

   451         EPEMessageShowBTDeviceAddress,

   452         EPEMessageShowBTLoopback,

   453         EPEMessageShowIMEI,

   454         EPEMessageShowVersion,

   455         EPEMessageShowWlanMacAddress,

   456         EPEMessageSSRequestFailed,

   457         EPEMessageBTDebugMode,

   458 

   459         // Security messages                  7000 - 7999

   460         EPEMessageBadBarringPasswordChange  = 7000,

   461         EPEMessageBadPin1Change,

   462         EPEMessageBadPin1Unblock,

   463         EPEMessageBadPin2Change,

   464         EPEMessageBadPin2Unblock,

   465         EPEMessageBarringPasswordChanged,

   466         EPEMessageChangedSimLock,

   467         EPEMessageFailedChangeSimLock,

   468         EPEMessageFailedNewPin1AndPin2NotEqual,         // Error message, NewPin1 and NewPin2 are not equal

   469         EPEMessageFailedSecurityCommandAlreadyActive,   // Error message, SecurityCommand is already active

   470         EPEMessagePin1Changed,

   471         EPEMessagePin1Unblocked,

   472         EPEMessagePin2Changed,

   473         EPEMessagePin2Unblocked,

   474         EPEMessageSIMChanged,

   475         EPEMessageSIMStateChanged,

   476 

   477         // Settings and Shared Data messages  8000 - 8999

   478         EPEMessageProfileChanged            = 8000,

   479 

   480         // Startup messages                   9000 - 9999

   481         EPEMessagePEConstructionReady       = 9000,     // Phone Engine is initialized and fully operational

   482         EPEMessagePEConstructionFailed,

   483         EPEMessagePEConstructionTwoPhaseReady,

   484         // Miscellaneous messages             10000 - 10999

   485         EPEMessageDoNotSendMe               = 10000,

   486         EPEMessageInValidEmergencyNumber,

   487         EPEMessageLogEventSaved, 

   488         EPEMessagePhoneIdentityReady,

   489         EPEMessageStartATDialing,

   490         EPEMessageValidEmergencyNumber,

   491         EPEMessageMuteRingingTone,

   492 

   493         // Audio messages                         11000 - 11199

   494 

   495         // Call messages                          11200 - 11399

   496         EPEMessageActiveBarring                 = KPEMessagesFromPhoneEngineGsmFirst + 200,

   497         EPEMessageActiveCallForwarding,

   498         EPEMessageAddedConferenceMember,

   499         EPEMessageALSLineChanged,

   500         EPEMessageCallBarred,

   501         EPEMessageIncCallIsForw,

   502         EPEMessageIncCallForwToC,

   503         EPEMessageOutCallForwToC,

   504         EPEMessageForwardUnconditionalModeActive,

   505         EPEMessageForwardConditionallyModeActive,

   506         EPEMessageDroppedConferenceMember,

   507         EPEMessageGoingOneToOne,

   508         EPEMessageRemoteCreatedConference,

   509         EPEMessageRemoteHeld,

   510         EPEMessageRemoteResumed,

   511         EPEMessageTempClirSuppressUnsuccessful,

   512         EPEMessageTempClirActivationUnsuccessful,

   513         EPEMessageShowIncCallGroupIndex,

   514         EPEMessageDataPortLoaned,

   515         // Contact messages                       11400 - 11599

   516 

   517         // Error messages                         11600 - 11799

   518 

   519         // VoIP service messages                       11800 - 12999

   520         EPEMessageServiceEnabled               = KPEMessagesFromPhoneEngineGsmFirst + 800,

   521         EPEMessageServiceEnabling,

   522         EPEMessageNoService,

   523         EPEMessageServiceDisabled,

   524 

   525         // Parser messages                        12000 - 12199

   526         EPEMessageIssuedSSRequest               = KPEMessagesFromPhoneEngineGsmFirst + 1000,

   527         EPEMessageIssuingSSRequest,

   528 

   529         // Security messages                      12200 - 12399

   530         EPEMessageSecureNotSpecified,

   531 

   532         // Settings and Shared Data messages      12400 - 12599

   533         EPEMessageAlsStatusChanged              = KPEMessagesFromPhoneEngineGsmFirst + 1400,

   534         EPEMessageBarringNotification,

   535         EPEMessageClipStatusNotification,

   536         EPEMessageClirStatusNotification,

   537         EPEMessageCnapStatusNotification,

   538         EPEMessageColpStatusNotification,

   539         EPEMessageColrStatusNotification,

   540         EPEMessageForwardingNotification,

   541         EPEMessageVmbxNumberLine1Changed,

   542         EPEMessageVmbxNumberLine2Changed,

   543         EPEMessageWaitingNotification,

   544 

   545 

   546         // Miscellaneous messages                 12600 - 12799

   547 

   548         // Last                                   12999

   549         // Exposing this allows the compiler to detect the overlapping enumerations.

   550         EPEMessageLastVariantItem               = KPEMessagesFromPhoneEngineGsmLast

   551         };

   552         

   553         /**

   554         * HandleError

   555         * Phone Application implements this callback method to provide a framework

   556         * for proceeding in an error condition.

   557         * @param aErrorInfo is the call id number.

   558         */

   559         virtual void HandleError( const TPEErrorInfo& aErrorInfo ) = 0;

   560 

   561         /**

   562         * HandleMessage

   563         * Phone Application implements this callback method to provide a response

   564         * for an event message sent by the Phone Engine.

   565         * @param aMessage specifies the event that has taken place

   566         * @param aCallId is the call id number.

   567         */

   568         virtual void HandleMessage( const TInt aMessage, const TInt aCallId ) = 0;

   569         

   570     }; // MEngineMonitor

   571 

   572 

   573 // Maximum number of the conference members.

   574 const TInt KPEMaximumNumberOfConferenceMembers = 5;

   575 // Maximum number of voice calls

   576 const TInt KPEMaximumNumberOfVoiceCalls = 8; // Phone engine user can change this value if needed.

   577 // Maximum number of data calls

   578 const TInt KPEMaximumNumberOfDataCalls = 2; 

   579 // Maximum number of conference calls

   580 const TInt KPEMaximumNumberOfConferenceCalls = 1;    

   581 // Maximum number of all calls

   582 const TInt KPEMaximumNumberOfCalls = KPEMaximumNumberOfVoiceCalls + 

   583     KPEMaximumNumberOfDataCalls + KPEMaximumNumberOfConferenceCalls;

   584 

   585 // Emergency CallId

   586 const TInt KPEEmergencyCallId = KPEMaximumNumberOfVoiceCalls - 1;

   587 // Conference Call ID

   588 const TInt KPEConferenceCallID = KPEMaximumNumberOfVoiceCalls;

   589 

   590 // Invalid call index, note not the same as call id

   591 const TInt KPEInvalidCallIndex = -1;

   592 // These two are needed in TPECallInfo's conference field

   593 // Indicates, that this is Conference Master

   594 const TInt KPEConferenceMaster = -1;

   595 // Indicates, that this is Normal voice call

   596 const TInt KPENormalVoiceCall = -2;

   597 

   598 // All MMI Service Codes are defined in standard 3GPP TS 02.30 V7.1.1, Annex C.

   599 // MMI Service Codes: No service code was specified

   600 _LIT( KPENoServiceCode, "" );

   601 // MMI Service Codes: All teleservices

   602 _LIT( KPEAllTeleservices, "10" );

   603 // MMI Service Codes: Voice teleservices

   604 _LIT( KPETelephony, "11" );

   605 // MMI Service Codes: All Data Services

   606 _LIT( KPEAllDataServices, "12" );

   607 // MMI Service Codes: Fax Services

   608 _LIT( KPEFacsimileServices, "13" );

   609 // MMI Service Codes: SMS Services

   610 _LIT( KPEShortMessageServices, "16" );

   611 // MMI Service Codes: Voice Group Call Service

   612 _LIT( KPEVoiceGroupCallService, "17" );

   613 // MMI Service Codes: Voice Broadcast Service

   614 _LIT( KPEVoiceBroadcastService, "18" );

   615 // MMI Service Codes: All teleservices except SMS

   616 _LIT( KPEAllTeleservicesExceptSMS, "19" );

   617 // MMI Service Codes: All Bearer Service

   618 _LIT( KPEAllBearerServices, "20" );

   619 // MMI Service Codes: All Async Services

   620 _LIT( KPEAllAsyncServices, "21" );

   621 // MMI Service Codes: All Sync Services

   622 _LIT( KPEAllSyncServices, "22" );

   623 // MMI Service Codes: All Data Circuit Sync

   624 _LIT( KPEAllDataCircuitSync, "24" );

   625 // MMI Service Codes: All Data Circuit Async

   626 _LIT( KPEAllDataCircuitAsync, "25" );

   627 // MMI Service Codes: All Dedicated Packet Access

   628 _LIT( KPEAllDedicatedPacketAccess, "26" );

   629 // MMI Service Codes: All Dedicated Pad Access

   630 _LIT( KPEAllDedicatedPadAccess, "27" );

   631 // MMI Service Codes: All Gprs Beares Services

   632 _LIT( KPEAllGprsBearerServices, "99" );

   633 // MMI Service Codess: PLMN specific teleservices

   634 _LIT( KPEAllPlmnSpecificTeleservices, "50" );

   635 _LIT( KPEPlmnSpecificTeleservice1, "51" );

   636 _LIT( KPEPlmnSpecificTeleservice2, "52" );

   637 _LIT( KPEPlmnSpecificTeleservice3, "53" );

   638 _LIT( KPEPlmnSpecificTeleservice4, "54" );

   639 _LIT( KPEPlmnSpecificTeleservice5, "55" );

   640 _LIT( KPEPlmnSpecificTeleservice6, "56" );

   641 _LIT( KPEPlmnSpecificTeleservice7, "57" );

   642 _LIT( KPEPlmnSpecificTeleservice8, "58" );

   643 _LIT( KPEPlmnSpecificTeleservice9, "59" );

   644 _LIT( KPEPlmnSpecificTeleservice10, "60" );

   645 _LIT( KPEPlmnSpecificTeleservice11, "61" );

   646 _LIT( KPEPlmnSpecificTeleservice12, "62" );

   647 _LIT( KPEPlmnSpecificTeleservice13, "63" );

   648 _LIT( KPEPlmnSpecificTeleservice14, "64" );

   649 _LIT( KPEPlmnSpecificTeleservice15, "65" );

   650 // MMI Service Codess: PLMN specific bearer services

   651 _LIT( KPEAllPlmnSpecificBearerServices, "70" );

   652 _LIT( KPEPlmnSpecificBearerService1, "71" );

   653 _LIT( KPEPlmnSpecificBearerService2, "72" );

   654 _LIT( KPEPlmnSpecificBearerService3, "73" );

   655 _LIT( KPEPlmnSpecificBearerService4, "74" );

   656 _LIT( KPEPlmnSpecificBearerService5, "75" );

   657 _LIT( KPEPlmnSpecificBearerService6, "76" );

   658 _LIT( KPEPlmnSpecificBearerService7, "77" );

   659 _LIT( KPEPlmnSpecificBearerService8, "78" );

   660 _LIT( KPEPlmnSpecificBearerService9, "79" );

   661 _LIT( KPEPlmnSpecificBearerService10, "80" );

   662 _LIT( KPEPlmnSpecificBearerService11, "81" );

   663 _LIT( KPEPlmnSpecificBearerService12, "82" );

   664 _LIT( KPEPlmnSpecificBearerService13, "83" );

   665 _LIT( KPEPlmnSpecificBearerService14, "84" );

   666 _LIT( KPEPlmnSpecificBearerService15, "85" );

   667 // ALS

   668 _LIT( KPEAuxVoiceService, "89" );

   669 

   670 //Fax Modem UI application UID

   671 const TInt KPEFaxModemUIUid = 0x1000594E;

   672 // TPESimState fisrt value

   673 const TInt KPEStartupEnumerationFirstValue = 100;

   674 

   675 // Indicates that dtmf sending is possible with this call. 

   676 const TUint KPECapsDtmf = 0x00080000;

   677 

   678 // SIM states

   679 enum TPESimState

   680     {

   681     EPESimStatusUninitialized = KPEStartupEnumerationFirstValue,

   682     EPESimUsable,       // The Sim card is fully usable.    

   683     EPESimReadable,     // The SIM card is not fully usable, but the emergency number can be read.

   684     EPESimNotReady,     // The Sim card is present but not ready or usable.

   685     EPESimNotPresent,   // The Sim card is not present.

   686     EPESimNotSupported  // SIM/RUIM is not supported. Some CDMA phones do not support a SIM/RUIM at all.

   687     };

   688     

   689 // Supplementary Services action type

   690 enum TPESSAction

   691     {

   692     EPESSActionUnspecified = 0,

   693     EPESSActivation,

   694     EPESSDeactivation,

   695     EPESSInterrogation,

   696     EPESSRegistration,

   697     EPESSErasure,

   698     EPEPasswordOperation

   699     };

   700 

   701 // Supplementary Services type

   702 enum TPESSType

   703     {

   704     EPESSTypeUnspecified = 0,

   705     EPECallForwardingNotReachable,

   706     EPECallForwardingNoReply,

   707     EPECallForwardingBusy,

   708     EPECallForwardingUnconditional,

   709     EPECallForwardingAll,

   710     EPECallForwardingAllConditional,

   711     EPECallBarringAllOutgoing,

   712     EPECallBarringAllOutgoingInternational,

   713     EPECallBarringAllOutgoingInternationalExcHome,

   714     EPECallBarringAllIncoming,

   715     EPECallBarringAllIncomingWhenRoaming,

   716     EPECallBarringAllServices,

   717     EPECallBarringAllOutgoingServices,

   718     EPECallBarringAllIncomingServices,

   719     EPECallBarringPassword,

   720     EPECallWaiting,

   721     EPEClip,

   722     EPEClir,

   723     EPECnap,

   724     EPEColp,

   725     EPEColr,

   726     EPEEmlpp,

   727     EPEMsp,

   728     EPESpnp,

   729     EPEPin,

   730     EPEUnblockPin,

   731     EPESimLock

   732     };

   733 

   734 //Forwarded information definition

   735 NONSHARABLE_STRUCT( TPEForwardedInfo )

   736     {

   737     RMobilePhone::TMobilePhoneCFCondition iCondition;

   738     RMobilePhone::TMobileService iServiceGroup;

   739     RMobilePhone::TMobilePhoneCFStatus iStatus; 

   740     TPEPhoneNumber iPhoneNumber;

   741     TInt iTimeout;

   742     };

   743 

   744 // Forwarding information definition

   745 NONSHARABLE_STRUCT( TPEForwardingInfo )

   746     {

   747     TInt iGroupCount;

   748     TFixedArray<TPEForwardedInfo, KPEMaxServiceGroup> iForwardedInfo;

   749     };

   750 

   751 NONSHARABLE_STRUCT( TPEActiveForwardInfo )

   752     {

   753     RMobilePhone::TMobilePhoneCFActive iActiveType;

   754     RMobilePhone::TMobileService  iServiceGroup;

   755     };

   756 

   757 //Wait information definition

   758 NONSHARABLE_STRUCT( TPEWaitInfo )

   759     {

   760     RMobilePhone::TMobileService iServiceGroup;

   761     RMobilePhone::TMobilePhoneCWStatus iStatus; 

   762     };

   763 

   764 // Waiting information definition

   765 NONSHARABLE_STRUCT( TPEWaitingInfo )

   766     {

   767     TInt iGroupCount;

   768     TFixedArray<TPEWaitInfo, KPEMaxServiceGroup> iWaitInfo;

   769     };

   770 

   771 //Barred information definition

   772 NONSHARABLE_STRUCT( TPEBarredInfo )

   773     {

   774     RMobilePhone::TMobilePhoneCBCondition iCondition;

   775     RMobilePhone::TMobileService iServiceGroup;

   776     RMobilePhone::TMobilePhoneCBStatus iStatus; 

   777     };

   778 

   779 // Barring information definition

   780 NONSHARABLE_STRUCT( TPEBarringInfo )

   781     {

   782     TInt iGroupCount;

   783     TFixedArray<TPEBarredInfo, KPEMaxServiceGroup> iBarredInfo;

   784     };

   785 

   786 // Contains information of the Suplementary Services command.

   787 NONSHARABLE_STRUCT( TPESSCommandInfo )                   // For SS Commands.

   788     {

   789     TPESSAction action;     // SS Action

   790     /*RMobilePhone::TMobileService*/ TInt group;       // MMI Service Code

   791     TPESSType type;         // Supplementary Services type

   792     };

   793 

   794 NONSHARABLE_STRUCT( TPEConferenceMemberInfo )

   795     {

   796     TName iConferenceMemberName;

   797     TInt iConferenceMemberId;

   798     };

   799 

   800 /**

   801  *  Offers message interface from phone application to phone engine.

   802  *

   803  *  ?more_complete_description

   804  *

   805  *  @lib phoneengine

   806  *  @since S60 v4.0 

   807  */

   808 NONSHARABLE_CLASS( MPEPhoneModel ) 

   809     {

   810 public:

   811 

   812     typedef TInt TPEMessagesToPhoneEngine;

   813 

   814     enum

   815         {

   816         // Audio messages                     1000 - 1999

   817         EPEMessageSetAudioMute              = 1000,

   818         EPEMessageSetAudioVolume,

   819         EPEMessageSetAudioOutput,

   820 

   821         // Call messages                      2000 - 2999

   822         EPEMessageAnswer                    = 2000,

   823         EPEMessageClientDial,

   824         EPEMessageContinueDTMFSending,

   825         EPEMessageDial,

   826         EPEMessagePlayDTMF,

   827         EPEMessageEndDTMF,

   828         EPEMessagePhoneNumberEdited,

   829         EPEMessageRelease,

   830         EPEMessageReleaseAll,

   831         EPEMessageReject,

   832         EPEMessageSendDTMF,

   833         EPEMessageStopDTMFSending,

   834         EPEMessageStopTonePlay,

   835         EPEMessageAutomaticAnswerOff,       //UI sends when soft reject is needed

   836         EPEMessageTerminateAllConnections,

   837         EPEMessageSetSwitchToCallFlag,

   838         EPEMessageSwitchToVideoOrVoice,

   839         EPEMessageSatCallRequestCompleted,

   840         EPEMessageClientDialEmergency,

   841         EPEMessageReplaceActive,

   842         EPEMessageContinueEmergencyCallInitialization,

   843         EPEMessageAcceptUnattendedTransfer,

   844         EPEMessageRejectUnattendedTransfer,

   845 

   846         EPEMessageDoUnattendedTransfer,

   847         EPEMessageForwardCallToAddress,

   848         EPEMessageDialServiceCall,

   849         // Contact messages                   3000 - 3999

   850 

   851         // Error messages                     4000 - 4999

   852 

   853         // Network messages                   5000 - 5999

   854 

   855         // Parser messages                    6000 - 6999

   856 

   857         // Security messages                  7000 - 7999

   858 

   859         // Service messages                   8000 - 8999

   860         EPEMessageDisableService            = 8000,

   861 

   862         // Startup messages                   9000 - 9999

   863         EPEMessagePEConstructionReady       = 9000,

   864 

   865         // Miscellaneous messages             10000 - 10999

   866         EPEMessageCheckEmergencyNumber      = 10000 // Request engine to check is entered number emergency.

   867 

   868         // Variant messages                   11000 - 12999

   869         // From KPEMessagesToPhoneEngineGsmFirst

   870         // to KPEMessagesToPhoneEngineGsmLast

   871         };

   872 

   873      virtual ~MPEPhoneModel() {};

   874 

   875     /**

   876      * Returns pointer to information object (CPEEngineInfo) 

   877      *

   878      * @since S60 v4.0

   879      * @return Return pointer to CPEEngineInfo object

   880      */

   881      virtual MPEEngineInfo* EngineInfo() = 0;

   882      

   883     /**

   884      * Reroutes messages from the phone application to the message handler

   885      *

   886      * @since S60 v4.0

   887      * @param aMessage is the message code

   888      */

   889      virtual void HandleMessage( const TInt aMessage ) = 0;

   890      

   891     /**

   892      * Returns the name of the specified message to PhoneEngine

   893      *

   894      * @since S60 v4.0

   895      * @param aMessage is the message code

   896      * @return String containing the name of the message

   897      */

   898      virtual TPtrC NameByMessageToPhoneEngine( const TInt aMessage ) const = 0;

   899 

   900     /**

   901      * Returns the name of the specified message from PhoneEngine

   902      *

   903      * @param aMessage is the message code

   904      * @return String containing the name of the message

   905      */

   906      virtual TPtrC NameByMessageFromPhoneEngine( const TInt aMessage ) const = 0;

   907      

   908     }; // MPEPhoneModel 

   909 

   910 /**

   911 * Utility class for call id.

   912 *

   913 *  @lib PhoneEngine.lib

   914 */

   915 NONSHARABLE_CLASS( CallIdCheck )

   916     {

   917     public:

   918         static inline TBool IsValid( TInt aCallId ) 

   919             {

   920             return aCallId >= 0 && aCallId < KPEMaximumNumberOfCalls;

   921             }

   922         static inline TBool IsVoice( TInt aCallId )

   923             {

   924             return aCallId >= 0 && aCallId < KPEMaximumNumberOfVoiceCalls;

   925             }

   926         static inline TBool IsConference( TInt aCallId )

   927             {

   928             return aCallId >= KPEMaximumNumberOfVoiceCalls && 

   929                    aCallId < ( KPEMaximumNumberOfVoiceCalls + KPEMaximumNumberOfConferenceCalls );

   930             }

   931         static inline TBool IsVideo( TInt aCallId )

   932             {

   933             return aCallId >= ( KPEMaximumNumberOfVoiceCalls + KPEMaximumNumberOfConferenceCalls ) 

   934                 && aCallId < ( KPEMaximumNumberOfVoiceCalls + KPEMaximumNumberOfConferenceCalls + 

   935                 KPEMaximumNumberOfDataCalls );

   936             }            

   937     };

   938 

   939 #endif // PEVIRTUALENGINE_H

   940 

   941 //End of file