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 "xqcentralrepositoryutils_p.h"

    23 #include "xqsettingsmanager.h"

    24 #include "xqsettingsmanager_p.h"

    25 #include "ccentralrepositoryhandler.h"

    26 #include "xqcentralrepositorysearchcriteria.h"

    27 

    28 XQCentralRepositoryUtilsPrivate::XQCentralRepositoryUtilsPrivate(XQSettingsManager& settingsManager)

    29     : m_settingsManagerPrivate(*settingsManager.d)

    30 {

    31 }

    32 

    33 XQCentralRepositoryUtilsPrivate::~XQCentralRepositoryUtilsPrivate()

    34 {

    35 }

    36 

    37 #ifdef XQSETTINGSMANAGER_NO_CENREPKEY_CREATION_DELETION

    38 bool XQCentralRepositoryUtilsPrivate::createKey(const XQCentralRepositorySettingsKey& /*key*/, const QVariant& /*value*/)

    39 {

    40     m_settingsManagerPrivate.iError = KErrNotSupported;

    41     return false;

    42 }

    43 #else    

    44 bool XQCentralRepositoryUtilsPrivate::createKey(const XQCentralRepositorySettingsKey& key, const QVariant& value)

    45 {

    46     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(key.uid());

    47     

    48     if (handler)

    49     {

    50         switch (value.type())

    51         {

    52             case QVariant::Int:

    53             {

    54                 m_settingsManagerPrivate.iError = handler->createKey(key.key(), value.toInt());

    55                 break;

    56             }

    57             case QVariant::Double:

    58             {

    59                 m_settingsManagerPrivate.iError = handler->createKey(key.key(), value.toDouble());

    60                 break;

    61             }

    62             case QVariant::String:

    63             {

    64                 m_settingsManagerPrivate.iError = handler->createKey(key.key(), TPtrC16(reinterpret_cast<const TUint16*>(value.toString().utf16())));

    65                 break;

    66             }

    67             case QVariant::ByteArray:

    68             {

    69                 m_settingsManagerPrivate.iError = handler->createKey(key.key(), TPtrC8((TUint8*)(value.toByteArray().constData())));

    70                 break;

    71             }

    72             default:

    73             {

    74                 m_settingsManagerPrivate.iError = KErrArgument;

    75                 break;

    76             }

    77         }

    78     }

    79     else

    80     {

    81         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

    82     }

    83     return m_settingsManagerPrivate.iError == KErrNone;

    84 }

    85 #endif

    86 

    87 #ifdef XQSETTINGSMANAGER_NO_CENREPKEY_CREATION_DELETION

    88 bool XQCentralRepositoryUtilsPrivate::deleteKey(const XQCentralRepositorySettingsKey& /*key*/)

    89 {

    90     m_settingsManagerPrivate.iError = KErrNotSupported;

    91     return false;

    92 }

    93 #else

    94 bool XQCentralRepositoryUtilsPrivate::deleteKey(const XQCentralRepositorySettingsKey& key)

    95 {

    96     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(key.uid());

    97     

    98     if (handler)

    99     {

   100         m_settingsManagerPrivate.iError = handler->deleteKey(key.key());

   101     }

   102     else

   103     {

   104         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   105     }

   106     return m_settingsManagerPrivate.iError == KErrNone;

   107 }

   108 #endif

   109 

   110 bool XQCentralRepositoryUtilsPrivate::resetKey(const XQCentralRepositorySettingsKey& key)

   111 {

   112     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(key.uid());

   113     

   114     if (handler)

   115     {

   116         m_settingsManagerPrivate.iError = handler->resetKey(key.key());

   117     }

   118     else

   119     {

   120         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   121     }

   122     return m_settingsManagerPrivate.iError == KErrNone;

   123 }

   124 

   125 bool XQCentralRepositoryUtilsPrivate::resetRepository(long int repositoryUid)

   126 {

   127     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);

   128     

   129     if (handler)

   130     {

   131         m_settingsManagerPrivate.iError = handler->resetRepository();

   132     }

   133     else

   134     {

   135         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   136     }

   137     return m_settingsManagerPrivate.iError == KErrNone;

   138 }

   139 

   140 QList<XQCentralRepositorySettingsKey> XQCentralRepositoryUtilsPrivate::findKeys(const XQCentralRepositorySearchCriteria& criteria)

   141 {

   142     long int repositoryUid = criteria.repositoryUid();

   143     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);

   144     if (!handler)

   145     {

   146         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   147         return QList<XQCentralRepositorySettingsKey>();

   148     }

   149 

   150     QList<XQCentralRepositorySettingsKey> keys;

   151 

   152     TRAP(m_settingsManagerPrivate.iError,

   153         RArray<TUint32> foundKeys;

   154         CleanupClosePushL(foundKeys);

   155         if (criteria.value().isNull())

   156         {

   157             User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),

   158                 foundKeys));

   159         }

   160         else

   161         {

   162             switch (criteria.value().type())

   163             {

   164                 case QVariant::Int:

   165                 {

   166                     User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),

   167                         criteria.value().toInt(), criteria.negativeCriteria(), foundKeys));

   168                     break;

   169                 }

   170                 case QVariant::Double:

   171                 {

   172                     User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),

   173                         criteria.value().toDouble(), criteria.negativeCriteria(), foundKeys));

   174                     break;

   175                 }

   176                 case QVariant::String:

   177                 {

   178                     TPtrC16 stringValue(reinterpret_cast<const TUint16*>(criteria.value().toString().utf16()));

   179                     User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),

   180                         stringValue, criteria.negativeCriteria(), foundKeys));

   181                     break;

   182                 }

   183                 case QVariant::ByteArray:

   184                 {

   185                     TPtrC8 byteArrayValue((TUint8*)(criteria.value().toByteArray().constData()));

   186                     User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),

   187                         byteArrayValue, criteria.negativeCriteria(), foundKeys));

   188                     break;

   189                 }

   190                 default:

   191                 {

   192                     User::Leave(KErrArgument);

   193                     break;

   194                 }

   195             }

   196         }

   197         for (int i = 0; i < foundKeys.Count(); ++i)

   198         {

   199             XQCentralRepositorySettingsKey key(repositoryUid, foundKeys[i]);

   200             keys.append(key);

   201         }

   202 

   203         CleanupStack::PopAndDestroy(&foundKeys);

   204     )

   205     return keys;

   206 }

   207 

   208 bool XQCentralRepositoryUtilsPrivate::startTransaction(long int repositoryUid, XQCentralRepositoryUtils::TransactionMode transactionMode)

   209 {

   210     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);

   211     

   212     if (handler)

   213     {

   214         CRepository::TTransactionMode mode = CRepository::EConcurrentReadWriteTransaction;

   215         switch (transactionMode)

   216         {

   217             case XQCentralRepositoryUtils::ConcurrentReadWriteTransaction:

   218             {

   219                 mode = CRepository::EConcurrentReadWriteTransaction;

   220                 break;

   221             }

   222             case XQCentralRepositoryUtils::ReadTransaction:

   223             {

   224                 mode = CRepository::EReadTransaction;

   225                 break;

   226             }

   227             case XQCentralRepositoryUtils::ReadWriteTransaction:

   228             {

   229                 mode = CRepository::EReadWriteTransaction;

   230                 break;

   231             }

   232             default:

   233             {

   234                 m_settingsManagerPrivate.iError = KErrArgument;

   235                 return false;

   236             }

   237         }

   238         m_settingsManagerPrivate.iError = handler->startTransaction(mode);

   239     }

   240     else

   241     {

   242         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   243     }

   244     return m_settingsManagerPrivate.iError == KErrNone;

   245 }

   246 

   247 bool XQCentralRepositoryUtilsPrivate::commitTransaction(long int repositoryUid)

   248 {

   249     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);

   250     

   251     if (handler)

   252     {

   253         m_settingsManagerPrivate.iError = handler->commitTransaction();

   254     }

   255     else

   256     {

   257         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   258     }

   259     return m_settingsManagerPrivate.iError == KErrNone;

   260 }

   261 

   262 void XQCentralRepositoryUtilsPrivate::cancelTransaction(long int repositoryUid)

   263 {

   264     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);

   265     if (!handler)

   266     {

   267         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   268         return;

   269     }

   270     m_settingsManagerPrivate.iError = XQSettingsManager::NoError;

   271     handler->cancelTransaction();

   272 }

   273 

   274 void XQCentralRepositoryUtilsPrivate::failTransaction(long int repositoryUid)

   275 {

   276     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);

   277     if (!handler)

   278     {

   279         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   280         return;

   281     }

   282     m_settingsManagerPrivate.iError = XQSettingsManager::NoError;

   283     handler->failTransaction();

   284 }

   285 

   286 XQCentralRepositoryUtils::TransactionState XQCentralRepositoryUtilsPrivate::transactionState(long int repositoryUid) const

   287 {

   288     CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);

   289     if (!handler)

   290     {

   291         m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;

   292         return XQCentralRepositoryUtils::UnknownTransaction;

   293     }

   294 

   295     m_settingsManagerPrivate.iError = XQSettingsManager::NoError;

   296     switch (handler->transactionState())

   297     {

   298         case 0: return XQCentralRepositoryUtils::NotInTransaction;

   299         case 2: return XQCentralRepositoryUtils::ActiveTransaction;

   300         case 6: return XQCentralRepositoryUtils::FailedTransaction;

   301         default:

   302         {

   303             break;

   304         }

   305     }

   306     return XQCentralRepositoryUtils::UnknownTransaction;

   307 }