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 

    20 #include    <mtclreg.h>

    21 #include    <smsclnt.h>

    22 #include    <smutset.h>

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

    24 #include    <centralrepository.h>       // CRepository

    25 #include    <CommonEngineDomainCRKeys.h>

    26 #include    <ProfileEngineSDKCRKeys.h>

    27 #include    <settingsinternalcrkeys.h>

    28 #include    <satdomainpskeys.h>

    29 #define Q_OS_SYMBIAN // needed to activate homescreendomainpskeys.h

    30 #include    <homescreendomainpskeys.h>

    31 

    32 // ******************************************************************

    33 // TODO: ScreensaverInternalPSKeys.h does no longer exist.

    34 // Must find an alternative way to check screen locked state.

    35 // #include    <ScreensaverInternalPSKeys.h>

    36 // ******************************************************************

    37 #include    <ctsydomainpskeys.h>

    38 #include    <sbdefs.h>

    39 #include    <BTSapDomainPSKeys.h>

    40 

    41 #include    "SATInternalPSKeys.h"

    42 #include    "CSatSystemState.h"

    43 #include    "msatmultimodeapi.h"

    44 #include    "SatLog.h"

    45 

    46 // ============================ MEMBER FUNCTIONS ===============================

    47 

    48 // -----------------------------------------------------------------------------

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

    50 // might leave.

    51 // -----------------------------------------------------------------------------

    52 //

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

    54     {

    55     LOG( SIMPLE,

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

    57     }

    58 

    59 // -----------------------------------------------------------------------------

    60 // Symbian 2nd phase constructor can leave.

    61 // -----------------------------------------------------------------------------

    62 //

    63 void CSatSystemState::ConstructL( MSatMultiModeApi& aPhone )

    64     {

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

    66 

    67     // Define policies

    68     TSecurityPolicy readPolicy( ECapabilityReadUserData );

    69     TSecurityPolicy writePolicy( ECapabilityWriteUserData );

    70 

    71     TInt err( KErrNone );

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

    73     err = RProperty::Define( KPSUidSatServerInternal, 

    74                              KSatIdleModeText,

    75                              RProperty::ELargeText, 

    76                              readPolicy, 

    77                              writePolicy );

    78     LOG2( SIMPLE, 

    79           "SATSYSTEMSTATE: CSatSystemState::ConstructL \

    80           Define KSatIdleModeText err: %i", err )

    81 

    82     err = RProperty::Define( KPSUidSatServerInternal, 

    83                              KSatIdleModeTextIconId,

    84                              RProperty::EInt, 

    85                              readPolicy, 

    86                              writePolicy );

    87     LOG2( SIMPLE, 

    88          "SATSYSTEMSTATE: CSatSystemState::ConstructL \

    89          Define KSatIdleModeTextIconId err: %i", err )                       

    90 

    91     err = RProperty::Define( KPSUidSatServerInternal, 

    92                              KSatIdleModeTextIconQualifier,

    93                              RProperty::EInt, 

    94                              readPolicy, 

    95                              writePolicy );

    96     LOG2( SIMPLE, 

    97           "SATSYSTEMSTATE: CSatSystemState::ConstructL \

    98           Define KSatIdleModeTextIconQualifier err: %i", err )                         

    99 

   100     // Set default (empty) values

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

   102 

   103     err = RProperty::Define( KPSUidSatServer, 

   104                              KSatLanguageSelectionTimeBeforeReboot,

   105                              RProperty::EInt, 

   106                              readPolicy, 

   107                              writePolicy );

   108     LOG2( SIMPLE, 

   109           "SATSYSTEMSTATE: CSatSystemState::ConstructL \

   110           Define KSatLanguageSelectionTimeBeforeReboot err: %i", err )                        

   111 

   112     // Create Network Registration Status Monitor.

   113     iNetworkRegStatusMonitor = CSatNetworkRegStatusMonitor::NewL( aPhone );

   114 

   115     // Start Network Registration Status Monitor.

   116     iNetworkRegStatusMonitor->Start();

   117 

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

   119     }

   120 

   121 // -----------------------------------------------------------------------------

   122 // Two-phased constructor.

   123 // -----------------------------------------------------------------------------

   124 //

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

   126     {

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

   128 

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

   130     CleanupStack::PushL( self );

   131     self->ConstructL( aPhone );

   132     CleanupStack::Pop( self );

   133 

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

   135     return self;

   136     }

   137 

   138 

   139 // Destructor

   140 CSatSystemState::~CSatSystemState()

   141     {

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

   143 

   144     delete iNetworkRegStatusMonitor;

   145     iNetworkRegStatusMonitor = NULL;

   146 

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

   148     }

   149 

   150 // -----------------------------------------------------------------------------

   151 // Returns network registration status.

   152 // -----------------------------------------------------------------------------

   153 //

   154 RMobilePhone::TMobilePhoneRegistrationStatus

   155     CSatSystemState::GetNetworkRegistrationStatus()

   156     {

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

   158         GetNetworkRegistrationStatus calling-exiting" )

   159     return iNetworkRegStatusMonitor->CurrentValue();

   160     }

   161 

   162 // -----------------------------------------------------------------------------

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

   164 // voice call active.

   165 // -----------------------------------------------------------------------------

   166 //

   167 TBool CSatSystemState::IsCallActive()

   168     {

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

   170     TInt callActiveState = EPSCTsyCallTypeNone;

   171 

   172     // Get current call status from P&S

   173     const TInt errCode( RProperty::Get(

   174         KPSUidCtsyCallInformation,

   175         KCTsyCallType,

   176         callActiveState ) );

   177 

   178     // Check current call type

   179     TBool result(

   180         ( EPSCTsyCallTypeCSVoice == callActiveState ) &&

   181         ( KErrNone == errCode ) );

   182 

   183     LOG2(

   184         SIMPLE,

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

   186         result )

   187     return result;

   188     }

   189 

   190 // -----------------------------------------------------------------------------

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

   192 // -----------------------------------------------------------------------------

   193 //

   194 TBool CSatSystemState::IsCallIncoming()

   195     {

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

   197 

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

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

   200     TBool result( iPhone.IsCallIncoming() );

   201 

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

   203         with value: %d", result )

   204     return result;

   205     }

   206 

   207 // -----------------------------------------------------------------------------

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

   209 // -----------------------------------------------------------------------------

   210 //

   211 const TDesC& CSatSystemState::SCANumber()

   212     {

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

   214 

   215     // Null possible previous SCA number

   216     iScaAddress = KNullDesC;

   217     TBuf<KMaxSCANumberSize> address;

   218 

   219     TRAPD( err, ReadCurrentSMSCL( address ) );

   220     LOG2( SIMPLE,

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

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

   223     if ( KErrNone != err )

   224         {

   225         address = KNullDesC;

   226         }

   227 

   228     iScaAddress = address;

   229 

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

   231     return iScaAddress;

   232     }

   233 

   234 // -----------------------------------------------------------------------------

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

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

   237 // -----------------------------------------------------------------------------

   238 //

   239 TBool CSatSystemState::IsSilentMode()

   240     {

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

   242     TBool result( EFalse );

   243     TInt silenceMode( -1 );

   244     CRepository* centRep( NULL );

   245 

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

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

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

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

   250         {

   251         // Get the needed information from CentRep

   252         centRep->Get( KProEngActiveMessageAlert, silenceMode );

   253 

   254         // Delete CentRep

   255         delete centRep;

   256 

   257         if ( 0 == silenceMode )

   258             {

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

   260                           Silent mode" )

   261             result = ETrue;

   262             }

   263         }

   264     

   265     LOG2(

   266         SIMPLE,

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

   268         result )

   269     return result;

   270     }

   271 

   272 // -----------------------------------------------------------------------------

   273 // Checks is phone in idle state.

   274 // -----------------------------------------------------------------------------

   275 //

   276 TBool CSatSystemState::IsPhoneInIdleStateL()

   277     {

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

   279     TInt idleStatus(EHomeScreenIdleState) ;

   280 

   281     // Get the idle status from P&S

   282     User::LeaveIfError( RProperty::Get(

   283         KHsCategoryUid, 

   284         KHsCategoryStateKey, 

   285         idleStatus));

   286     // Returns true if phone in idle state. 

   287     const TBool result( EHomeScreenIdleState == idleStatus ); 

   288 

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

   290         with value: %d", result )

   291     return result;

   292     }

   293     

   294 // -----------------------------------------------------------------------------

   295 // Checks is screen saver actived from idle.

   296 // -----------------------------------------------------------------------------

   297 //

   298 TBool CSatSystemState::IsScreenSaverActivedFromIdle()

   299     {

   300     LOG( SIMPLE, 

   301     "SATSYSTEMSTATE: CSatSystemState::IsScreenSaverActivedFromIdle calling" )

   302     TBool result( EFalse );

   303 

   304     /*

   305     // TODO: This method can no longer be used for checking screen saver status.

   306     // Must find an alternative method.

   307 

   308     TInt screenSaverActive( -1 );

   309 

   310     // Get the idle status from P&S

   311     TInt err = RProperty::Get( KPSUidScreenSaver, 

   312         KScreenSaverActivatedFromIdle, screenSaverActive );

   313         

   314     if ( KErrNone == err )

   315         {

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

   317         if ( screenSaverActive )

   318             {

   319             result = ETrue;

   320             }

   321         }

   322 

   323     LOG2( SIMPLE, 

   324         "SATSYSTEMSTATE: CSatSystemState:: IsScreenSaverActivedFromIdle \

   325          err: %d", err )

   326     */

   327 

   328     LOG2( SIMPLE, 

   329         "SATSYSTEMSTATE: CSatSystemState:: \

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

   331     return result;    

   332     }

   333 

   334 // -----------------------------------------------------------------------------

   335 // Sets time between language selection and reboot.

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

   337 //

   338 TInt CSatSystemState::WriteLanguageSelectionTime(

   339     TInt aTime )

   340     {

   341     LOG2( NORMAL,

   342     "SATSYSTEMSTATE: CSatSystemState::WriteLanguageSelectionTime calling, \

   343     aTime: %d", aTime )

   344     TInt errorCode( KErrNone );

   345 

   346     // Set SetUpIdleModeText string

   347     errorCode = RProperty::Set(

   348         KPSUidSatServer,

   349         KSatLanguageSelectionTimeBeforeReboot,

   350         aTime );

   351     LOG2( NORMAL,

   352     "SATSYSTEMSTATE: CSatSystemState::WriteLanguageSelectionTime exiting, \

   353     errorCode: %d", errorCode )

   354     return errorCode;

   355     }

   356 

   357 // -----------------------------------------------------------------------------

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

   359 // -----------------------------------------------------------------------------

   360 //

   361 TInt CSatSystemState::WriteSetIdleModeText(

   362     const TDesC& aString,

   363     TInt aIconId,

   364     RSat::TIconQualifier aIconQualifier )

   365     {

   366     LOG( SIMPLE,

   367         "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText calling" )

   368     LOG2(

   369         NORMAL,

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

   371         aIconId )

   372     TInt errorCode( KErrNone );

   373 

   374     // Set SetUpIdleModeText string

   375     errorCode = RProperty::Set(

   376         KPSUidSatServerInternal,

   377         KSatIdleModeText,

   378         aString );

   379     LOG2( NORMAL,

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

   381      errorCode )

   382     if ( KErrNone == errorCode )

   383         {

   384         // Set SetUpIdleModeText icon

   385         errorCode = RProperty::Set(

   386             KPSUidSatServerInternal,

   387             KSatIdleModeTextIconId,

   388             aIconId );

   389         if ( KErrNone == errorCode )

   390             {

   391             // Select qualifier value for icon.

   392             TSatIdleModeTextIconQualifierValue qualifier( KSatIdleIconQInit );

   393             LOG2( NORMAL,

   394             "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText \

   395             aIconQualifier: %d", aIconQualifier )

   396             switch ( aIconQualifier )

   397                 {

   398                 // Icon not present.

   399                 case RSat::ENoIconId:

   400                     {

   401                     qualifier = KSatIdleIconQNoIcon;

   402                     break;

   403                     }

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

   405                 case RSat::ESelfExplanatory:

   406                     {

   407                     qualifier = KSatIdleIconQSelfExplanatory;

   408                     break;

   409                     }

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

   411                 case RSat::ENotSelfExplanatory:

   412                     {

   413                     qualifier = KSatIdleIconQNotSelfExplanatory;

   414                     break;

   415                     }

   416                 // Icon qualifier is not set.

   417                 case RSat::EIconQualifierNotSet:

   418                 default:

   419                     {

   420                     qualifier = KSatIdleIconQInit;

   421                     break;

   422                     }

   423                 }

   424 

   425                 LOG2( NORMAL,

   426                 "SATSYSTEMSTATE: CSatSystemState::WriteSetIdleModeText \

   427                 IconQualifier: %d", qualifier )

   428 

   429             // Set qualifier for icon.

   430             errorCode = RProperty::Set(

   431                 KPSUidSatServerInternal,

   432                 KSatIdleModeTextIconQualifier,

   433                 qualifier );

   434             }

   435         }

   436 

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

   438         exiting with value: %d", errorCode )

   439     return errorCode;

   440     }

   441 

   442 // -----------------------------------------------------------------------------

   443 // Checks is backup process ongoing.

   444 // -----------------------------------------------------------------------------

   445 //

   446 TBool CSatSystemState::IsBackupProcessOngoing()

   447     {

   448     LOG( SIMPLE,

   449         "SATSYSTEMSTATE: CSatSystemState::IsBackupProcessOngoing calling" )

   450     TInt backupState( conn::ENoBackup );

   451 

   452     // Get the backup state from P&S

   453     const TInt errCode( RProperty::Get(

   454         KUidSystemCategory,

   455         conn::KUidBackupRestoreKey,

   456         backupState ) );

   457 

   458     TBool result(

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

   460         && ( KErrNone == errCode ) );

   461 

   462     LOG2( SIMPLE,

   463         "SATSYSTEMSTATE: CSatSystemState::IsBackupProcessOngoing exiting \

   464         with value: %d", result )

   465     return result;

   466     }

   467 

   468 // -----------------------------------------------------------------------------

   469 // CSatSystemState::IsConfirmSatOperationsOn

   470 // -----------------------------------------------------------------------------

   471 //

   472 TBool CSatSystemState::IsConfirmSatOperationsOn()

   473     {

   474     LOG( SIMPLE,

   475         "SATSYSTEMSTATE: CSatSystemState::IsConfirmSatOperationsOn calling" )

   476     TBool result( EFalse );

   477     TInt confirmSatOperations( 0 );

   478     CRepository* centRep( NULL );

   479 

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

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

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

   483         {

   484         // Get the needed information from CentRep

   485         centRep->Get( KSettingsConfirmSatOperations, confirmSatOperations );

   486 

   487         // Delete CentRep

   488         delete centRep;

   489 

   490         if ( 1 == confirmSatOperations )

   491             {

   492             LOG( SIMPLE,

   493             "SATSYSTEMSTATE: CSatSystemState::IsConfirmSatOperationsOn \

   494             1 == confirmSatOperations" )

   495             result = ETrue;

   496             }

   497         }

   498     

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

   500         exiting with value: %d", result )

   501     return result;

   502     }

   503 

   504 // -----------------------------------------------------------------------------

   505 // CSatSystemState::DisplayTextLanguage

   506 // -----------------------------------------------------------------------------

   507 //

   508 TBool CSatSystemState::DisplayTextLanguage()

   509     {

   510     LOG( SIMPLE,

   511         "SATSYSTEMSTATE: CSatSystemState::DisplayTextLanguage calling" )

   512     TInt selLanguage( 0 );

   513     CRepository* centRep( NULL );

   514 

   515     // Create instance to CentRep

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

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

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

   519         {

   520         // Get the needed information from CentRep

   521         centRep->Get( KGSDisplayTxtLang, selLanguage );

   522 

   523         // Delete CentRep

   524         delete centRep;

   525         }

   526     

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

   528         exiting with value: %d", selLanguage )

   529     return selLanguage;

   530     }

   531 

   532 // -----------------------------------------------------------------------------

   533 // Checks is BT SAP active

   534 // -----------------------------------------------------------------------------

   535 //

   536 TBool CSatSystemState::IsBtSapActive()

   537     {

   538     LOG( SIMPLE,

   539         "SATSYSTEMSTATE: CSatSystemState::IsBtSapActive calling" )

   540     TInt sapActive( EBTSapNotConnected );

   541 

   542     // Get the backup state from P&S

   543     const TInt errCode( RProperty::Get(

   544         KPSUidBluetoothSapConnectionState,

   545         KBTSapConnectionState,

   546         sapActive ) );

   547 

   548     LOG2(

   549         SIMPLE,

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

   551 

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

   553                     ( EBTSapConnected == sapActive ) ) &&

   554                     ( KErrNone == errCode ) );

   555 

   556     LOG2(

   557         SIMPLE,

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

   559         result )

   560     return result;

   561     }

   562 

   563 // -----------------------------------------------------------------------------

   564 // Reads current SMS Center number.

   565 // -----------------------------------------------------------------------------

   566 //

   567 void CSatSystemState::ReadCurrentSMSCL( TDes& aAddress )

   568     {

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

   570 

   571     aAddress = KNullDesC;

   572     TInt status( KErrNone );

   573 

   574     // Open message server connection.

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

   576     CleanupStack::PushL( msvSession );

   577 

   578     CClientMtmRegistry* clientRegistry =

   579         CClientMtmRegistry::NewL( *msvSession );

   580 

   581     CleanupStack::PushL( clientRegistry );

   582 

   583     // Get the account.

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

   585     if ( KMsvUnknownServiceIndexEntryId != serviceId )

   586         {

   587         LOG( SIMPLE, 

   588         "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   589         KMsvUnknownServiceIndexEntryId != serviceId" )

   590         // Read the setting.

   591         CSmsClientMtm* mtm =

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

   593         CleanupStack::PushL( mtm );

   594         mtm->SwitchCurrentEntryL( serviceId );

   595         mtm->LoadMessageL();

   596         // Findout the number.

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

   598 

   599 #ifndef __HIDE_MESSAGING_API_V1__

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

   601             {

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

   603                 {

   604                 LOG( SIMPLE, 

   605                 "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

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

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

   608                 aAddress = addr;

   609                 }

   610             else

   611                 {

   612                 LOG( SIMPLE, 

   613                 "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   614                 others" )

   615                 status = KErrOverflow;

   616                 }

   617             }

   618 #else

   619 

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

   621             {

   622             LOG( SIMPLE, 

   623             "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   624             settings.ServiceCenterCount() != 0" )

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

   626                 {

   627                 LOG( SIMPLE, 

   628                 "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   629                 settings.DefaultServiceCenter() < \

   630                 settings.ServiceCenterCount()" )

   631                 TPtrC addr = settings.GetServiceCenter(

   632                     settings.DefaultServiceCenter() ).Address();

   633                 aAddress = addr;

   634                 }

   635             else

   636                 {

   637                 status = KErrOverflow;

   638                 }

   639             }

   640 

   641 #endif

   642         else

   643             {

   644             LOG( SIMPLE, 

   645             "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   646             settings.ServiceCenterCount() == 0" )

   647             status = KErrNotFound;

   648             }

   649 

   650         // Cleanup.

   651         CleanupStack::PopAndDestroy( mtm );

   652         }

   653     else

   654         {

   655         LOG( SIMPLE, 

   656         "SATSYSTEMSTATE: CSatSystemState::ReadCurrentSMSCL \

   657         KMsvUnknownServiceIndexEntryId == serviceId" )

   658         status = KErrNotFound;

   659         }

   660 

   661     CleanupStack::PopAndDestroy( clientRegistry );

   662     CleanupStack::PopAndDestroy( msvSession );

   663 

   664     if ( KErrNone != status )

   665         {

   666         LOG2( NORMAL,

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

   668             status )

   669         User::Leave( status );

   670         }

   671 

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

   673     }

   674 

   675 // -----------------------------------------------------------------------------

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

   677 // -----------------------------------------------------------------------------

   678 //

   679 TMsvId CSatSystemState::ServiceForMTML(

   680     CMsvSession& aSession,

   681     const TUid& aMtm ) const

   682     {

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

   684 

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

   686     CleanupStack::PushL( entry );

   687     TMsvId serviceId = KMsvUnknownServiceIndexEntryId;

   688     LOG2( SIMPLE, 

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

   690      entry->Count() )

   691     // Check are there any entries

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

   693         {        

   694         entry->SetSortTypeL(

   695             TMsvSelectionOrdering( KMsvGroupByType | KMsvGroupByStandardFolders,

   696             EMsvSortByDetailsReverse,

   697             ETrue ) );

   698 

   699         const TMsvEntry* tentry;

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

   701             {

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

   703             if ( tentry->iMtm == aMtm )

   704                 {

   705                 LOG( SIMPLE, 

   706                 "SATSYSTEMSTATE: CSatSystemState::ServiceForMTML \

   707                 tentry->iMtm == aMtm" )

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

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

   710                     {

   711                     LOG( SIMPLE, 

   712                     "SATSYSTEMSTATE: CSatSystemState::ServiceForMTML \

   713                     exit loop" )

   714                     serviceId = tentry->Id();

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

   716                     }

   717                 }

   718             }

   719         }

   720 

   721     CleanupStack::PopAndDestroy( entry );

   722 

   723     LOG2( SIMPLE,

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

   725     serviceId )

   726     return serviceId;

   727     }

   728 

   729 // -----------------------------------------------------------------------------

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

   731 // mode is needed.

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

   733 // -----------------------------------------------------------------------------

   734 //

   735 TBool CSatSystemState::IsWarningAndGameTonesOn()

   736     {

   737     LOG( SIMPLE, "SATSYSTEMSTATE: \

   738         CSatSystemState::IsWarningAndGameTonesOn calling" )

   739 

   740     TBool modeOn( ETrue );

   741     CRepository* centRep( NULL );

   742 

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

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

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

   746         {

   747         // Get the needed information from CentRep

   748         centRep->Get( KProEngActiveWarningTones, modeOn );

   749 

   750         // Delete CentRep

   751         delete centRep;

   752 

   753         }

   754    

   755     LOG2(

   756         SIMPLE,

   757         "SATSYSTEMSTATE: \

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

   759         modeOn )

   760 

   761     return modeOn;

   762     }