1 /*

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

     3 * All rights reserved.

     4 *

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

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

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

     8 * 

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

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

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12 * GNU Lesser General Public License for more details.

    13 *

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

    15 * along with this program.  If not, 

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

    17 *

    18 * Description:

    19 *

    20 */

    21 

    22 #include "cpublishandsubscribehandler.h"

    23 #include <e32property.h>

    24 

    25 #include "xqsettingskey.h"

    26 

    27 CPublishAndSubscribeHandler* CPublishAndSubscribeHandler::NewL(TUid aUid)

    28 {

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

    30     CleanupStack::PushL(self);

    31     self->ConstructL();

    32     CleanupStack::Pop(self);

    33     return self;

    34 }

    35 

    36 void CPublishAndSubscribeHandler::ConstructL()

    37 {

    38 }

    39 

    40 CPublishAndSubscribeHandler::CPublishAndSubscribeHandler(TUid aUid)

    41     : m_uid(aUid)

    42 {

    43 }

    44 

    45 CPublishAndSubscribeHandler::~CPublishAndSubscribeHandler()

    46 {

    47 }

    48 

    49 void CPublishAndSubscribeHandler::setObserver(MSettingsHandlerObserver* observer)

    50 {

    51     m_observer = observer;

    52 }

    53 

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

    55 {

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

    57 }

    58 

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

    60 {

    61     return KErrArgument;

    62 }

    63 

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

    65 {

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

    67     if (err == KErrOverflow)

    68     {

    69         value.ReAllocL(RProperty::KMaxPropertySize);

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

    71         if (err == KErrOverflow)

    72         {

    73             value.ReAllocL(RProperty::KMaxLargePropertySize);

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

    75         }

    76     }

    77     User::LeaveIfError(err);

    78 }

    79 

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

    81 {

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

    83     if (err == KErrOverflow)

    84     {

    85         value.ReAllocL(RProperty::KMaxPropertySize);

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

    87         if (err == KErrOverflow)

    88         {

    89             value.ReAllocL(RProperty::KMaxLargePropertySize);

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

    91         }

    92     }

    93     User::LeaveIfError(err);

    94 }

    95 

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

    97 {

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

    99 }

   100 

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

   102 {

   103     return KErrArgument;

   104 }

   105 

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

   107 {

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

   109 }

   110 

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

   112 {

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

   114 }

   115 

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

   117 {

   118     switch (type)

   119     {

   120         case XQSettingsManager::TypeInt:

   121         {

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

   123         }

   124         case XQSettingsManager::TypeString:

   125         {

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

   127         }

   128         case XQSettingsManager::TypeByteArray:

   129         {

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

   131         }

   132         case XQSettingsManager::TypeDouble:

   133         default:

   134         {

   135             return KErrArgument;

   136         }

   137     }

   138 }

   139 

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

   141     const XQPublishAndSubscribeSecurityPolicy& readPolicy, const XQPublishAndSubscribeSecurityPolicy& writePolicy)

   142 {

   143     switch (type)

   144     {

   145         case XQSettingsManager::TypeInt:

   146         {

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

   148         }

   149         case XQSettingsManager::TypeString:

   150         {

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

   152         }

   153         case XQSettingsManager::TypeByteArray:

   154         {

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

   156         }

   157         case XQSettingsManager::TypeDouble:

   158         default:

   159         {

   160             return KErrArgument;

   161         }

   162     }

   163 }

   164 

   165 TSecurityPolicy CPublishAndSubscribeHandler::symbianPolicy(const XQPublishAndSubscribeSecurityPolicy& policy)

   166 {

   167     //Use constructor for EAlwaysFail or EAlwaysPass

   168     switch (policy.secPolicyType())

   169     {

   170         case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysFail:

   171         {

   172             return TSecurityPolicy(TSecurityPolicy::EAlwaysFail);

   173         }

   174         case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysPass:

   175         {

   176             return TSecurityPolicy(TSecurityPolicy::EAlwaysPass);

   177         }

   178         default:

   179         {

   180             break;

   181         }

   182     }

   183     

   184     TCapability capability1 = ECapability_None;

   185     TCapability capability2 = ECapability_None;

   186     TCapability capability3 = ECapability_None;

   187     TCapability capability4 = ECapability_None;

   188     TCapability capability5 = ECapability_None;

   189     TCapability capability6 = ECapability_None;

   190     TCapability capability7 = ECapability_None;

   191     

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

   193     

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

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

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

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

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

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

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

   201     

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

   203     if (secureId != -1)

   204     {

   205         //Use constructor for TSecureId + max 3 capabilities

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

   207     }

   208     

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

   210     if (vendorId != -1)

   211     {

   212         //Use constructor for TVendorId + max 3 capabilities

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

   214     }

   215     

   216     if (capabilities.count() < 4)

   217     {

   218         //Use constructor for max 3 capabilities

   219         return TSecurityPolicy(capability1, capability2, capability3);

   220     }

   221     else

   222     {

   223         //Use constructor for max 7 capabilities

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

   225     }

   226 }

   227 

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

   229 {

   230     switch (capability)

   231     {

   232         case XQPublishAndSubscribeSecurityPolicy::CapabilityTCB:                return ECapabilityTCB;

   233         case XQPublishAndSubscribeSecurityPolicy::CapabilityCommDD:             return ECapabilityCommDD;

   234         case XQPublishAndSubscribeSecurityPolicy::CapabilityPowerMgmt:          return ECapabilityPowerMgmt;

   235         case XQPublishAndSubscribeSecurityPolicy::CapabilityMultimediaDD:       return ECapabilityMultimediaDD;

   236         case XQPublishAndSubscribeSecurityPolicy::CapabilityReadDeviceData:     return ECapabilityReadDeviceData;

   237         case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteDeviceData:    return ECapabilityWriteDeviceData;

   238         case XQPublishAndSubscribeSecurityPolicy::CapabilityDRM:                return ECapabilityDRM;

   239         case XQPublishAndSubscribeSecurityPolicy::CapabilityTrustedUI:          return ECapabilityTrustedUI;

   240         case XQPublishAndSubscribeSecurityPolicy::CapabilityProtServ:           return ECapabilityProtServ;

   241         case XQPublishAndSubscribeSecurityPolicy::CapabilityDiskAdmin:          return ECapabilityDiskAdmin;

   242         case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkControl:     return ECapabilityNetworkControl;

   243         case XQPublishAndSubscribeSecurityPolicy::CapabilityAllFiles:           return ECapabilityAllFiles;

   244         case XQPublishAndSubscribeSecurityPolicy::CapabilitySwEvent:            return ECapabilitySwEvent;

   245         case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkServices:    return ECapabilityNetworkServices;

   246         case XQPublishAndSubscribeSecurityPolicy::CapabilityLocalServices:      return ECapabilityLocalServices;

   247         case XQPublishAndSubscribeSecurityPolicy::CapabilityReadUserData:       return ECapabilityReadUserData;

   248         case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteUserData:      return ECapabilityWriteUserData;

   249         case XQPublishAndSubscribeSecurityPolicy::CapabilityLocation:           return ECapabilityLocation;

   250         case XQPublishAndSubscribeSecurityPolicy::CapabilitySurroundingsDD:     return ECapabilitySurroundingsDD;

   251         case XQPublishAndSubscribeSecurityPolicy::CapabilityUserEnvironment:    return ECapabilityUserEnvironment;

   252         default:

   253         {

   254             break;

   255         }

   256     }

   257     return TCapability();

   258 }

   259 

   260 TInt CPublishAndSubscribeHandler::deleteProperty(unsigned long key)

   261 {

   262     return RProperty::Delete(m_uid, key);

   263 }

   264 

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

   266 {

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

   268     {

   269         error = KErrAlreadyExists;

   270         return false;

   271     }

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

   273     if (newMonitor)

   274     {

   275         m_monitors[key.key()] = newMonitor;

   276         error = newMonitor->StartMonitoring();

   277         return error == KErrNone;

   278     }

   279     error = KErrNoMemory;

   280     return false;

   281 }

   282 

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

   284 {

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

   286     {

   287         error = KErrNotFound;

   288         return false;

   289     }

   290     const long int itemKey = key.key();

   291     CPubSubMonitor* monitor = m_monitors[itemKey];

   292     m_monitors.remove(itemKey);

   293     delete monitor;

   294     

   295     return error == KErrNone;

   296 }