/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  class implementation

*

*/

#include <centralrepository.h>

#include <btserversdkcrkeys.h>

#include <settingsinternalcrkeys.h>

#include <hwrmvibrasdkcrkeys.h>

#include <hwrmlightdomaincrkeys.h>

#include <AknFepInternalCRKeys.h>

#include <sysutildomaincrkeys.h>

#include <UikonInternalPSKeys.h>

#include <hwrmdomainpskeys.h>

#include <hwrmpowerstatesdkpskeys.h>

#include <ir_sock.h>

#include "activerequests.h"

#include "sysinfoservice.h"

#include "entitykeys.h"

#include "sysinfoutils.h"

using namespace SysInfo;

_LIT(KDriveSeperator,":\\");

const TInt KMaxDriveLength = 5;

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

// CCenrepNotifier::CCenrepNotifier()

// C++ default constructor.

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

//

CCenrepNotifier::CCenrepNotifier(TSysRequest::TRequestType aReqType,

                                TInt32 aTransID, TCommand aCommand,

                                ISystemObserver* aObsrver)

                                :CActiveRequest(aReqType,aTransID,aObsrver),	

                                iCommand(aCommand)

    {

    }

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

// CCenrepNotifier::~CCenrepNotifier()

// Destructor.

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

//

CCenrepNotifier::~CCenrepNotifier()

    {

    Cancel();

    delete iCenrep;

    delete iEntity;

    delete iKey;

    }

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

// CCenrepNotifier::NewL()

// Two-phased constructor, returns instance of this class.

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

//

CCenrepNotifier* CCenrepNotifier::NewL(const TSysRequest& aRequest, 

                                                    TCommand aCommand)

    {

    CCenrepNotifier* self;

    self = new (ELeave) CCenrepNotifier(aRequest.RequestType(),

                                        aRequest.TransactionID(),

                                        aCommand,aRequest.Observer());

    CleanupStack::PushL(self);

    self->ConstructL(aRequest);

    CleanupStack::Pop(self);

    return self;

    }

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

// CCenrepNotifier::ConstructL()

// 2nd Phase constructor to allocate required resources for this obj.

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

//

void CCenrepNotifier::ConstructL(const TSysRequest& aRequest)

    {

    //supportes only notifications.

    if(TSysRequest::ENotification != RequestType())

        User::Leave(KErrNotSupported);

    // Identify repository uid and key.

    switch (iCommand)

        {

        case EPridictiveText:

            iRepositoryUid = KCRUidAknFep;

            iRepositoryKey = KAknFepPredTxtFlag;

            break;

        case EInputLanguage:

            iRepositoryUid = KCRUidAknFep;

            iRepositoryKey = KAknFepInputTxtLang;

            break;

        case EBlueTooth:

            iRepositoryUid = KCRUidBluetoothPowerState;

            iRepositoryKey = KBTPowerState;

            break;

        case EVibra:

            iRepositoryUid = KCRUidVibraCtrl;

            iRepositoryKey = KVibraCtrlProfileVibraEnabled;

            break;

        case EKeyLock:

            iRepositoryUid = KCRUidSecuritySettings;

            iRepositoryKey = KSettingsAutolockStatus;

            break;

        default: 

            User::Leave(KErrNotFound);

        }

    // create repository instance.

    iCenrep = CRepository::NewL(iRepositoryUid);	

    // Make local copy of SA.

    iEntity = aRequest.Entity().AllocL();

    iKey	= aRequest.Key().AllocL();

    }

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

// CCenrepNotifier::Request()

// Issues notification request.

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

//

TInt CCenrepNotifier::Request ()

    {

    if( !IsActive() )

        {

        iCenrep->NotifyRequest(iRepositoryKey, iStatus);

        SetActive ();

        }

    return KErrNone;

    }

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

// CCenrepNotifier::RunL()

// Gets called in event of request completion or error situation.

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

//

void CCenrepNotifier::RunL()

    {

    TInt Error(iStatus.Int());

    if (KErrNone <= Error)

        {

        // Re-Issue request

        Request ();

        Error = iCenrep->Get(iRepositoryKey,iValue);

        //Create CSysData

        CStatus* Status = CStatus::NewL(iValue);

        // Calling Observer response method.

        TRAP_IGNORE(SystemObserver()->HandleResponseL(*iEntity, *iKey, Status,

                                            TransactionID(),RequestType(),Error));

        }

    else

        {

        TRAP_IGNORE(SystemObserver()->HandleResponseL(*iEntity, *iKey, NULL,

                TransactionID(),RequestType(),Error));

        ActiveStore::RemoveRequest(TransactionID());

        }

    }

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

// CCenrepNotifier::DoCancel()

// Cancel ongoing request.

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

//

void CCenrepNotifier::DoCancel()

    {

    iCenrep->NotifyCancel(iRepositoryKey);

    }

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

// CPubSubNotifier::CPubSubNotifier()

// C++ default constructor.

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

//

CPubSubNotifier::CPubSubNotifier(TSysRequest::TRequestType aReqType, 

                                TInt32 aTransID, TCommand aCommand,

                                ISystemObserver* aObsrver)

                                :CActiveRequest(aReqType,aTransID,aObsrver),	

                                iValue(EUnknown), iCommand(aCommand)

    {

    }

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

// CPubSubNotifier::~CPubSubNotifier()

// Destructor.

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

//

CPubSubNotifier::~CPubSubNotifier()

    {

    Cancel();

    iProperty.Close();

    delete iEntity;

    delete iKey;

    }

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

// CPubSubNotifier::NewL()

// Two-phased constructor, returns instance of this class.

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

//

CPubSubNotifier* CPubSubNotifier::NewL(const TSysRequest& aRequest, 

                                                    TCommand aCommand)

    {

    CPubSubNotifier* self;

    self = new (ELeave) CPubSubNotifier( aRequest.RequestType(),

                                        aRequest.TransactionID(),

                                        aCommand,aRequest.Observer() );

    CleanupStack::PushL(self);

    self->ConstructL (aRequest);

    CleanupStack::Pop(self);

    return self;

    }

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

// CPubSubNotifier::ConstructL()

// 2nd Phase constructor to allocate required resources for this obj.

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

//

void CPubSubNotifier::ConstructL (const TSysRequest& aRequest)

    {

    //supportes only notifications.

    if(TSysRequest::ENotification != RequestType())

        User::Leave(KErrNotSupported);

    // Identify publish subscribe category uid and key based on command.

    switch (iCommand)

        {

        case ERegistrationStatus:

            iPropertyUid = KPSUidNetworkInfo;

            iPropertyKey = KNWRegistrationStatus;

            break;

        case ENetworkMode:

            iPropertyUid = KPSUidNetworkInfo;

            iPropertyKey = KNWTelephonyNetworkMode;

            break;

        case EChargingStatus:

            iPropertyUid = KPSUidHWRMPowerState;

            iPropertyKey = KHWRMChargingStatus;

            break;

        case EFlipStatus:

            iPropertyUid = KPSUidHWRM;

            iPropertyKey = KHWRMFlipStatus;

            break;

        case EGripStatus:

            iPropertyUid = KPSUidHWRM;

            iPropertyKey = KHWRMGripStatus;

            break;

        case EInfraRed:

            iPropertyUid = KIrdaPropertyCategory;

            iPropertyKey = KIrdaStatus;

            break;

        case EMemoryCard:

            iPropertyUid = KPSUidUikon;

            iPropertyKey = KUikMMCInserted;

            break;

        default:

            User::Leave(KErrNotFound);

        }

    User::LeaveIfError (iProperty.Attach(iPropertyUid,iPropertyKey));

    // Make local copy of SA.

    iEntity = aRequest.Entity().AllocL();

    iKey	= aRequest.Key().AllocL();

    }

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

// CPubSubNotifier::Request()

// Issues notification request.

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

//

TInt CPubSubNotifier::Request()

    {

    if( !IsActive() )

        {

        iProperty.Subscribe(iStatus);

        SetActive ();

        }

    return KErrNone;

    }

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

// CPubSubNotifier::RunL()

// Gets called in event of request completion or error situation.

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

//

void CPubSubNotifier::RunL()

    {

    //get error.

    TInt Error(iStatus.Int());

    TInt value = 0;	

    if (KErrNone <= Error)

    {

    // Re-Issue request

    Request();

    // read value.

    iProperty.Get(value);

    switch (iCommand)

        {

        case EChargingStatus:

            // ChargeStatus need to be mapped to one these states Charging,

            // NotCharging and Unknown

            if ( EChargingStatusCharging == value || 

                    EChargingStatusAlmostComplete == value ||

                    EChargingStatusChargingContinued == value )

                value = ECharging;

            else if( EChargingStatusNotConnected == value || 

                        EChargingStatusNotCharging == value || 

                        EChargingStatusChargingComplete == value)

                value = ENotCharging;

            else

                value = EUnknown;

            break;

        case EInfraRed:

            // IRStatus need to be mapped to one these states 

            // ON, OFF, UNKNOWN.

            if ( TIrdaStatusCodes::EIrLoaded == value || 

                    TIrdaStatusCodes::EIrDiscoveredPeer == value ||

                    TIrdaStatusCodes::EIrBlocked == value || 

                    TIrdaStatusCodes::EIrLostPeer == value || 

                    TIrdaStatusCodes::EIrDisconnected == value )

                value = EOn;

            else if( TIrdaStatusCodes::EIrUnloaded == value )

                value = EOff;

            else

                value = EUnknown;

            break;

        case EFlipStatus:

        case EGripStatus:

            if (value == EPSHWRMFlipOpen)

                value = EOpen;

            else if (value == EPSHWRMFlipClosed)

                value = EClosed;

            else

                value = EUnknown;

            break;

        case ERegistrationStatus:

        case ENetworkMode :	

        case EMemoryCard:

            break;

        default:

            Error= KErrGeneral;

        }

    if((value != iValue))

        {

        iValue = value;

        //Create output CSysData

        CStatus* Status = CStatus::NewL(iValue);

        //Calling Observer Handle.

        TRAP_IGNORE(SystemObserver()->HandleResponseL(*iEntity, *iKey, Status,

                                        TransactionID(),RequestType(),Error));

        }    

    }

    else

    {

    TRAP_IGNORE(SystemObserver()->HandleResponseL(*iEntity, *iKey, NULL,

            TransactionID(),RequestType(),Error));

    ActiveStore::RemoveRequest(TransactionID());

    }

    }

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

// CPubSubNotifier::DoCancel()

// Cancel ongoing request.

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

//

void CPubSubNotifier::DoCancel()

    {

    iProperty.Cancel();

    }

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

// CCriticalMemNotifier::CCriticalMemNotifier()

// C++ default constructor.

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

//

CCriticalMemNotifier::CCriticalMemNotifier(TSysRequest::TRequestType aReqType, 

                                TInt32 aTransID,ISystemObserver* aObsrver)

                                :CActiveRequest(aReqType,aTransID,aObsrver)

    {

    }

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

// CCriticalMemNotifier::~CCriticalMemNotifier()

// Destructor.

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

//

CCriticalMemNotifier::~CCriticalMemNotifier()

    {

    Cancel();

    iFs.Close();

    }

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

// CCriticalMemNotifier::NewL()

// Two-phased constructor, returns instance of this class.

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

//

CCriticalMemNotifier* CCriticalMemNotifier::NewL(const TSysRequest& aRequest)

    {

    CCriticalMemNotifier* self;

    self = new (ELeave) CCriticalMemNotifier(aRequest.RequestType(),

                        aRequest.TransactionID(),aRequest.Observer());

    CleanupStack::PushL(self);

    self->ConstructL (aRequest);

    CleanupStack::Pop(self);

    return self;

    }

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

// CCriticalMemNotifier::ConstructL()

// 2nd Phase constructor to allocate required resources for this obj.

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

//

void CCriticalMemNotifier::ConstructL(const TSysRequest& aRequest)

    {

    //supportes only notifications.

    if(TSysRequest::ENotification != RequestType())

        User::Leave(KErrNotSupported);

    CDriveInfo* DrvInfo=NULL;

    //Input validation.

    if( aRequest.SystemData() && 

            CSysData::EDriveInfo == aRequest.SystemData()->DataType() )

        DrvInfo = (CDriveInfo*)aRequest.SystemData();

    else

        User::Leave(KErrArgument);

    iDrvNumber = DrvInfo->DriveNumber();

    iCriticalFreeMemory = DrvInfo->CriticalSpace();

    CleanupClosePushL(iFs);

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

    // If Critical Memory not specified assume system defaults.

    if( -1 == iCriticalFreeMemory )

        {

        TVolumeInfo VolumeInfo;

        User::LeaveIfError(iFs.Volume(VolumeInfo,iDrvNumber));

        if(EMediaRam == VolumeInfo.iDrive.iType)

            RepositoryUtil::GetRepositoryKeyL(KCRUidDiskLevel,

                                KRamDiskCriticalLevel, iCriticalFreeMemory);

        else

            RepositoryUtil::GetRepositoryKeyL(KCRUidDiskLevel,

                                KDiskCriticalThreshold, iCriticalFreeMemory);

        }

    CleanupStack::Pop(&iFs);

    }

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

// CCriticalMemNotifier::Request()

// Issues notification request.

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

//

TInt CCriticalMemNotifier::Request ()

    {

    if( !IsActive() )

        {

        iFs.NotifyDiskSpace(iCriticalFreeMemory,iDrvNumber,iStatus);

        SetActive();

        }

    return KErrNone;

    }

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

// CCriticalMemNotifier::RunL()

// Gets called in event of request completion or error situation.

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

//

void CCriticalMemNotifier::RunL()

    {

    TInt error(iStatus.Int());

    if(KErrNone <= error)

        {

        //Re-Issue request.

        Request();

        //Specify the Drive number in output CSysData.

        TBuf<KMaxDriveLength> drv;

        drv.FillZ();

        drv.Append('A'+iDrvNumber);

        drv.Append(KDriveSeperator);

        CStringData* drive = CStringData::NewL(drv);

        TVolumeInfo VolumeInfo;

        iFs.Volume(VolumeInfo,iDrvNumber);