/*

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

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include "cpublishandsubscribehandler.h"

#include <e32property.h>

#include "xqsettingskey.h"

CPublishAndSubscribeHandler* CPublishAndSubscribeHandler::NewL(TUid aUid)

{

    CPublishAndSubscribeHandler* self = new (ELeave) CPublishAndSubscribeHandler(aUid); 

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

void CPublishAndSubscribeHandler::ConstructL()

{

}

CPublishAndSubscribeHandler::CPublishAndSubscribeHandler(TUid aUid)

    : m_uid(aUid)

{

}

CPublishAndSubscribeHandler::~CPublishAndSubscribeHandler()

{

}

void CPublishAndSubscribeHandler::setObserver(MSettingsHandlerObserver* observer)

{

    m_observer = observer;

}

TInt CPublishAndSubscribeHandler::getValue(unsigned long key, TInt& value)

{

    return RProperty::Get(m_uid, key, value);

}

TInt CPublishAndSubscribeHandler::getValue(unsigned long /*key*/, TReal& /*value*/)

{

    return KErrArgument;

}

void CPublishAndSubscribeHandler::getValueL(unsigned long key, RBuf8& value)

{

    TInt err = RProperty::Get(m_uid, key, value);

    if (err == KErrOverflow)

    {

        value.ReAllocL(RProperty::KMaxPropertySize);

        err = RProperty::Get(m_uid, key, value);

        if (err == KErrOverflow)

        {

            value.ReAllocL(RProperty::KMaxLargePropertySize);

            err = RProperty::Get(m_uid, key, value);

        }

    }

    User::LeaveIfError(err);

}

void CPublishAndSubscribeHandler::getValueL(unsigned long key, RBuf16& value)

{

    TInt err = RProperty::Get(m_uid, key, value);

    if (err == KErrOverflow)

    {

        value.ReAllocL(RProperty::KMaxPropertySize);

        err = RProperty::Get(m_uid, key, value);

        if (err == KErrOverflow)

        {

            value.ReAllocL(RProperty::KMaxLargePropertySize);

            err = RProperty::Get(m_uid, key, value);

        }

    }

    User::LeaveIfError(err);

}

TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TInt& value)

{

    return RProperty::Set(m_uid, key, value);

}

TInt CPublishAndSubscribeHandler::setValue(unsigned long /*key*/, const TReal& /*value*/)

{

    return KErrArgument;

}

TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TDesC8& value)

{

    return RProperty::Set(m_uid, key, value);

}

TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TDesC16& value)

{

    return RProperty::Set(m_uid, key, value);

}

TInt CPublishAndSubscribeHandler::defineProperty(unsigned long key, XQSettingsManager::Type type)

{

    switch (type)

    {

        case XQSettingsManager::TypeInt:

        {

            return RProperty::Define(m_uid, key, RProperty::EInt);

        }

        case XQSettingsManager::TypeString:

        {

            return RProperty::Define(m_uid, key, RProperty::EText);

        }

        case XQSettingsManager::TypeByteArray:

        {

            return RProperty::Define(m_uid, key, RProperty::EByteArray);

        }

        case XQSettingsManager::TypeDouble:

        default:

        {

            return KErrArgument;

        }

    }

}

TInt CPublishAndSubscribeHandler::defineProperty(unsigned long key, XQSettingsManager::Type type,

    const XQPublishAndSubscribeSecurityPolicy& readPolicy, const XQPublishAndSubscribeSecurityPolicy& writePolicy)

{

    switch (type)

    {

        case XQSettingsManager::TypeInt:

        {

            return RProperty::Define(m_uid, key, RProperty::EInt, symbianPolicy(readPolicy), symbianPolicy(writePolicy));

        }

        case XQSettingsManager::TypeString:

        {

            return RProperty::Define(m_uid, key, RProperty::EText, symbianPolicy(readPolicy), symbianPolicy(writePolicy));

        }

        case XQSettingsManager::TypeByteArray:

        {

            return RProperty::Define(m_uid, key, RProperty::EByteArray, symbianPolicy(readPolicy), symbianPolicy(writePolicy));

        }

        case XQSettingsManager::TypeDouble:

        default:

        {

            return KErrArgument;

        }

    }

}

TSecurityPolicy CPublishAndSubscribeHandler::symbianPolicy(const XQPublishAndSubscribeSecurityPolicy& policy)

{

    //Use constructor for EAlwaysFail or EAlwaysPass

    switch (policy.secPolicyType())

    {

        case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysFail:

        {

            return TSecurityPolicy(TSecurityPolicy::EAlwaysFail);

        }

        case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysPass:

        {

            return TSecurityPolicy(TSecurityPolicy::EAlwaysPass);

        }

        default:

        {

            break;

        }

    }

    TCapability capability1 = ECapability_None;

    TCapability capability2 = ECapability_None;

    TCapability capability3 = ECapability_None;

    TCapability capability4 = ECapability_None;

    TCapability capability5 = ECapability_None;

    TCapability capability6 = ECapability_None;

    TCapability capability7 = ECapability_None;

    const QList<XQPublishAndSubscribeSecurityPolicy::Capability>& capabilities = policy.capabilities();

    if (capabilities.count() > 0) capability1 = symbianCapability(capabilities[0]);

    if (capabilities.count() > 1) capability2 = symbianCapability(capabilities[1]);

    if (capabilities.count() > 2) capability3 = symbianCapability(capabilities[2]);

    if (capabilities.count() > 3) capability4 = symbianCapability(capabilities[3]);

    if (capabilities.count() > 4) capability5 = symbianCapability(capabilities[4]);

    if (capabilities.count() > 5) capability6 = symbianCapability(capabilities[5]);

    if (capabilities.count() > 6) capability7 = symbianCapability(capabilities[6]);

    long int secureId = policy.secureId().uid();

    if (secureId != -1)

    {

        //Use constructor for TSecureId + max 3 capabilities

        return TSecurityPolicy(TSecureId(secureId), capability1, capability2, capability3);

    }

    long int vendorId = policy.vendorId().uid();

    if (vendorId != -1)

    {

        //Use constructor for TVendorId + max 3 capabilities

        return TSecurityPolicy(TVendorId(vendorId), capability1, capability2, capability3);

    }

    if (capabilities.count() < 4)

    {

        //Use constructor for max 3 capabilities

        return TSecurityPolicy(capability1, capability2, capability3);

    }

    else

    {

        //Use constructor for max 7 capabilities

        return TSecurityPolicy(capability1, capability2, capability3, capability4, capability5, capability6, capability7);

    }

}

TCapability CPublishAndSubscribeHandler::symbianCapability(const XQPublishAndSubscribeSecurityPolicy::Capability& capability)

{

    switch (capability)

    {

        case XQPublishAndSubscribeSecurityPolicy::CapabilityTCB:                return ECapabilityTCB;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityCommDD:             return ECapabilityCommDD;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityPowerMgmt:          return ECapabilityPowerMgmt;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityMultimediaDD:       return ECapabilityMultimediaDD;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityReadDeviceData:     return ECapabilityReadDeviceData;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteDeviceData:    return ECapabilityWriteDeviceData;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityDRM:                return ECapabilityDRM;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityTrustedUI:          return ECapabilityTrustedUI;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityProtServ:           return ECapabilityProtServ;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityDiskAdmin:          return ECapabilityDiskAdmin;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkControl:     return ECapabilityNetworkControl;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityAllFiles:           return ECapabilityAllFiles;

        case XQPublishAndSubscribeSecurityPolicy::CapabilitySwEvent:            return ECapabilitySwEvent;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkServices:    return ECapabilityNetworkServices;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityLocalServices:      return ECapabilityLocalServices;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityReadUserData:       return ECapabilityReadUserData;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteUserData:      return ECapabilityWriteUserData;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityLocation:           return ECapabilityLocation;

        case XQPublishAndSubscribeSecurityPolicy::CapabilitySurroundingsDD:     return ECapabilitySurroundingsDD;

        case XQPublishAndSubscribeSecurityPolicy::CapabilityUserEnvironment:    return ECapabilityUserEnvironment;

        default:

        {

            break;

        }

    }

    return TCapability();

}

TInt CPublishAndSubscribeHandler::deleteProperty(unsigned long key)

{

    return RProperty::Delete(m_uid, key);

}

bool CPublishAndSubscribeHandler::handleStartMonitoring(const XQSettingsKey& key, XQSettingsManager::Type type, MSettingsHandlerObserver& observer, TInt& error)

{

    if (m_monitors.contains(key.key()))

    {

        error = KErrAlreadyExists;

        return false;

    }

    CPubSubMonitor* newMonitor = new CPubSubMonitor(key, type, observer);

    if (newMonitor)

    {

        m_monitors[key.key()] = newMonitor;

        error = newMonitor->StartMonitoring();

        return error == KErrNone;

    }

    error = KErrNoMemory;

    return false;

}

bool CPublishAndSubscribeHandler::handleStopMonitoring(const XQSettingsKey& key, TInt& error)

{

    if (!m_monitors.contains(key.key()))

    {

        error = KErrNotFound;

        return false;

    }

    const long int itemKey = key.key();

    CPubSubMonitor* monitor = m_monitors[itemKey];

    m_monitors.remove(itemKey);

    delete monitor;

    return error == KErrNone;

}