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:  Provides system state information to SAT Server

    15 *

    16 */

    17 

    18 

    19 #include    <mtclreg.h>

    20 #include    <smsclnt.h>

    21 #include    <smutset.h>

    22 #include    <PSVariables.h>             // Publish & Suscribe keys

    23 #include    <centralrepository.h>       // CRepository

    24 #include    <CommonEngineDomainCRKeys.h>

    25 #include    <ProfileEngineSDKCRKeys.h>

    26 #include    <settingsinternalcrkeys.h>

    27 #include    <SATDomainPSKeys.h>

    28 #include    <activeidle2domainpskeys.h>

    29 #include    <ScreensaverInternalPSKeys.h>

    30 #include    <ctsydomainpskeys.h>

    31 #include    <sbdefs.h>

    32 #include    <BTSapDomainPSKeys.h>

    33 #include    <SATDomainPSKeys.h>

    34 

    35 #include    "SATInternalPSKeys.h"

    36 #include    "CSatSystemState.h"

    37 #include    "msatmultimodeapi.h"

    38 #include    "SatLog.h"

    39 

    40 // ============================ MEMBER FUNCTIONS ===============================

    41 

    42 // -----------------------------------------------------------------------------

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

    44 // might leave.

    45 // -----------------------------------------------------------------------------

    46 //

    47 CSatSystemState::CSatSystemState( MSatMultiModeApi& aPhone ) : iPhone( aPhone )

    48     {

    49     LOG( SIMPLE,

    50         "SATSYSTEMSTATE: CSatSystemState::CSatSystemState calling-exiting" )

    51     }

    52 

    53 // -----------------------------------------------------------------------------

    54 // Symbian 2nd phase constructor can leave.

    55 // -----------------------------------------------------------------------------

    56 //

    57 void CSatSystemState::ConstructL( MSatMultiModeApi& aPhone )

    58     {

    59     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::ConstructL calling" )

    60 

    61     // Define policies

    62     TSecurityPolicy readPolicy( ECapabilityReadUserData );

    63     TSecurityPolicy writePolicy( ECapabilityWriteUserData );

    64 

    65     TInt err( KErrNone );

    66     // Define properties in P&S for SetUpIdleModeTex command

    67     err = RProperty::Define( KPSUidSatServerInternal, 

    68                              KSatIdleModeText,

    69                              RProperty::ELargeText, 

    70                              readPolicy, 

    71                              writePolicy );

    72     LOG2( SIMPLE, 

    73           "SATSYSTEMSTATE: CSatSystemState::ConstructL \

    74           Define KSatIdleModeText err: %i", err )

    75 

    76     err = RProperty::Define( KPSUidSatServerInternal, 

    77                              KSatIdleModeTextIconId,

    78                              RProperty::EInt, 

    79                              readPolicy, 

    80                              writePolicy );

    81     LOG2( SIMPLE, 

    82          "SATSYSTEMSTATE: CSatSystemState::ConstructL \

    83          Define KSatIdleModeTextIconId err: %i", err )                       

    84 

    85     err = RProperty::Define( KPSUidSatServerInternal, 

    86                              KSatIdleModeTextIconQualifier,

    87                              RProperty::EInt, 

    88                              readPolicy, 

    89                              writePolicy );

    90     LOG2( SIMPLE, 

    91           "SATSYSTEMSTATE: CSatSystemState::ConstructL \

    92           Define KSatIdleModeTextIconQualifier err: %i", err )                         

    93 

    94     // Set default (empty) values

    95     WriteSetIdleModeText( KNullDesC, KErrNotFound, RSat::ENoIconId );

    96 

    97     err = RProperty::Define( KPSUidSatServer, 

    98                              KSatLanguageSelectionTimeBeforeReboot,

    99                              RProperty::EInt, 

   100                              readPolicy, 

   101                              writePolicy );

   102     LOG2( SIMPLE, 

   103           "SATSYSTEMSTATE: CSatSystemState::ConstructL \

   104           Define KSatLanguageSelectionTimeBeforeReboot err: %i", err )                        

   105 

   106     // Create Network Registration Status Monitor.

   107     iNetworkRegStatusMonitor = CSatNetworkRegStatusMonitor::NewL( aPhone );

   108 

   109     // Start Network Registration Status Monitor.

   110     iNetworkRegStatusMonitor->Start();

   111 

   112     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::ConstructL exiting" )

   113     }

   114 

   115 // -----------------------------------------------------------------------------

   116 // Two-phased constructor.

   117 // -----------------------------------------------------------------------------

   118 //

   119 MSatSystemState* CSatSystemState::NewL( MSatMultiModeApi& aPhone )

   120     {

   121     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::NewL calling" )

   122 

   123     CSatSystemState* self = new( ELeave ) CSatSystemState( aPhone );

   124     CleanupStack::PushL( self );

   125     self->ConstructL( aPhone );

   126     CleanupStack::Pop( self );

   127 

   128     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::NewL exiting" )

   129     return self;

   130     }

   131 

   132 

   133 // Destructor

   134 CSatSystemState::~CSatSystemState()

   135     {

   136     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::~CSatSystemState calling" )

   137 

   138     delete iNetworkRegStatusMonitor;

   139     iNetworkRegStatusMonitor = NULL;

   140 

   141     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::~CSatSystemState exiting" )

   142     }

   143 

   144 // -----------------------------------------------------------------------------

   145 // Returns network registration status.

   146 // -----------------------------------------------------------------------------

   147 //

   148 RMobilePhone::TMobilePhoneRegistrationStatus

   149     CSatSystemState::GetNetworkRegistrationStatus()

   150     {

   151     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::\

   152         GetNetworkRegistrationStatus calling-exiting" )

   153     return iNetworkRegStatusMonitor->CurrentValue();

   154     }

   155 

   156 // -----------------------------------------------------------------------------

   157 // Checks current call status and returns true only if cuurent call status is

   158 // voice call active.

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

   160 //

   161 TBool CSatSystemState::IsCallActive()

   162     {

   163     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::IsCallActive calling" )

   164     TInt callActiveState = EPSCTsyCallTypeNone;

   165 

   166     // Get current call status from P&S

   167     const TInt errCode( RProperty::Get(

   168         KPSUidCtsyCallInformation,

   169         KCTsyCallType,

   170         callActiveState ) );

   171 

   172     // Check current call type

   173     TBool result(

   174         ( EPSCTsyCallTypeCSVoice == callActiveState ) &&

   175         ( KErrNone == errCode ) );

   176 

   177     LOG2(

   178         SIMPLE,

   179         "SATSYSTEMSTATE: CSatSystemState::IsCallActive exiting with value: %d",

   180         result )

   181     return result;

   182     }

   183 

   184 // -----------------------------------------------------------------------------

   185 // Checks current call state and returns true if phone is alerting or ringing.

   186 // -----------------------------------------------------------------------------

   187 //

   188 TBool CSatSystemState::IsCallIncoming()

   189     {

   190     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::IsCallIncoming calling" )

   191 

   192     // Using MSatMultiModeApi::IsCallIncoming to check call status instead of

   193     // checking P&S key so that we can get the status on time

   194     TBool result( iPhone.IsCallIncoming() );

   195 

   196     LOG2( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::IsCallIncoming exiting \

   197         with value: %d", result )

   198     return result;

   199     }

   200 

   201 // -----------------------------------------------------------------------------

   202 // Gets the SMS Service center number and returns it.

   203 // -----------------------------------------------------------------------------

   204 //

   205 const TDesC& CSatSystemState::SCANumber()

   206     {

   207     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::SCANumber calling" )

   208 

   209     // Null possible previous SCA number

   210     iScaAddress = KNullDesC;

   211     TBuf<KMaxSCANumberSize> address;

   212 

   213     TRAPD( err, ReadCurrentSMSCL( address ) );

   214     LOG2( SIMPLE,

   215     "SATSYSTEMSTATE: CSatSystemState::SCANumber err: %d", err )

   216     // If any error occurs, return null string.

   217     if ( KErrNone != err )

   218         {

   219         address = KNullDesC;

   220         }

   221 

   222     iScaAddress = address;

   223 

   224     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::SCANumber exiting" )

   225     return iScaAddress;

   226     }

   227 

   228 // -----------------------------------------------------------------------------

   229 // Method is used when the information of phones silent mode is needed.

   230 // Returns true if silent mode is on and false otherwise.

   231 // -----------------------------------------------------------------------------

   232 //

   233 TBool CSatSystemState::IsSilentMode()

   234     {

   235     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::IsSilentMode calling" )

   236     TBool result( EFalse );

   237     TInt silenceMode( -1 );

   238     CRepository* centRep( NULL );

   239 

   240     TRAPD( err, centRep = CRepository::NewL( KCRUidProfileEngine ) );

   241     LOG2( SIMPLE, "SATSYSTEMSTATE:CSatSystemState::IsSilentMode\

   242                    CRepository::NewL result: %i", err )

   243     if ( ( KErrNone == err ) && centRep )

   244         {

   245         // Get the needed information from CentRep

   246         centRep->Get( KProEngActiveMessageAlert, silenceMode );

   247 

   248         // Delete CentRep

   249         delete centRep;

   250 

   251         if ( 0 == silenceMode )

   252             {

   253             LOG( SIMPLE, "SATSYSTEMSTATE:CSatSystemState::IsSilentMode\

   254                           Silent mode" )

   255             result = ETrue;

   256             }

   257         }

   258     

   259     LOG2(

   260         SIMPLE,

   261         "SATSYSTEMSTATE: CSatSystemState::IsSilentMode exiting with value: %d",

   262         result )

   263     return result;

   264     }

   265 

   266 // -----------------------------------------------------------------------------

   267 // Checks is phone in idle state.

   268 // -----------------------------------------------------------------------------

   269 //

   270 TBool CSatSystemState::IsPhoneInIdleStateL()

   271     {

   272     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::IsPhoneInIdleState calling" )

   273     TInt idleStatus;

   274 

   275     // Get the idle status from P&S

   276     User::LeaveIfError( RProperty::Get(

   277         KPSUidAiInformation,

   278         KActiveIdleState,

   279         idleStatus ) );

   280 

   281     // Returns true if phone in idle state.

   282     const TBool result( EPSAiForeground == idleStatus );

   283 

   284     LOG2( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::IsPhoneInIdleState exiting \

   285         with value: %d", result )

   286     return result;

   287     }

   288     

   289 // -----------------------------------------------------------------------------

   290 // Checks is screen saver actived from idle.

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

   292 //

   293 TBool CSatSystemState::IsScreenSaverActivedFromIdle()

   294     {

   295     LOG( SIMPLE, 

   296     "SATSYSTEMSTATE: CSatSystemState::IsScreenSaverActivedFromIdle calling" )

   297     TBool result( EFalse );

   298     TInt screenSaverActive( -1 );

   299 

   300     // Get the idle status from P&S

   301     TInt err = RProperty::Get( KPSUidScreenSaver, 

   302         KScreenSaverActivatedFromIdle, screenSaverActive );

   303         

   304     if ( KErrNone == err )

   305         {

   306         // Returns true if screen saver is actived from idle.    

   307         if ( screenSaverActive )

   308             {

   309             result = ETrue;

   310             }

   311         }

   312 

   313     LOG2( SIMPLE, 

   314         "SATSYSTEMSTATE: CSatSystemState:: IsScreenSaverActivedFromIdle \

   315          err: %d", err )

   316         

   317     LOG2( SIMPLE, 

   318         "SATSYSTEMSTATE: CSatSystemState:: \

   319         IsScreenSaverActivedFromIdle exiting with value: %d", result )

   320     return result;    

   321     }

   322 

   323 // -----------------------------------------------------------------------------

   324 // Sets time between language selection and reboot.

   325 // -----------------------------------------------------------------------------

   326 //

   327 TInt CSatSystemState::WriteLanguageSelectionTime(

   328     TInt aTime )

   329     {

   330     LOG2( NORMAL,

   331     "SATSYSTEMSTATE: CSatSystemState::WriteLanguageSelectionTime calling, \

   332     aTime: %d", aTime )

   333     TInt errorCode( KErrNone );

   334 

   335     // Set SetUpIdleModeText string

   336     errorCode = RProperty::Set(

   337         KPSUidSatServer,

   338         KSatLanguageSelectionTimeBeforeReboot,

   339         aTime );

   340     LOG2( NORMAL,

   341     "SATSYSTEMSTATE: CSatSystemState::WriteLanguageSelectionTime exiting, \

   342     errorCode: %d", errorCode )

   343     return errorCode;

   344     }

   345 

   346 // -----------------------------------------------------------------------------

   347 // Writes idle mode text and icon ID to P&S.

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

   349 //

   350 TInt CSatSystemState::WriteSetIdleModeText(

   351     const TDesC& aString,

   352     TInt aIconId,

   353     RSat::TIconQualifier aIconQualifier )

   354     {

   355     LOG( SIMPLE,

   356         "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText calling" )

   357     LOG2(

   358         NORMAL,

   359         "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText ID: %d",

   360         aIconId )

   361     TInt errorCode( KErrNone );

   362 

   363     // Set SetUpIdleModeText string

   364     errorCode = RProperty::Set(

   365         KPSUidSatServerInternal,

   366         KSatIdleModeText,

   367         aString );

   368     LOG2( NORMAL,

   369     "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText errorCode: %d",

   370      errorCode )

   371     if ( KErrNone == errorCode )

   372         {

   373         // Set SetUpIdleModeText icon

   374         errorCode = RProperty::Set(

   375             KPSUidSatServerInternal,

   376             KSatIdleModeTextIconId,

   377             aIconId );

   378         if ( KErrNone == errorCode )

   379             {

   380             // Select qualifier value for icon.

   381             TSatIdleModeTextIconQualifierValue qualifier( KSatIdleIconQInit );

   382             LOG2( NORMAL,

   383             "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText \

   384             aIconQualifier: %d", aIconQualifier )

   385             switch ( aIconQualifier )

   386                 {

   387                 // Icon not present.

   388                 case RSat::ENoIconId:

   389                     {

   390                     qualifier = KSatIdleIconQNoIcon;

   391                     break;

   392                     }

   393                 // Icon is self explanatory. Displayed instead text string.

   394                 case RSat::ESelfExplanatory:

   395                     {

   396                     qualifier = KSatIdleIconQSelfExplanatory;

   397                     break;

   398                     }

   399                 // Icon is not self explanatory. Displayed with text string.

   400                 case RSat::ENotSelfExplanatory:

   401                     {

   402                     qualifier = KSatIdleIconQNotSelfExplanatory;

   403                     break;

   404                     }

   405                 // Icon qualifier is not set.

   406                 case RSat::EIconQualifierNotSet:

   407                 default:

   408                     {

   409                     qualifier = KSatIdleIconQInit;

   410                     break;

   411                     }

   412                 }

   413 

   414                 LOG2( NORMAL,

   415                 "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText \

   416                 IconQualifier: %d", qualifier )

   417 

   418             // Set qualifier for icon.

   419             errorCode = RProperty::Set(

   420                 KPSUidSatServerInternal,

   421                 KSatIdleModeTextIconQualifier,

   422                 qualifier );

   423             }

   424         }

   425 

   426     LOG2( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText \

   427         exiting with value: %d", errorCode )

   428     return errorCode;

   429     }

   430 

   431 // -----------------------------------------------------------------------------

   432 // Checks is backup process ongoing.

   433 // -----------------------------------------------------------------------------

   434 //

   435 TBool CSatSystemState::IsBackupProcessOngoing()

   436     {

   437     LOG( SIMPLE,

   438         "SATSYSTEMSTATE: CSatSystemState::IsBackupProcessOngoing calling" )

   439     TInt backupState( conn::ENoBackup );

   440 

   441     // Get the backup state from P&S

   442     const TInt errCode( RProperty::Get(

   443         KUidSystemCategory,

   444         conn::KUidBackupRestoreKey,

   445         backupState ) );

   446 

   447     TBool result(

   448         ( conn::ENoBackup != ( backupState & conn::KBackupIncTypeMask ) )

   449         && ( KErrNone == errCode ) );

   450 

   451     LOG2( SIMPLE,

   452         "SATSYSTEMSTATE: CSatSystemState::IsBackupProcessOngoing exiting \

   453         with value: %d", result )

   454     return result;

   455     }

   456 

   457 // -----------------------------------------------------------------------------

   458 // CSatSystemState::IsConfirmSatOperationsOn

   459 // -----------------------------------------------------------------------------

   460 //

   461 TBool CSatSystemState::IsConfirmSatOperationsOn()

   462     {

   463     LOG( SIMPLE,

   464         "SATSYSTEMSTATE: CSatSystemState::IsConfirmSatOperationsOn calling" )

   465     TBool result( EFalse );

   466     TInt confirmSatOperations( 0 );

   467     CRepository* centRep( NULL );

   468 

   469     TRAPD( err, centRep = CRepository::NewL( KCRUidPersonalizationSettings ) );

   470     LOG2( SIMPLE, "SATSYSTEMSTATE:   CentRep failed: %i", err )

   471     if ( ( KErrNone == err ) && centRep )

   472         {

   473         // Get the needed information from CentRep

   474         centRep->Get( KSettingsConfirmSatOperations, confirmSatOperations );

   475 

   476         // Delete CentRep

   477         delete centRep;

   478 

   479         if ( 1 == confirmSatOperations )

   480             {

   481             LOG( SIMPLE,

   482             "SATSYSTEMSTATE: CSatSystemState::IsConfirmSatOperationsOn \

   483             1 == confirmSatOperations" )

   484             result = ETrue;

   485             }

   486         }

   487     

   488     LOG2( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::IsConfirmSatOperationsOn \

   489         exiting with value: %d", result )

   490     return result;

   491     }

   492 

   493 // -----------------------------------------------------------------------------

   494 // CSatSystemState::DisplayTextLanguage

   495 // -----------------------------------------------------------------------------

   496 //

   497 TBool CSatSystemState::DisplayTextLanguage()

   498     {

   499     LOG( SIMPLE,

   500         "SATSYSTEMSTATE: CSatSystemState::DisplayTextLanguage calling" )

   501     TInt selLanguage( 0 );

   502     CRepository* centRep( NULL );

   503 

   504     // Create instance to CentRep

   505     TRAPD( err, centRep = CRepository::NewL( KCRUidCommonEngineKeys ) );

   506     LOG2( SIMPLE, "SATSYSTEMSTATE:   CentRep failed: %i", err )

   507     if ( ( KErrNone == err ) && centRep )

   508         {

   509         // Get the needed information from CentRep

   510         centRep->Get( KGSDisplayTxtLang, selLanguage );

   511 

   512         // Delete CentRep

   513         delete centRep;

   514         }

   515     

   516     LOG2( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::DisplayTextLanguage \

   517         exiting with value: %d", selLanguage )

   518     return selLanguage;

   519     }

   520 

   521 // -----------------------------------------------------------------------------

   522 // Checks is BT SAP active

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

   524 //

   525 TBool CSatSystemState::IsBtSapActive()

   526     {

   527     LOG( SIMPLE,

   528         "SATSYSTEMSTATE: CSatSystemState::IsBtSapActive calling" )

   529     TInt sapActive( EBTSapNotConnected );

   530 

   531     // Get the backup state from P&S

   532     const TInt errCode( RProperty::Get(

   533         KPSUidBluetoothSapConnectionState,

   534         KBTSapConnectionState,

   535         sapActive ) );

   536 

   537     LOG2(

   538         SIMPLE,

   539         "SATSYSTEMSTATE:   RProperty::Get returned value: %i", errCode )

   540 

   541     TBool result( ( ( EBTSapConnecting == sapActive ) ||

   542                     ( EBTSapConnected == sapActive ) ) &&

   543                     ( KErrNone == errCode ) );

   544 

   545     LOG2(

   546         SIMPLE,

   547         "SATSYSTEMSTATE: CSatSystemState::IsBtSapActive exiting with value: %i",

   548         result )

   549     return result;

   550     }

   551 

   552 // -----------------------------------------------------------------------------

   553 // Reads current SMS Center number.

   554 // -----------------------------------------------------------------------------

   555 //

   556 void CSatSystemState::ReadCurrentSMSCL( TDes& aAddress )

   557     {

   558     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL calling" )

   559 

   560     aAddress = KNullDesC;

   561     TInt status( KErrNone );

   562 

   563     // Open message server connection.

   564     CMsvSession* msvSession = CMsvSession::OpenSyncL( *this );

   565     CleanupStack::PushL( msvSession );

   566 

   567     CClientMtmRegistry* clientRegistry =

   568         CClientMtmRegistry::NewL( *msvSession );

   569 

   570     CleanupStack::PushL( clientRegistry );

   571 

   572     // Get the account.

   573     TInt serviceId( ServiceForMTML( *msvSession, KUidMsgTypeSMS ) );

   574     if ( KMsvUnknownServiceIndexEntryId != serviceId )

   575         {

   576         LOG( SIMPLE, 

   577         "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   578         KMsvUnknownServiceIndexEntryId != serviceId" )

   579         // Read the setting.

   580         CSmsClientMtm* mtm =

   581             static_cast<CSmsClientMtm*>( clientRegistry->NewMtmL( KUidMsgTypeSMS ) );

   582         CleanupStack::PushL( mtm );

   583         mtm->SwitchCurrentEntryL( serviceId );

   584         mtm->LoadMessageL();

   585         // Findout the number.

   586         const CSmsSettings& settings = mtm->ServiceSettings();

   587 

   588 #ifndef __HIDE_MESSAGING_API_V1__

   589         if ( settings.NumSCAddresses() != 0 )

   590             {

   591             if ( settings.DefaultSC() < settings.NumSCAddresses() )

   592                 {

   593                 LOG( SIMPLE, 

   594                 "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   595                 settings.DefaultSC() < settings.NumSCAddresses()" )

   596                 TPtrC addr = settings.SCAddress( settings.DefaultSC() ).Address();

   597                 aAddress = addr;

   598                 }

   599             else

   600                 {

   601                 LOG( SIMPLE, 

   602                 "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   603                 others" )

   604                 status = KErrOverflow;

   605                 }

   606             }

   607 #else

   608 

   609         if ( settings.ServiceCenterCount() != 0 )

   610             {

   611             LOG( SIMPLE, 

   612             "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   613             settings.ServiceCenterCount() != 0" )

   614             if ( settings.DefaultServiceCenter() < settings.ServiceCenterCount() )

   615                 {

   616                 LOG( SIMPLE, 

   617                 "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   618                 settings.DefaultServiceCenter() < \

   619                 settings.ServiceCenterCount()" )

   620                 TPtrC addr = settings.GetServiceCenter(

   621                     settings.DefaultServiceCenter() ).Address();

   622                 aAddress = addr;

   623                 }

   624             else

   625                 {

   626                 status = KErrOverflow;

   627                 }

   628             }

   629 

   630 #endif

   631         else

   632             {

   633             LOG( SIMPLE, 

   634             "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   635             settings.ServiceCenterCount() == 0" )

   636             status = KErrNotFound;

   637             }

   638 

   639         // Cleanup.

   640         CleanupStack::PopAndDestroy( mtm );

   641         }

   642     else

   643         {

   644         LOG( SIMPLE, 

   645         "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   646         KMsvUnknownServiceIndexEntryId == serviceId" )

   647         status = KErrNotFound;

   648         }

   649 

   650     CleanupStack::PopAndDestroy( clientRegistry );

   651     CleanupStack::PopAndDestroy( msvSession );

   652 

   653     if ( KErrNone != status )

   654         {

   655         LOG2( NORMAL,

   656             "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL leave: %d",

   657             status )

   658         User::Leave( status );

   659         }

   660 

   661     LOG( NORMAL, "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL exiting" )

   662     }

   663 

   664 // -----------------------------------------------------------------------------

   665 // Specifies an entry in the Message Server index.

   666 // -----------------------------------------------------------------------------

   667 //

   668 TMsvId CSatSystemState::ServiceForMTML(

   669     CMsvSession& aSession,

   670     const TUid& aMtm ) const

   671     {

   672     LOG( SIMPLE, "SATSYSTEMSTATE: CSatSystemState::ServiceForMTML calling" )

   673 

   674     CMsvEntry* entry = aSession.GetEntryL( KMsvRootIndexEntryIdValue );

   675     CleanupStack::PushL( entry );

   676     TMsvId serviceId = KMsvUnknownServiceIndexEntryId;

   677     LOG2( SIMPLE, 

   678     "SATSYSTEMSTATE: CSatSystemState::ServiceForMTML count: %d",

   679      entry->Count() )

   680     // Check are there any entries

   681     if ( entry->Count() != 0 )

   682         {        

   683         entry->SetSortTypeL(

   684             TMsvSelectionOrdering( KMsvGroupByType | KMsvGroupByStandardFolders,

   685             EMsvSortByDetailsReverse,

   686             ETrue ) );

   687 

   688         const TMsvEntry* tentry;

   689         for ( TInt cc( entry->Count() ); --cc >= 0; )

   690             {

   691             tentry = &( *entry )[cc];

   692             if ( tentry->iMtm == aMtm )

   693                 {

   694                 LOG( SIMPLE, 

   695                 "SATSYSTEMSTATE: CSatSystemState::ServiceForMTML \

   696                 tentry->iMtm == aMtm" )

   697                 if ( ( tentry->iType.iUid == KUidMsvServiceEntryValue ) &&

   698                      ( tentry->Id() != KMsvLocalServiceIndexEntryIdValue ) )

   699                     {

   700                     LOG( SIMPLE, 

   701                     "SATSYSTEMSTATE: CSatSystemState::ServiceForMTML \

   702                     exit loop" )

   703                     serviceId = tentry->Id();

   704                     cc = 0; // To exit for-loop. Replaces break.

   705                     }

   706                 }

   707             }

   708         }

   709 

   710     CleanupStack::PopAndDestroy( entry );

   711 

   712     LOG2( SIMPLE,

   713     "SATSYSTEMSTATE: CSatSystemState::ServiceForMTML exiting with value: %d",

   714     serviceId )

   715     return serviceId;

   716     }

   717 

   718 // -----------------------------------------------------------------------------

   719 // Method is used when the information of phones warnings and game tone

   720 // mode is needed.

   721 // Returns true if silent mode is on and false otherwise.

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

   723 //

   724 TBool CSatSystemState::IsWarningAndGameTonesOn()

   725     {

   726     LOG( SIMPLE, "SATSYSTEMSTATE: \

   727         CSatSystemState::IsWarningAndGameTonesOn calling" )

   728 

   729     TBool modeOn( ETrue );

   730     CRepository* centRep( NULL );

   731 

   732     TRAPD( err, centRep = CRepository::NewL( KCRUidProfileEngine ) );

   733     LOG2( SIMPLE, "SATSYSTEMSTATE:   CentRep failed: %i", err )

   734     if ( ( KErrNone == err ) && centRep )

   735         {

   736         // Get the needed information from CentRep

   737         centRep->Get( KProEngActiveWarningTones, modeOn );

   738 

   739         // Delete CentRep

   740         delete centRep;

   741 

   742         }

   743    

   744     LOG2(

   745         SIMPLE,

   746         "SATSYSTEMSTATE: \

   747         CSatSystemState::IsWarningAndGameTonesOn exiting with value: %d",

   748         modeOn )

   749 

   750     return modeOn;

   751     }