/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  SysInfoPlugin implementation

*

*/

// INCLUDE FILES

#include "HtiSysInfoServicePlugin.h"

#include "HtiLightsController.h"

#include "HtiPropertySubscriber.h"

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

#include <aknkeylock.h>

#include <AknSkinsInternalCRKeys.h>

#include <AknsSkinUID.h>

#include <AknsSrvClient.h>

#include <bautils.h>

#include <btengsettings.h>

#include <btengdomaincrkeys.h>

#include <bt_subscribe.h>

#include <btmanclient.h>

#include <centralrepository.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <DRMRightsClient.h>

#include <e32property.h>

#include <etel.h>

#include <etelmm.h>

#include <hal.h>

#include <ir_sock.h>

#include <mmtsy_names.h>

#include <rmmcustomapi.h>

#include <hwrmpowerstatesdkpskeys.h>

#include <settingsinternalcrkeys.h>

#include <sysutil.h>

#include <tz.h>

// CONSTANTS

const static TUid KSysInfoServiceUid = { 0x10210CC7 };

// from irinternalpskey.h

const static TUid KPSUidIrdaActivation = { 0x2000276D };

const TInt KTimeDataLength = 7;

const TInt KMaxBtNameLength = 30;

const TInt KDateTimeFormatCmdLength = 6;

_LIT( KTempFilePath, "\\" );

_LIT( KTempFileName, "HtiTempFile.tmp" );

_LIT( KMatchFileName, "HtiTempFile.tmp*" );

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

_LIT( KTimeSeparatorChars, ".:" );

_LIT8( KErrDescrArgument, "Invalid argument" );

_LIT8( KErrDescrNotSupported, "Command not supported" );

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

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

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

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

_LIT8( KErrDescrAllocRAM, "Error allocating RAM" );

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

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

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

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

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

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

_LIT8( KErrDescrSysUtil, "SysUtil failed" );

_LIT8( KErrDescrSetTime, "Setting time failed" );

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

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

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

_LIT8( KErrDescrIrActivation, "IR activation failed" );

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

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

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

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

_LIT8( KErrDescrBtSettings, "Bluetooth settings failed" );

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

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

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

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

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

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

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

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

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

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

_LIT8( KErrDescrActivateSkin, "Activating Skin failed" );

enum TSysInfoCommand

    {

    ESysInfoHAL =             0x01,

    ESysInfoIMEI=             0x02,

    ESysInfoSWVersion =       0x03,

    ESysInfoLangVersion =     0x04,

    ESysInfoSWLangVersion =   0x05,

    ESysInfoUserAgent =       0x06,

    EFreeRAM =                0x07,

    EUsedRAM =                0x08,

    ETotalRAM =               0x09,

    EEatRAM =                 0x0A,

    EReleaseRAM =             0x0B,

    EFreeDiskSpace =          0x0C,

    EUsedDiskSpace =          0x0D,

    ETotalDiskSize =          0x0E,

    EEatDiskSpace =           0x0F,

    EReleaseDiskSpace =       0x10,

    ESysInfoSetHomeTime =     0x20,

    ESysInfoGetHomeTime =     0x21,

    ESetDateTimeFormat =      0x22,

    ELightStatus =            0x30,

    ELightOn =                0x31,

    ELightOff =               0x32,

    ELightBlink =             0x33,

    ELightRelease =           0x3A,

    EScreenSaverDisable =     0x40,

    EScreenSaverEnable  =     0x41,

    EScreenSaverTimeout =     0x42,

    ENetworkModeGet =         0x50,

    ENetworkModeSet =         0x51,

    ENetworkModeSetNoReboot = 0x52,

    EHsdpaSet =               0x53,

    EIrActivate =             0x5A,

    EBtPower =                0x5B,

    EBtSettings =             0x5C,

    EBtDeletePairings =       0x5D,

    EKeylockToggle =          0x60,

    EAutoKeyGuardTime =       0x61,

    EEmtpyDrmRightsDb =       0x65,

    EBatteryStatus =          0x70,

    ESignalStrength =         0x71,

    EUpdateMediaGallery =     0x7A,

    EActivateSkin =           0x80

    };

//------------------------------------------------------------------------------

// Create instance of concrete ECOM interface implementation

//------------------------------------------------------------------------------

CHtiSysInfoServicePlugin* CHtiSysInfoServicePlugin::NewL()

    {

    CHtiSysInfoServicePlugin* self = new (ELeave) CHtiSysInfoServicePlugin;

    CleanupStack::PushL (self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

//------------------------------------------------------------------------------

// Constructor

//------------------------------------------------------------------------------

CHtiSysInfoServicePlugin::CHtiSysInfoServicePlugin():

    {

    }

//------------------------------------------------------------------------------

// Destructor

//------------------------------------------------------------------------------

CHtiSysInfoServicePlugin::~CHtiSysInfoServicePlugin()

    {

    HTI_LOG_TEXT( "CHtiSysInfoServicePlugin destroy" );

    delete iMemEater;

    delete iReply;

    CleanUpTempFiles();

    delete iFileMan;

    iFs.Close();

    delete iLightsController;

    if ( iAllowSSSubscriber )

        {

        iAllowSSSubscriber->Unsubscribe();

        }

    iAllowSSProperty.Close();

    delete iAllowSSSubscriber;

    }

//------------------------------------------------------------------------------

// Second phase construction

//------------------------------------------------------------------------------

void CHtiSysInfoServicePlugin::ConstructL()

    {

    HTI_LOG_TEXT( "CHtiSysInfoServicePlugin::ConstructL" );

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

    iFileMan = CFileMan::NewL( iFs );

    }

//------------------------------------------------------------------------------

// CHtiSysInfoServicePlugin::ProcessMessageL

//------------------------------------------------------------------------------

void CHtiSysInfoServicePlugin::ProcessMessageL(const TDesC8& aMessage,

                                THtiMessagePriority /*aPriority*/)

    {

    HTI_LOG_FUNC_IN( "CHtiSysInfoServicePlugin::ProcessMessage" );

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

    if ( aMessage.Length() > 0 )

        {

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

        switch ( aMessage[0] )

            {

            case ESysInfoHAL:

                {

                HTI_LOG_TEXT( "ESysInfoHAL" );

                HandleGetHalAttrL( aMessage );

                }

                break;

            case ESysInfoIMEI:

                {

                HTI_LOG_TEXT( "ESysInfoIMEI" );

                HandleGetImeiL( aMessage );

                }

                break;

            case ESysInfoSWVersion:

                {

                HTI_LOG_TEXT( "ESysInfoSWVersion" );

                HandleGetSwVersionL( aMessage );

                }

                break;

            case ESysInfoLangVersion:

                {

                HTI_LOG_TEXT( "ESysInfoLangVersion" );

                HandleGetLangVersionL( aMessage );

                }

                break;

            case ESysInfoSWLangVersion:

                {

                HTI_LOG_TEXT( "ESysInfoSWLangVersion" );

                HandleGetSwLangVersionL( aMessage );

                }

                break;

            case ESysInfoUserAgent:

                {

                HTI_LOG_TEXT( "ESysInfoUserAgent" );

                HandleGetUserAgentStringL( aMessage );

                }

                break;

            case EFreeRAM:

                {

                HTI_LOG_TEXT( "EFreeRAM" );

                HandleGetFreeRamL( aMessage );

                }

                break;

            case EUsedRAM:

                {

                HTI_LOG_TEXT( "EUsedRAM" );

                HandleGetUsedRamL( aMessage );

                }

                break;

            case ETotalRAM:

                {

                HTI_LOG_TEXT( "ETotalRAM" );

                HandleGetTotalRamL( aMessage );

                }

                break;

            case EEatRAM:

                {

                HTI_LOG_TEXT( "EEatRAM" );

                HandleEatRamL( aMessage );

                }

                break;

            case EReleaseRAM:

                {

                HTI_LOG_TEXT( "EReleaseRAM" );

                HandleReleaseRamL( aMessage );

                }

                break;

            case EFreeDiskSpace:

                {

                HTI_LOG_TEXT( "EFreeDiskSpace" );

                HandleGetFreeDiskSpaceL( aMessage );

                }

                break;

            case EUsedDiskSpace:

                {

                HTI_LOG_TEXT( "EUsedDiskSpace" );

                HandleGetUsedDiskSpaceL( aMessage );

                }

                break;

            case ETotalDiskSize:

                {

                HTI_LOG_TEXT( "ETotalDiskSize" );

                HandleGetTotalDiskSpaceL( aMessage );

                }

                break;

            case EEatDiskSpace:

                {

                HTI_LOG_TEXT( "EEatDiskSpace" );

                HandleEatDiskSpaceL( aMessage );

                }

                break;

            case EReleaseDiskSpace:

                {

                HTI_LOG_TEXT( "EReleaseDiskSpace" );

                HandleReleaseDiskSpaceL( aMessage );

                }

                break;

            case ESysInfoSetHomeTime:

                {

                HTI_LOG_TEXT( "ESysInfoSetHomeTime" );

                HandleSetHomeTimeL( aMessage );

                }

                break;

            case ESysInfoGetHomeTime:

                {

                HTI_LOG_TEXT( "ESysInfoGetHomeTime" );

                HandleGetHomeTimeL( aMessage );

                }

                break;

            case ESetDateTimeFormat:

                {

                HTI_LOG_TEXT( "ESetDateTimeFormat" );

                HandleSetDateTimeFormatL( aMessage );

                }

                break;

            case ELightStatus:

            case ELightOn:

            case ELightOff:

            case ELightBlink:

            case ELightRelease:

                {

                HTI_LOG_TEXT( "ELight*" );

                HandleLightsCommandL( aMessage );

                }

                break;

            case EScreenSaverDisable:

            case EScreenSaverEnable:

                {

                HTI_LOG_TEXT( "EScreenSaver*" );

                HandleScreenSaverCommandL( aMessage );

                }

                break;

            case EScreenSaverTimeout:

                {

                HTI_LOG_TEXT( "EScreenSaverTimeout" );

                HandleScreenSaverTimeoutCommandL( aMessage );

                }

                break;

            case ENetworkModeSet:

            case ENetworkModeSetNoReboot:

            case ENetworkModeGet:

                {

                HTI_LOG_TEXT( "ENetworkMode*" );

                HandleNetworkModeCommandL( aMessage );

                }

                break;

            case EHsdpaSet:

                {

                HTI_LOG_TEXT( "EHsdpaSet" );

                HandleHsdpaCommandL( aMessage );

                }

                break;

            case EIrActivate:

                {

                HTI_LOG_TEXT( "EIrActivate" );

                HandleIrActivateCommandL( aMessage );

                }

                break;

            case EBtPower:

                {

                HTI_LOG_TEXT( "EBtPower" );

                HandleBtPowerCommandL( aMessage );

                }

                break;

            case EBtSettings:

                {

                HTI_LOG_TEXT( "EBtSettings" );

                HandleBtSettingsCommandL( aMessage );

                }

                break;

            case EBtDeletePairings:

                {

                HTI_LOG_TEXT( "EBtDeletePairings" );

                HandleBtDeletePairingsL( aMessage );

                }

                break;

            case EKeylockToggle:

                {

                HTI_LOG_TEXT( "EKeylockToggle" );

                HandleKeyLockToggleL( aMessage );

                }

                break;

            case EAutoKeyGuardTime:

                {

                HTI_LOG_TEXT( "EAutoKeyGuardTime" );

                HandleAutoKeyGuardTimeL( aMessage );

                }

                break;

            case EEmtpyDrmRightsDb:

                {

                HTI_LOG_TEXT( "EEmtpyDrmRightsDb" );

                HandleEmptyDrmRightsDbL( aMessage );

                }

                break;

            case EBatteryStatus:

                {

                HTI_LOG_TEXT( "EBatteryStatus" );

                HandleBatteryStatusL( aMessage );

                }

                break;

            case ESignalStrength:

                {

                HTI_LOG_TEXT( "ESignalStrength" );

                HandleSignalStrengthL( aMessage );

                }

                break;

            case EUpdateMediaGallery:

                {

                HTI_LOG_TEXT( "EUpdateMediaGallery" );

                HandleUpdateMediaGalleryL( aMessage );

                }

                break;

            case EActivateSkin:

                {

                HTI_LOG_TEXT( "EActivateSkin" );

                HandleActivateSkinL( aMessage );

                }

                break;

            default:

                {

                iDispatcher->DispatchOutgoingErrorMessage(

                    KErrArgument,

                    KErrDescrNotSupported,

                    KSysInfoServiceUid );

                }

            }

        }

    else // aMessage.Length() > 0

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            KErrArgument,

            KErrDescrArgument,

            KSysInfoServiceUid);

        }

    if ( iReply )

        {

        TInt err = iDispatcher->DispatchOutgoingMessage( iReply,

                                                         KSysInfoServiceUid );

        if ( err == KErrNoMemory )

            {

            HTI_LOG_TEXT( "KErrNoMemory" );

            iDispatcher->AddMemoryObserver( this );

            }

        else

            {

            iReply = NULL;

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiSysInfoServicePlugin::ProcessMessage" );

    }

//------------------------------------------------------------------------------

// CHtiSysInfoServicePlugin::NotifyMemoryChange

//------------------------------------------------------------------------------

void CHtiSysInfoServicePlugin::NotifyMemoryChange( TInt aAvailableMemory )

    {

    if ( iReply )

        {

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

            {

            TInt err = iDispatcher->DispatchOutgoingMessage(

                iReply, KSysInfoServiceUid );

            if ( err == KErrNone )

                {

                iReply = NULL;

                iDispatcher->RemoveMemoryObserver( this );

                }

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

                {

                delete iReply;

                iReply = NULL;

                iDispatcher->RemoveMemoryObserver( this );

                }

            }

        }

    else

        {

        // some error, should not be called

        iDispatcher->RemoveMemoryObserver( this );

        }

    }