1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  SysInfoPlugin implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "HtiSysInfoServiceplugin.h"

    21 #include "HtiLightsController.h"

    22 #include "HtiPropertySubscriber.h"

    23 #include <HtiDispatcherInterface.h>

    24 #include <HTILogging.h>

    25 

    26 #include <aknkeylock.h>

    27 #include <AknSkinsInternalCRKeys.h>

    28 #include <AknsSkinUID.h>

    29 #include <AknSSrvClient.h>

    30 #include <bautils.h>

    31 #include <btengsettings.h>

    32 #include <btengdomaincrkeys.h>

    33 #include <bt_subscribe.h>

    34 #include <btmanclient.h>

    35 #include <centralrepository.h>

    36 #include <CoreApplicationUIsSDKCRKeys.h>

    37 #include <DRMRightsClient.h>

    38 #include <e32property.h>

    39 #include <etel.h>

    40 #include <etelmm.h>

    41 #include <hal.h>

    42 #include <ir_sock.h>

    43 #include <mmtsy_names.h>

    44 #include <RMmCustomAPI.h>

    45 #include <HWRMPowerStateSDKPSKeys.h>

    46 #include <ScreenSaverInternalPSKeys.h>

    47 #include <SettingsInternalCRKeys.h>

    48 #include <sysutil.h>

    49 #include <tz.h>

    50 

    51 // CONSTANTS

    52 const static TUid KSysInfoServiceUid = { 0x10210CC7 };

    53 

    54 // from irinternalpskey.h

    55 const static TUid KPSUidIrdaActivation = { 0x2000276D };

    56 

    57 const TInt KTimeDataLength = 7;

    58 const TInt KMaxBtNameLength = 30;

    59 const TInt KDateTimeFormatCmdLength = 6;

    60 

    61 _LIT( KTempFilePath, "\\" );

    62 _LIT( KTempFileName, "HtiTempFile.tmp" );

    63 _LIT( KDateSeparatorChars, ".:/-" );

    64 _LIT( KTimeSeparatorChars, ".:" );

    65 

    66 _LIT8( KErrDescrArgument, "Invalid argument" );

    67 _LIT8( KErrDescrNotSupported, "Command not supported" );

    68 _LIT8( KErrDescrHAL, "Error retrieving HAL attribute" );

    69 _LIT8( KErrDescrAttOutOfRange, "HAL attribute argument is out of range" );

    70 _LIT8( KErrDescrFreeRAM, "Error retrieving the amount of free RAM" );

    71 _LIT8( KErrDescrTotalRAM, "Error retrieving the amount of total RAM" );

    72 _LIT8( KErrDescrAllocRAM, "Error allocating RAM" );

    73 _LIT8( KErrDescrInvalidRAM, "Requested free RAM larger than currently free" );

    74 _LIT8( KErrDescrVolInfo, "Error retrieving volume info" );

    75 _LIT8( KErrDescrNotEnoughSpace, "Not enough disk space" );

    76 _LIT8( KErrDescrCreateTempFile, "Error creating temp file" );

    77 _LIT8( KErrDescrSetSizeTempFile, "Error allocating size for temp file" );

    78 _LIT8( KErrDescrDeleteTempFile, "Error deleting temp file" );

    79 _LIT8( KErrDescrSysUtil, "SysUtil failed" );

    80 _LIT8( KErrDescrSetTime, "Setting time failed" );

    81 _LIT8( KErrDescrDateTimeFormat, "Setting date and time formats failed" );

    82 _LIT8( KErrDescrScreenSaver, "Setting screen saver state failed" );

    83 _LIT8( KErrDescrGetNetworkModes, "Getting network modes failed" );

    84 _LIT8( KErrDescrSetNetworkMode, "Setting network mode failed" );

    85 _LIT8( KErrDescrIrActivation, "IR activation failed" );

    86 _LIT8( KErrDescrGetBtPower, "Getting BT power state failed" );

    87 _LIT8( KErrDescrSetBtPower, "Setting BT power state failed" );

    88 _LIT8( KErrDescrBtOnDenied, "Turning BT on not allowed (Offline mode)" );

    89 _LIT8( KErrDescrBtOffDenied, "Turning BT off not allowed (active connections)" );

    90 _LIT8( KErrDescrBtSettings, "Bluetooth settings failed" );

    91 _LIT8( KErrDescrBtDeletePairings, "Deleting Bluetooth pairing(s) failed" );

    92 _LIT8( KErrDescrKeyLock, "Key lock toggle failed" );

    93 _LIT8( KErrDescrInvalidTime, "Auto key guard time value too large (max 3600)" );

    94 _LIT8( KErrDescrAutoKeyGuardFailed, "Setting auto key guard time failed" );

    95 _LIT8( KErrDescrInvalidSSTimeout, "Invalid screen saver timeout value" );

    96 _LIT8( KErrDescrSSTimeoutFailed, "Setting screen saver timeout failed" );

    97 _LIT8( KErrDescrDrmDbConnect, "DRM DB connect failed." );

    98 _LIT8( KErrDescrDrmDbDelete,  "DRM DB delete failed." );

    99 _LIT8( KErrDescrBatteryLevel, "Getting battery level failed." );

   100 _LIT8( KErrDescrChargingStatus, "Getting charging status failed." );

   101 _LIT8( KErrDescrSignalStrength, "Getting signal strength failed." );

   102 _LIT8( KErrDescrMGUpdate, "Update Media Gallery failed" );

   103 _LIT8( KErrDescrActivateSkin, "Activating Skin failed" );

   104 

   105 enum TSysInfoCommand

   106     {

   107     ESysInfoHAL =             0x01,

   108     ESysInfoIMEI=             0x02,

   109     ESysInfoSWVersion =       0x03,

   110     ESysInfoLangVersion =     0x04,

   111     ESysInfoSWLangVersion =   0x05,

   112     ESysInfoUserAgent =       0x06,

   113     EFreeRAM =                0x07,

   114     EUsedRAM =                0x08,

   115     ETotalRAM =               0x09,

   116     EEatRAM =                 0x0A,

   117     EReleaseRAM =             0x0B,

   118     EFreeDiskSpace =          0x0C,

   119     EUsedDiskSpace =          0x0D,

   120     ETotalDiskSize =          0x0E,

   121     EEatDiskSpace =           0x0F,

   122     EReleaseDiskSpace =       0x10,

   123 

   124     ESysInfoSetHomeTime =     0x20,

   125     ESysInfoGetHomeTime =     0x21,

   126     ESetDateTimeFormat =      0x22,

   127 

   128     ELightStatus =            0x30,

   129     ELightOn =                0x31,

   130     ELightOff =               0x32,

   131     ELightBlink =             0x33,

   132     ELightRelease =           0x3A,

   133 

   134     EScreenSaverDisable =     0x40,

   135     EScreenSaverEnable  =     0x41,

   136     EScreenSaverTimeout =     0x42,

   137 

   138     ENetworkModeGet =         0x50,

   139     ENetworkModeSet =         0x51,

   140     ENetworkModeSetNoReboot = 0x52,

   141     EHsdpaSet =               0x53,

   142 

   143     EIrActivate =             0x5A,

   144     EBtPower =                0x5B,

   145     EBtSettings =             0x5C,

   146     EBtDeletePairings =       0x5D,

   147 

   148     EKeylockToggle =          0x60,

   149     EAutoKeyGuardTime =       0x61,

   150 

   151     EEmtpyDrmRightsDb =       0x65,

   152 

   153     EBatteryStatus =          0x70,

   154     ESignalStrength =         0x71,

   155 

   156     EUpdateMediaGallery =     0x7A,

   157 

   158     EActivateSkin =           0x80

   159     };

   160 

   161 

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

   163 // Create instance of concrete ECOM interface implementation

   164 //------------------------------------------------------------------------------

   165 CHtiSysInfoServicePlugin* CHtiSysInfoServicePlugin::NewL()

   166     {

   167     CHtiSysInfoServicePlugin* self = new (ELeave) CHtiSysInfoServicePlugin;

   168     CleanupStack::PushL (self);

   169     self->ConstructL();

   170     CleanupStack::Pop();

   171     return self;

   172     }

   173 

   174 //------------------------------------------------------------------------------

   175 // Constructor

   176 //------------------------------------------------------------------------------

   177 CHtiSysInfoServicePlugin::CHtiSysInfoServicePlugin():

   178     iMemEater( NULL ), iReply( NULL ), iAllowSSValue( -1 ),

   179     iAllowSSPropertyAttached( EFalse ), iGalleryUpdateSupported( ETrue )

   180     {

   181     }

   182 

   183 //------------------------------------------------------------------------------

   184 // Destructor

   185 //------------------------------------------------------------------------------

   186 CHtiSysInfoServicePlugin::~CHtiSysInfoServicePlugin()

   187     {

   188     HTI_LOG_TEXT( "CHtiSysInfoServicePlugin destroy" );

   189     delete iMemEater;

   190     delete iReply;

   191 

   192     CleanUpTempFiles();

   193     delete iFileMan;

   194     iFs.Close();

   195     delete iLightsController;

   196 

   197     if ( iAllowSSSubscriber )

   198         {

   199         iAllowSSSubscriber->Unsubscribe();

   200         }

   201     iAllowSSProperty.Close();

   202     delete iAllowSSSubscriber;

   203     }

   204 

   205 //------------------------------------------------------------------------------

   206 // Second phase construction

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

   208 void CHtiSysInfoServicePlugin::ConstructL()

   209     {

   210     HTI_LOG_TEXT( "CHtiSysInfoServicePlugin::ConstructL" );

   211     User::LeaveIfError( iFs.Connect() );

   212     iFileMan = CFileMan::NewL( iFs );

   213     }

   214 

   215 //------------------------------------------------------------------------------

   216 // CHtiSysInfoServicePlugin::ProcessMessageL

   217 //------------------------------------------------------------------------------

   218 void CHtiSysInfoServicePlugin::ProcessMessageL(const TDesC8& aMessage,

   219                                 THtiMessagePriority /*aPriority*/)

   220     {

   221     HTI_LOG_FUNC_IN( "CHtiSysInfoServicePlugin::ProcessMessage" );

   222     HTI_LOG_FORMAT( "Message length: %d", aMessage.Length() );

   223 

   224     if ( aMessage.Length() > 0 )

   225         {

   226         HTI_LOG_FORMAT( "Command: %d", aMessage[0] );

   227 

   228         switch ( aMessage[0] )

   229             {

   230             case ESysInfoHAL:

   231                 {

   232                 HTI_LOG_TEXT( "ESysInfoHAL" );

   233                 HandleGetHalAttrL( aMessage );

   234                 }

   235                 break;

   236             case ESysInfoIMEI:

   237                 {

   238                 HTI_LOG_TEXT( "ESysInfoIMEI" );

   239                 HandleGetImeiL( aMessage );

   240                 }

   241                 break;

   242             case ESysInfoSWVersion:

   243                 {

   244                 HTI_LOG_TEXT( "ESysInfoSWVersion" );

   245                 HandleGetSwVersionL( aMessage );

   246                 }

   247                 break;

   248             case ESysInfoLangVersion:

   249                 {

   250                 HTI_LOG_TEXT( "ESysInfoLangVersion" );

   251                 HandleGetLangVersionL( aMessage );

   252                 }

   253                 break;

   254             case ESysInfoSWLangVersion:

   255                 {

   256                 HTI_LOG_TEXT( "ESysInfoSWLangVersion" );

   257                 HandleGetSwLangVersionL( aMessage );

   258                 }

   259                 break;

   260             case ESysInfoUserAgent:

   261                 {

   262                 HTI_LOG_TEXT( "ESysInfoUserAgent" );

   263                 HandleGetUserAgentStringL( aMessage );

   264                 }

   265                 break;

   266             case EFreeRAM:

   267                 {

   268                 HTI_LOG_TEXT( "EFreeRAM" );

   269                 HandleGetFreeRamL( aMessage );

   270                 }

   271                 break;

   272             case EUsedRAM:

   273                 {

   274                 HTI_LOG_TEXT( "EUsedRAM" );

   275                 HandleGetUsedRamL( aMessage );

   276                 }

   277                 break;

   278             case ETotalRAM:

   279                 {

   280                 HTI_LOG_TEXT( "ETotalRAM" );

   281                 HandleGetTotalRamL( aMessage );

   282                 }

   283                 break;

   284             case EEatRAM:

   285                 {

   286                 HTI_LOG_TEXT( "EEatRAM" );

   287                 HandleEatRamL( aMessage );

   288                 }

   289                 break;

   290             case EReleaseRAM:

   291                 {

   292                 HTI_LOG_TEXT( "EReleaseRAM" );

   293                 HandleReleaseRamL( aMessage );

   294                 }

   295                 break;

   296             case EFreeDiskSpace:

   297                 {

   298                 HTI_LOG_TEXT( "EFreeDiskSpace" );

   299                 HandleGetFreeDiskSpaceL( aMessage );

   300                 }

   301                 break;

   302             case EUsedDiskSpace:

   303                 {

   304                 HTI_LOG_TEXT( "EUsedDiskSpace" );

   305                 HandleGetUsedDiskSpaceL( aMessage );

   306                 }

   307                 break;

   308             case ETotalDiskSize:

   309                 {

   310                 HTI_LOG_TEXT( "ETotalDiskSize" );

   311                 HandleGetTotalDiskSpaceL( aMessage );

   312                 }

   313                 break;

   314             case EEatDiskSpace:

   315                 {

   316                 HTI_LOG_TEXT( "EEatDiskSpace" );

   317                 HandleEatDiskSpaceL( aMessage );

   318                 }

   319                 break;

   320             case EReleaseDiskSpace:

   321                 {

   322                 HTI_LOG_TEXT( "EReleaseDiskSpace" );

   323                 HandleReleaseDiskSpaceL( aMessage );

   324                 }

   325                 break;

   326             case ESysInfoSetHomeTime:

   327                 {

   328                 HTI_LOG_TEXT( "ESysInfoSetHomeTime" );

   329                 HandleSetHomeTimeL( aMessage );

   330                 }

   331                 break;

   332             case ESysInfoGetHomeTime:

   333                 {

   334                 HTI_LOG_TEXT( "ESysInfoGetHomeTime" );

   335                 HandleGetHomeTimeL( aMessage );

   336                 }

   337                 break;

   338             case ESetDateTimeFormat:

   339                 {

   340                 HTI_LOG_TEXT( "ESetDateTimeFormat" );

   341                 HandleSetDateTimeFormatL( aMessage );

   342                 }

   343                 break;

   344             case ELightStatus:

   345             case ELightOn:

   346             case ELightOff:

   347             case ELightBlink:

   348             case ELightRelease:

   349                 {

   350                 HTI_LOG_TEXT( "ELight*" );

   351                 HandleLightsCommandL( aMessage );

   352                 }

   353                 break;

   354             case EScreenSaverDisable:

   355             case EScreenSaverEnable:

   356                 {

   357                 HTI_LOG_TEXT( "EScreenSaver*" );

   358                 HandleScreenSaverCommandL( aMessage );

   359                 }

   360                 break;

   361             case EScreenSaverTimeout:

   362                 {

   363                 HTI_LOG_TEXT( "EScreenSaverTimeout" );

   364                 HandleScreenSaverTimeoutCommandL( aMessage );

   365                 }

   366                 break;

   367             case ENetworkModeSet:

   368             case ENetworkModeSetNoReboot:

   369             case ENetworkModeGet:

   370                 {

   371                 HTI_LOG_TEXT( "ENetworkMode*" );

   372                 HandleNetworkModeCommandL( aMessage );

   373                 }

   374                 break;

   375             case EHsdpaSet:

   376                 {

   377                 HTI_LOG_TEXT( "EHsdpaSet" );

   378                 HandleHsdpaCommandL( aMessage );

   379                 }

   380                 break;

   381             case EIrActivate:

   382                 {

   383                 HTI_LOG_TEXT( "EIrActivate" );

   384                 HandleIrActivateCommandL( aMessage );

   385                 }

   386                 break;

   387             case EBtPower:

   388                 {

   389                 HTI_LOG_TEXT( "EBtPower" );

   390                 HandleBtPowerCommandL( aMessage );

   391                 }

   392                 break;

   393             case EBtSettings:

   394                 {

   395                 HTI_LOG_TEXT( "EBtSettings" );

   396                 HandleBtSettingsCommandL( aMessage );

   397                 }

   398                 break;

   399             case EBtDeletePairings:

   400                 {

   401                 HTI_LOG_TEXT( "EBtDeletePairings" );

   402                 HandleBtDeletePairingsL( aMessage );

   403                 }

   404                 break;

   405             case EKeylockToggle:

   406                 {

   407                 HTI_LOG_TEXT( "EKeylockToggle" );

   408                 HandleKeyLockToggleL( aMessage );

   409                 }

   410                 break;

   411             case EAutoKeyGuardTime:

   412                 {

   413                 HTI_LOG_TEXT( "EAutoKeyGuardTime" );

   414                 HandleAutoKeyGuardTimeL( aMessage );

   415                 }

   416                 break;

   417             case EEmtpyDrmRightsDb:

   418                 {

   419                 HTI_LOG_TEXT( "EEmtpyDrmRightsDb" );

   420                 HandleEmptyDrmRightsDbL( aMessage );

   421                 }

   422                 break;

   423             case EBatteryStatus:

   424                 {

   425                 HTI_LOG_TEXT( "EBatteryStatus" );

   426                 HandleBatteryStatusL( aMessage );

   427                 }

   428                 break;

   429             case ESignalStrength:

   430                 {

   431                 HTI_LOG_TEXT( "ESignalStrength" );

   432                 HandleSignalStrengthL( aMessage );

   433                 }

   434                 break;

   435             case EUpdateMediaGallery:

   436                 {

   437                 HTI_LOG_TEXT( "EUpdateMediaGallery" );

   438                 HandleUpdateMediaGalleryL( aMessage );

   439                 }

   440                 break;

   441             case EActivateSkin:

   442                 {

   443                 HTI_LOG_TEXT( "EActivateSkin" );

   444                 HandleActivateSkinL( aMessage );

   445                 }

   446                 break;

   447             default:

   448                 {

   449                 iDispatcher->DispatchOutgoingErrorMessage(

   450                     KErrArgument,

   451                     KErrDescrNotSupported,

   452                     KSysInfoServiceUid );

   453                 }

   454             }

   455         }

   456 

   457     else // aMessage.Length() > 0

   458         {

   459         iDispatcher->DispatchOutgoingErrorMessage(

   460             KErrArgument,

   461             KErrDescrArgument,

   462             KSysInfoServiceUid);

   463         }

   464 

   465     if ( iReply )

   466         {

   467         TInt err = iDispatcher->DispatchOutgoingMessage( iReply,

   468                                                          KSysInfoServiceUid );

   469         if ( err == KErrNoMemory )

   470             {

   471             HTI_LOG_TEXT( "KErrNoMemory" );

   472             iDispatcher->AddMemoryObserver( this );

   473             }

   474         else

   475             {

   476             iReply = NULL;

   477             }

   478         }

   479 

   480     HTI_LOG_FUNC_OUT( "CHtiSysInfoServicePlugin::ProcessMessage" );

   481     }

   482 

   483 //------------------------------------------------------------------------------

   484 // CHtiSysInfoServicePlugin::NotifyMemoryChange

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

   486 void CHtiSysInfoServicePlugin::NotifyMemoryChange( TInt aAvailableMemory )

   487     {

   488 

   489     if ( iReply )

   490         {

   491         if ( aAvailableMemory >= iReply->Size() )

   492             {

   493             TInt err = iDispatcher->DispatchOutgoingMessage(

   494                 iReply, KSysInfoServiceUid );

   495 

   496             if ( err == KErrNone )

   497                 {

   498                 iReply = NULL;

   499                 iDispatcher->RemoveMemoryObserver( this );

   500                 }

   501             else if ( err != KErrNoMemory ) //some other error

   502                 {

   503                 delete iReply;

   504                 iReply = NULL;

   505                 iDispatcher->RemoveMemoryObserver( this );

   506                 }

   507             }

   508         }

   509     else

   510         {

   511         // some error, should not be called

   512         iDispatcher->RemoveMemoryObserver( this );

   513         }

   514     }

   515 

   516 //------------------------------------------------------------------------------

   517 // CHtiSysInfoServicePlugin::HandleAllowSSPropertyChange

   518 //------------------------------------------------------------------------------

   519 TInt CHtiSysInfoServicePlugin::HandleAllowSSPropertyChange( TAny* aPtr )

   520     {

   521     HTI_LOG_TEXT( "Allow SS property was changed" );

   522     TInt newValue = -1;

   523     TInt wantedValue =

   524         STATIC_CAST( CHtiSysInfoServicePlugin*, aPtr )->iAllowSSValue;

   525     RProperty::Get( KPSUidScreenSaver,

   526                     KScreenSaverAllowScreenSaver, newValue );

   527     HTI_LOG_FORMAT( "New value is %d", newValue );

   528 

   529     TInt err = KErrNone;

   530     if ( newValue == 0 && wantedValue == 1 )

   531         {

   532         HTI_LOG_TEXT( "Restoring the SS disabled value" );

   533         err = RProperty::Set( KPSUidScreenSaver,

   534                               KScreenSaverAllowScreenSaver, wantedValue );

   535         }

   536     return err;

   537     }

   538 

   539 

   540 /*

   541  * Private helper methods

   542  */

   543 

   544 //------------------------------------------------------------------------------

   545 // CHtiSysInfoServicePlugin::HandleGetHalAttrL

   546 //------------------------------------------------------------------------------

   547 void CHtiSysInfoServicePlugin::HandleGetHalAttrL( const TDesC8& aMessage )

   548     {

   549     // check the message length

   550     if ( aMessage.Length() != 5 )

   551         {

   552         iDispatcher->DispatchOutgoingErrorMessage(

   553             KErrArgument,

   554             KErrDescrArgument,

   555             KSysInfoServiceUid );

   556         return;

   557         }

   558 

   559     TInt att =  aMessage[1] +

   560               ( aMessage[2] << 8  ) +

   561               ( aMessage[3] << 16 ) +

   562               ( aMessage[4] << 24 );

   563 

   564     // check that requested HAL attribute is valid

   565     if ( att < 0 || att >= HALData::ENumHalAttributes )

   566         {

   567         iDispatcher->DispatchOutgoingErrorMessage(

   568             KErrArgument,

   569             KErrDescrAttOutOfRange,

   570             KSysInfoServiceUid);

   571         return;

   572         }

   573 

   574     // get the HAL attribute

   575     TInt result;

   576     TInt err = HAL::Get( ( HALData::TAttribute ) att, result );

   577     if ( err )

   578         {

   579         iDispatcher->DispatchOutgoingErrorMessage(

   580             err,

   581             KErrDescrHAL,

   582             KSysInfoServiceUid );

   583         }

   584     else

   585         {

   586         iReply = HBufC8::NewL( 4 );

   587         iReply->Des().Append( ( TUint8* )( &result ), 4 );

   588         }

   589     }

   590 

   591 //------------------------------------------------------------------------------

   592 // CHtiSysInfoServicePlugin::HandleGetImeiL

   593 //------------------------------------------------------------------------------

   594 void CHtiSysInfoServicePlugin::HandleGetImeiL( const TDesC8& aMessage )

   595     {

   596     HTI_LOG_FUNC_IN( "CHtiSysInfoServicePlugin::HandleGetImeiL" );

   597 

   598     if ( aMessage.Length() != 1 )

   599         {

   600         iDispatcher->DispatchOutgoingErrorMessage( KErrArgument,

   601             KErrDescrArgument, KSysInfoServiceUid );

   602         return;

   603         }

   604 

   605 #if !defined (__WINS__) // no IMEI in emulator

   606     RTelServer server;

   607     User::LeaveIfError( server.Connect() );

   608     CleanupClosePushL( server );

   609     User::LeaveIfError( server.LoadPhoneModule( KMmTsyModuleName ) );

   610 

   611     RTelServer::TPhoneInfo info;

   612     TInt ret = KErrNotSupported;

   613     TInt count;

   614 

   615     RMobilePhone mobilePhone;

   616 

   617     User::LeaveIfError( server.EnumeratePhones( count ) );

   618 

   619     for ( TInt i = 0; i < count; i++ )

   620         {

   621         ret = server.GetPhoneInfo( i, info );

   622         if ( ret == KErrNone )

   623             {

   624             User::LeaveIfError( mobilePhone.Open( server, info.iName ) );

   625             CleanupClosePushL( mobilePhone );

   626             break;

   627             }

   628         }

   629 

   630     TRequestStatus status;

   631     RMobilePhone::TMobilePhoneIdentityV1 identity;

   632 

   633     mobilePhone.GetPhoneId( status, identity );

   634     User::WaitForRequest( status );

   635 

   636     CleanupStack::PopAndDestroy(); // mobilePhone

   637 

   638     server.UnloadPhoneModule( KMmTsyModuleName );

   639     CleanupStack::PopAndDestroy(); // server

   640 

   641     iReply = HBufC8::NewL( identity.iSerialNumber.Length() );

   642     iReply->Des().Copy( identity.iSerialNumber );

   643 

   644 #else // __WINS__

   645     // no IMEI in emulator

   646     iDispatcher->DispatchOutgoingErrorMessage( KErrNotSupported,

   647         KErrDescrNotSupported, KSysInfoServiceUid );

   648 #endif // __WINS__

   649     HTI_LOG_FUNC_OUT( "CHtiSysInfoServicePlugin::HandleGetImeiL" );

   650     }

   651 

   652 //------------------------------------------------------------------------------

   653 // CHtiSysInfoServicePlugin::HandleGetSwVersionL

   654 //------------------------------------------------------------------------------

   655 void CHtiSysInfoServicePlugin::HandleGetSwVersionL( const TDesC8& aMessage )

   656     {

   657     if ( aMessage.Length() != 1 )

   658         {

   659         iDispatcher->DispatchOutgoingErrorMessage(

   660             KErrArgument,

   661             KErrDescrArgument,

   662             KSysInfoServiceUid);

   663         return;

   664         }

   665 

   666     TBuf<KSysUtilVersionTextLength> reply16;

   667     TInt err = SysUtil::GetSWVersion( reply16 );

   668     if ( err )

   669         {

   670         iDispatcher->DispatchOutgoingErrorMessage(

   671             err,

   672             KErrDescrSysUtil,

   673             KSysInfoServiceUid );

   674         }

   675     else

   676         {

   677         iReply = HBufC8::NewL( reply16.Size() );

   678         iReply->Des().Append( ( TUint8* )reply16.Ptr(), reply16.Size() );

   679         }

   680     }

   681 

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

   683 // CHtiSysInfoServicePlugin::HandleGetLangVersionL

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

   685 void CHtiSysInfoServicePlugin::HandleGetLangVersionL( const TDesC8& aMessage )

   686     {

   687     if ( aMessage.Length() != 1 )

   688         {

   689         iDispatcher->DispatchOutgoingErrorMessage(

   690             KErrArgument,

   691             KErrDescrArgument,

   692             KSysInfoServiceUid );

   693         return;

   694         }

   695 

   696     TBuf<KSysUtilVersionTextLength> reply16;

   697     TInt err = SysUtil::GetLangVersion( reply16 );

   698     if ( err )

   699         {

   700         iDispatcher->DispatchOutgoingErrorMessage(

   701             err,

   702             KErrDescrSysUtil,

   703             KSysInfoServiceUid );

   704         }

   705     else

   706         {

   707         iReply = HBufC8::NewL( reply16.Size() );

   708         iReply->Des().Append( ( TUint8* )reply16.Ptr(), reply16.Size() );

   709         }

   710     }

   711 

   712 //------------------------------------------------------------------------------

   713 // CHtiSysInfoServicePlugin::HandleGetSwLangVersionL

   714 //------------------------------------------------------------------------------

   715 void CHtiSysInfoServicePlugin::HandleGetSwLangVersionL( const TDesC8& aMessage )

   716     {

   717     if ( aMessage.Length() != 1 )

   718         {

   719         iDispatcher->DispatchOutgoingErrorMessage(

   720             KErrArgument,

   721             KErrDescrArgument,

   722             KSysInfoServiceUid);

   723         return;

   724         }

   725 

   726     TBuf<KSysUtilVersionTextLength> reply16;

   727     TInt err = SysUtil::GetLangSWVersion( reply16 );

   728     if ( err )

   729         {

   730         iDispatcher->DispatchOutgoingErrorMessage(

   731             err,

   732             KErrDescrSysUtil,

   733             KSysInfoServiceUid );

   734         }

   735     else

   736         {

   737         iReply = HBufC8::NewL( reply16.Size() );

   738         iReply->Des().Append( ( TUint8* )reply16.Ptr(), reply16.Size() );

   739         }

   740     }

   741 

   742 //------------------------------------------------------------------------------

   743 // CHtiSysInfoServicePlugin::HandleGetUserAgentStringL

   744 //------------------------------------------------------------------------------

   745 void CHtiSysInfoServicePlugin::HandleGetUserAgentStringL(

   746         const TDesC8& aMessage )

   747     {

   748     aMessage.Length(); // get rid of compiler warning

   749     iDispatcher->DispatchOutgoingErrorMessage(

   750         KErrNotSupported,

   751         KErrDescrNotSupported,

   752         KSysInfoServiceUid);

   753     }

   754 

   755 //------------------------------------------------------------------------------

   756 // CHtiSysInfoServicePlugin::HandleGetFreeRamL

   757 //------------------------------------------------------------------------------

   758 void CHtiSysInfoServicePlugin::HandleGetFreeRamL( const TDesC8& aMessage )

   759     {

   760     if ( aMessage.Length() != 1 )

   761         {

   762         iDispatcher->DispatchOutgoingErrorMessage(

   763             KErrArgument,

   764             KErrDescrArgument,

   765             KSysInfoServiceUid );

   766         return;

   767         }

   768 

   769     User::CompressAllHeaps();

   770     TInt result;

   771     TInt err = HAL::Get( HALData::EMemoryRAMFree, result );

   772     if ( err )

   773         {

   774         iDispatcher->DispatchOutgoingErrorMessage(

   775             err,

   776             KErrDescrFreeRAM,

   777             KSysInfoServiceUid );

   778         }

   779     else

   780         {

   781         iReply = HBufC8::NewL( 4 );

   782         iReply->Des().Append( ( TUint8* )( &result ), 4 );

   783         }

   784     }

   785 

   786 //------------------------------------------------------------------------------

   787 // CHtiSysInfoServicePlugin::HandleGetUsedRamL

   788 //------------------------------------------------------------------------------

   789 void CHtiSysInfoServicePlugin::HandleGetUsedRamL( const TDesC8& aMessage )

   790     {

   791     if ( aMessage.Length() != 1 )

   792         {

   793         iDispatcher->DispatchOutgoingErrorMessage(

   794             KErrArgument,

   795             KErrDescrArgument,

   796             KSysInfoServiceUid);

   797         return;

   798         }

   799 

   800     User::CompressAllHeaps();

   801 

   802     TInt totalRam;

   803     TInt freeRam;

   804     TInt usedRam;

   805 

   806     // first get the total RAM...

   807     TInt err = HAL::Get( HALData::EMemoryRAM, totalRam );

   808     if ( err != KErrNone )

   809         {

   810         iDispatcher->DispatchOutgoingErrorMessage(

   811             err,

   812             KErrDescrTotalRAM,

   813             KSysInfoServiceUid );

   814         return;

   815         }

   816 

   817     // ...then get the free RAM

   818     err = HAL::Get( HALData::EMemoryRAMFree, freeRam );

   819     if ( err )

   820         {

   821         iDispatcher->DispatchOutgoingErrorMessage(

   822             err,

   823             KErrDescrFreeRAM,

   824             KSysInfoServiceUid );

   825         return;

   826         }

   827 

   828     // calculate used RAM from total and free RAM

   829     usedRam = totalRam - freeRam;

   830     iReply = HBufC8::NewL( 4 );

   831     iReply->Des().Append( ( TUint8* )( &usedRam ), 4 );

   832     }

   833 

   834 //------------------------------------------------------------------------------

   835 // CHtiSysInfoServicePlugin::HandleGetTotalRamL

   836 //------------------------------------------------------------------------------

   837 void CHtiSysInfoServicePlugin::HandleGetTotalRamL( const TDesC8& aMessage )

   838     {

   839     if ( aMessage.Length() != 1 )

   840         {

   841         iDispatcher->DispatchOutgoingErrorMessage(

   842             KErrArgument,

   843             KErrDescrArgument,

   844             KSysInfoServiceUid);

   845         return;

   846         }

   847 

   848     User::CompressAllHeaps();

   849 

   850     TInt result;

   851     TInt err = HAL::Get( HALData::EMemoryRAM, result );

   852     if ( err )

   853         {

   854         iDispatcher->DispatchOutgoingErrorMessage(

   855             err,

   856             KErrDescrTotalRAM,

   857             KSysInfoServiceUid );

   858         }

   859     else

   860         {

   861         iReply = HBufC8::NewL( 4 );

   862         iReply->Des().Append( ( TUint8* )( &result ), 4 );

   863         }

   864     }

   865 

   866 //------------------------------------------------------------------------------

   867 // CHtiSysInfoServicePlugin::HandleEatRamL

   868 //------------------------------------------------------------------------------

   869 void CHtiSysInfoServicePlugin::HandleEatRamL( const TDesC8& aMessage )

   870     {

   871     if ( aMessage.Length() != 5 )

   872         {

   873         iDispatcher->DispatchOutgoingErrorMessage(

   874             KErrArgument,

   875             KErrDescrArgument,

   876             KSysInfoServiceUid );

   877         return;

   878         }

   879 

   880     // get the amount of memory to be left free from the message

   881     TInt memLeftFree =  aMessage[1] +

   882                       ( aMessage[2] << 8  ) +

   883                       ( aMessage[3] << 16 ) +

   884                       ( aMessage[4] << 24 );

   885 

   886     // if there's a previous memory eater, delete it

   887     if ( iMemEater != NULL )

   888         {

   889         delete iMemEater;

   890         iMemEater = NULL;

   891         }

   892 

   893     User::CompressAllHeaps();

   894 

   895     // get the current free memory

   896     TInt memFree;

   897     TInt err = HAL::Get( HALData::EMemoryRAMFree, memFree );

   898     if ( err )

   899         {

   900         iDispatcher->DispatchOutgoingErrorMessage(

   901             err,

   902             KErrDescrFreeRAM,

   903             KSysInfoServiceUid );

   904         return;

   905         }

   906 

   907     // try to eat the memory

   908     TInt memToBeEaten = memFree - memLeftFree;

   909 

   910     if ( memToBeEaten < 0 )

   911         {

   912         iDispatcher->DispatchOutgoingErrorMessage(

   913                 KErrUnderflow,

   914                 KErrDescrInvalidRAM,

   915                 KSysInfoServiceUid );

   916         return;

   917         }

   918 

   919     TRAP( err, iMemEater = HBufC8::NewL( memToBeEaten ) );

   920     if ( err )

   921         {

   922         iDispatcher->DispatchOutgoingErrorMessage(

   923             err,

   924             KErrDescrAllocRAM,

   925             KSysInfoServiceUid );

   926         return;

   927         }

   928 

   929     // get the amount of memory left

   930     err = HAL::Get( HALData::EMemoryRAMFree, memFree );

   931     if ( err )

   932         {

   933         iDispatcher->DispatchOutgoingErrorMessage(

   934             err,

   935             KErrDescrFreeRAM,

   936             KSysInfoServiceUid );

   937         return;

   938         }

   939 

   940     // send the amount of memory back

   941     iReply = HBufC8::NewL( 4 );

   942     iReply->Des().Append( ( TUint8* )( &memFree ), 4 );

   943     }

   944 

   945 //------------------------------------------------------------------------------

   946 // CHtiSysInfoServicePlugin::HandleReleaseRamL

   947 //------------------------------------------------------------------------------

   948 void CHtiSysInfoServicePlugin::HandleReleaseRamL( const TDesC8& aMessage )

   949     {

   950     if ( aMessage.Length() != 1 )

   951         {

   952         iDispatcher->DispatchOutgoingErrorMessage(

   953             KErrArgument,

   954             KErrDescrArgument,

   955             KSysInfoServiceUid );

   956         return;

   957         }

   958 

   959     // if there's a memory eater, delete it

   960     if ( iMemEater != NULL )

   961         {

   962         delete iMemEater;

   963         iMemEater = NULL;

   964         }

   965 

   966     User::CompressAllHeaps();

   967 

   968     // query the amount of memory and send it back

   969     TInt memFree;

   970     TInt err = HAL::Get( HALData::EMemoryRAMFree, memFree );

   971     if ( err )

   972         {

   973         iDispatcher->DispatchOutgoingErrorMessage(

   974             err,

   975             KErrDescrHAL,

   976             KSysInfoServiceUid );

   977         }

   978     else

   979         {

   980         iReply = HBufC8::NewL( 4 );

   981         iReply->Des().Append( ( TUint8* )( &memFree ), 4 );

   982         }

   983     }

   984 

   985 //------------------------------------------------------------------------------

   986 // CHtiSysInfoServicePlugin::HandleGetFreeDiskSpaceL

   987 //------------------------------------------------------------------------------

   988 void CHtiSysInfoServicePlugin::HandleGetFreeDiskSpaceL( const TDesC8& aMessage )

   989     {

   990     if ( aMessage.Length() != 2 )

   991         {

   992         iDispatcher->DispatchOutgoingErrorMessage(

   993             KErrArgument,

   994             KErrDescrArgument,

   995             KSysInfoServiceUid);

   996         return;

   997         }

   998 

   999     TInt drive;

  1000     RFs::CharToDrive( TChar( aMessage[1] ), drive );

  1001     TVolumeInfo volInfo;

  1002     TInt err = iFs.Volume( volInfo, drive );

  1003 

  1004     if ( err )

  1005         {

  1006         iDispatcher->DispatchOutgoingErrorMessage(

  1007             err,

  1008             KErrDescrVolInfo,

  1009             KSysInfoServiceUid );

  1010         }

  1011     else

  1012         {

  1013         iReply = HBufC8::NewL( 8 );

  1014         iReply->Des().Append( ( TUint8* )( &volInfo.iFree ), 8 );

  1015         }

  1016     }

  1017 

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

  1019 // CHtiSysInfoServicePlugin::HandleGetUsedDiskSpaceL

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

  1021 void CHtiSysInfoServicePlugin::HandleGetUsedDiskSpaceL( const TDesC8& aMessage )

  1022     {

  1023     if ( aMessage.Length() != 2 )

  1024         {

  1025         iDispatcher->DispatchOutgoingErrorMessage(

  1026             KErrArgument,

  1027             KErrDescrArgument,

  1028             KSysInfoServiceUid);

  1029         return;

  1030         }

  1031 

  1032     TInt drive;

  1033     RFs::CharToDrive( TChar( aMessage[1] ), drive );

  1034     TVolumeInfo volInfo;

  1035     TInt err = iFs.Volume( volInfo, drive );

  1036 

  1037     if ( err )

  1038         {

  1039         iDispatcher->DispatchOutgoingErrorMessage(

  1040             err,

  1041             KErrDescrVolInfo,

  1042             KSysInfoServiceUid );

  1043         }

  1044     else

  1045         {

  1046         TInt64 used = volInfo.iSize - volInfo.iFree;

  1047         iReply = HBufC8::NewL( 8 );

  1048         iReply->Des().Append( ( TUint8* )( &used ), 8 );

  1049         }

  1050     }

  1051 

  1052 //------------------------------------------------------------------------------

  1053 // CHtiSysInfoServicePlugin::HandleGetTotalDiskSpaceL

  1054 //------------------------------------------------------------------------------

  1055 void CHtiSysInfoServicePlugin::HandleGetTotalDiskSpaceL(

  1056         const TDesC8& aMessage )

  1057     {

  1058     if ( aMessage.Length() != 2 )

  1059         {

  1060         iDispatcher->DispatchOutgoingErrorMessage(

  1061             KErrArgument,

  1062             KErrDescrArgument,

  1063             KSysInfoServiceUid);

  1064         return;

  1065         }

  1066 

  1067     TInt drive;

  1068     RFs::CharToDrive( TChar( aMessage[1] ), drive );

  1069     TVolumeInfo volInfo;

  1070     TInt err = iFs.Volume( volInfo, drive );

  1071 

  1072     if ( err )

  1073         {

  1074         iDispatcher->DispatchOutgoingErrorMessage(

  1075             err,

  1076             KErrDescrVolInfo,

  1077             KSysInfoServiceUid );

  1078         }

  1079     else

  1080         {

  1081         iReply = HBufC8::NewL( 8 );

  1082         iReply->Des().Append( ( TUint8* )( &volInfo.iSize ), 8 );

  1083         }

  1084     }

  1085 

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

  1087 // CHtiSysInfoServicePlugin::HandleEatDiskSpaceL

  1088 //------------------------------------------------------------------------------

  1089 void CHtiSysInfoServicePlugin::HandleEatDiskSpaceL( const TDesC8& aMessage )

  1090     {

  1091     if ( aMessage.Length() != 10 )

  1092         {

  1093         iDispatcher->DispatchOutgoingErrorMessage(

  1094             KErrArgument,

  1095             KErrDescrArgument,

  1096             KSysInfoServiceUid );

  1097         return;

  1098         }

  1099 

  1100 

  1101     TFileName path;

  1102     path.Append( aMessage[1] );

  1103     path.Append( _L( ":" ) );

  1104     path.Append( KTempFilePath );

  1105     path.Append( KTempFileName );

  1106 

  1107     HTI_LOG_TEXT( "Temp file path:" );

  1108     HTI_LOG_DES( path );

  1109 

  1110     // check if previous temp file exists and delete it

  1111     if ( BaflUtils::FileExists( iFs, path ) )

  1112         {

  1113         TInt err = iFileMan->Delete( path );

  1114         if ( err )

  1115             {

  1116             iDispatcher->DispatchOutgoingErrorMessage(

  1117                 err,

  1118                 KErrDescrDeleteTempFile,

  1119                 KSysInfoServiceUid );

  1120             return;

  1121             }

  1122         }

  1123 

  1124     // get free disk space

  1125     TInt drive;

  1126     RFs::CharToDrive( TChar( aMessage[1] ), drive );

  1127     TVolumeInfo volInfo;

  1128     TInt err = iFs.Volume( volInfo, drive );

  1129     if ( err )

  1130         {

  1131         iDispatcher->DispatchOutgoingErrorMessage(

  1132             err,

  1133             KErrDescrVolInfo,

  1134             KSysInfoServiceUid );