diff -r e8e63152f320 -r 2a9601315dfc javaextensions/midppush/pushregistryplugin/src/pushdbhandler.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/midppush/pushregistryplugin/src/pushdbhandler.cpp	Mon May 03 12:27:20 2010 +0300
@@ -0,0 +1,670 @@
+/*
+* Copyright (c) 2008 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:
+*
+*/
+
+
+#include "logger.h"
+#include "pushdbhandler.h"
+#include "javacommonutils.h"
+#include "pusherrorcodes.h"
+#include "pushexception.h"
+#include "javastorageexception.h"
+#include "javastoragenames.h"
+
+using namespace java::push;
+using namespace java::storage;
+using namespace java::util;
+
+/**
+ *
+ */
+PushDBHandler::PushDBHandler()
+        : mDbStorage(NULL)
+{
+    JELOG2(EJavaPush);
+}
+
+/**
+ *
+ */
+PushDBHandler::~PushDBHandler()
+{
+    JELOG2(EJavaPush);
+}
+
+/**
+ *
+ */
+void PushDBHandler::storeDynamicPushRegistration(const java::util::Uid& aUid,
+        const std::wstring& aUri,
+        const std::wstring& aMidletName,
+        const std::wstring& aFilter)
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        JavaStorageApplicationEntry_t entries;
+        JavaStorageEntry entry;
+        entry.setEntry(URL,aUri,JavaStorageEntry::STRING);
+        entries.insert(entry);
+        entry.setEntry(NAME,aMidletName,JavaStorageEntry::STRING);
+        entries.insert(entry);
+        entry.setEntry(FILTER,aFilter,JavaStorageEntry::STRING);
+        entries.insert(entry);
+        entry.setEntry(REGISTRATION_TYPE,L"0",JavaStorageEntry::INT);
+        entries.insert(entry);
+
+        entry.setEntry(ID, aUid.toString());
+        entries.insert(entry);
+
+        //ScopedLock lockObj(mMutex);
+        openDbStorage();
+        mDbStorage->startTransaction();
+        mDbStorage->write(PUSH_REGISTRATIONS_TABLE,entries);
+        mDbStorage->commitTransaction();
+        mDbStorage->close();
+    }
+    catch (JavaStorageException& ex)
+    {
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);
+    }
+    catch (...)
+    {
+        WLOG(EJavaPush,"ERROR!!! Unexpected error in storeDynamicPushRegistration() operation");
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushDBHandler::unregisterDynamicPushRegistration(const java::util::Uid& aUid,
+        const std::wstring& aUri)
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        JavaStorageApplicationEntry_t entries;
+        JavaStorageEntry entry;
+        entry.setEntry(ID,aUid.toString(),JavaStorageEntry::STRING);
+        entries.insert(entry);
+        entry.setEntry(URL,aUri,JavaStorageEntry::STRING);
+        entries.insert(entry);
+        entry.setEntry(REGISTRATION_TYPE,L"0",JavaStorageEntry::INT);
+        entries.insert(entry);
+
+        //ScopedLock lockObj(mMutex);
+        openDbStorage();
+
+        mDbStorage->startTransaction();
+        mDbStorage->remove(PUSH_REGISTRATIONS_TABLE,entries);
+        mDbStorage->commitTransaction();
+        mDbStorage->close();
+    }
+    catch (PushException& ex)
+    {
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->close();
+        }
+        throw;
+    }
+    catch (JavaStorageException& ex)
+    {
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);
+    }
+    catch (...)
+    {
+        WLOG(EJavaPush,"ERROR!!! Unexpected error in unregisterDynamicPushRegistration() operation");
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushDBHandler::storeAlarm(const Uid& aUid,const long long& aAlarmInMilliSecs)
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        JavaStorageApplicationEntry_t entries;
+        JavaStorageEntry entry;
+
+        std::wstring timeStr = JavaCommonUtils::longLongToWstring(aAlarmInMilliSecs);
+        entry.setEntry(ALARM_TIME,timeStr,JavaStorageEntry::STRING);
+        entries.insert(entry);
+        entry.setEntry(ID, aUid.toString());
+        entries.insert(entry);
+
+        //ScopedLock lockObj(mMutex);
+        openDbStorage();
+        mDbStorage->startTransaction();
+        mDbStorage->write(ALARM_REGISTRATIONS_TABLE,entries);
+        mDbStorage->commitTransaction();
+        mDbStorage->close();
+    }
+    catch (JavaStorageException& ex)
+    {
+        if (0 !=mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);
+    }
+    catch (...)
+    {
+        WLOG(EJavaPush,"ERROR!!! Unexpected error in storeAlarm() operation");
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushDBHandler::deleteAlarm(const Uid& aUid)
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        JavaStorageApplicationEntry_t entries;
+        JavaStorageEntry entry;
+        entry.setEntry(ID, aUid.toString());
+        entries.insert(entry);
+
+        //ScopedLock lockObj(mMutex);
+        openDbStorage();
+        mDbStorage->startTransaction();
+        mDbStorage->remove(ALARM_REGISTRATIONS_TABLE,entries);
+        mDbStorage->commitTransaction();
+        mDbStorage->close();
+    }
+    catch (JavaStorageException& ex)
+    {
+        if (0 !=mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);
+    }
+    catch (...)
+    {
+        WLOG(EJavaPush,"ERROR!!! Unexpected error in deleteAlarm() operation");
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->rollbackTransaction();
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushDBHandler::getPushRegs(const java::util::Uid& aUid,
+                                java::storage::JavaStorageApplicationList_t& aPushRegs)
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        JavaStorageApplicationEntry_t findPatterns;
+        JavaStorageEntry findPattern;
+        if (!aUid.isEmpty())
+        {
+            findPattern.setEntry(ID,aUid.toString(),JavaStorageEntry::STRING);
+            findPatterns.insert(findPattern);
+        }
+
+        //ScopedLock lockObj(mMutex);
+        openDbStorage();
+        mDbStorage->search(PUSH_REGISTRATIONS_TABLE,findPatterns,aPushRegs);
+        mDbStorage->close();
+    }
+    catch (JavaStorageException& ex)
+    {
+        if (0 !=mDbStorage.get())
+        {
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);
+    }
+    catch (...)
+    {
+        WLOG(EJavaPush,"ERROR!!! Unexpected error in getPushRegs() operation");
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushDBHandler::getAlarms(const java::util::Uid& aUid,
+                              std::list<DbAlarmData>& aAlarmList)
+{
+    JELOG2(EJavaPush);
+    try
+    {
+        JavaStorageEntry findPattern;
+        JavaStorageApplicationEntry_t findPatterns;
+        JavaStorageApplicationList_t foundEntries;
+        if (!aUid.isEmpty())
+        {
+            findPattern.setEntry(ID,aUid.toString(),JavaStorageEntry::STRING);
+            findPatterns.insert(findPattern);
+        }
+
+        //ScopedLock lockObj(mMutex);
+        openDbStorage();
+        mDbStorage->search(ALARM_REGISTRATIONS_TABLE,findPatterns,foundEntries);
+        fillAlarmData(aAlarmList,foundEntries);
+        mDbStorage->close();
+    }
+    catch (JavaStorageException& ex)
+    {
+        if (0 !=mDbStorage.get())
+        {
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);
+    }
+    catch (...)
+    {
+        WLOG(EJavaPush,"ERROR!!! Unexpected error in getAlarms() operation");
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushDBHandler::getMidletSuiteInfo(const java::util::Uid& aSuiteUid,
+                                       std::multimap<Uid,
+                                       MidletSuiteData>& aMidletSuiteInfo)
+{
+    JELOG2(EJavaPush);
+
+    getMidletSuiteInfo(aSuiteUid,PACKAGE_ID,aMidletSuiteInfo);
+}
+
+/**
+ *
+ */
+void PushDBHandler::getMidletSuiteInfoByMidletUid
+(const Uid& aMidletUid,std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo)
+{
+    JELOG2(EJavaPush);
+
+    getMidletSuiteInfo(aMidletUid,ID,aMidletSuiteInfo);
+}
+
+/**
+ *
+ */
+void PushDBHandler::getMidletSuiteInfo(const java::util::Uid& aUid,
+                                       const std::wstring& aSearchColumn,
+                                       std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo)
+{
+    JELOG2(EJavaPush);
+
+    try
+    {
+        JavaStorageEntry findPattern;
+        JavaStorageApplicationEntry_t findPatterns;
+        JavaStorageApplicationList_t foundEntries;
+        if (!aUid.isEmpty())
+        {
+            //Search condition can be PACKAGE_ID or ID.
+            findPattern.setEntry(aSearchColumn,aUid.toString(),JavaStorageEntry::STRING);
+            findPatterns.insert(findPattern);
+        }
+
+        findPattern.setEntry(PACKAGE_ID,L"");
+        findPatterns.insert(findPattern);
+        findPattern.setEntry(ID,L"");
+        findPatterns.insert(findPattern);
+        findPattern.setEntry(MAIN_CLASS,L"");
+        findPatterns.insert(findPattern);
+
+        //ScopedLock lockObj(mMutex);
+        openDbStorage();
+        mDbStorage->search(APPLICATION_TABLE,findPatterns,foundEntries);
+        fillMidletSuiteInfo(aMidletSuiteInfo,foundEntries);
+        addMediaId(*mDbStorage.get(),aMidletSuiteInfo);
+        mDbStorage->close();
+    }
+    catch (ExceptionBase& ex)
+    {
+        if (0 !=mDbStorage.get())
+        {
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,ex.toString(),__FILE__,__FUNCTION__,__LINE__);
+    }
+    catch (...)
+    {
+        WLOG(EJavaPush,"ERROR!!! Unexpected error in getAlarms() operation");
+        if (0 != mDbStorage.get())
+        {
+            mDbStorage->close();
+        }
+        throw PushException(DB_ERROR,"Unexpected exception occurred",__FILE__,__FUNCTION__,__LINE__);
+    }
+}
+
+/**
+ *
+ */
+void PushDBHandler::addMediaId(JavaStorage& aStorageObj,
+                               std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo)
+{
+    JELOG2(EJavaPush);
+
+    std::map<Uid,int> mediaIdContainer;
+    std::map<Uid,int>::iterator mediaIdContainerIter;
+
+    std::multimap<Uid,MidletSuiteData>::iterator iter;
+    for (iter = aMidletSuiteInfo.begin(); iter != aMidletSuiteInfo.end(); ++iter)
+    {
+        if (UNDEFINED_MEDIA_ID == iter->second.mMediaId)
+        {
+            mediaIdContainerIter = mediaIdContainer.find(iter->first);
+            if (mediaIdContainer.end() == mediaIdContainerIter)
+            {
+                getMediaId(aStorageObj,iter->first,mediaIdContainer);
+                mediaIdContainerIter = mediaIdContainer.find(iter->first);
+                if (mediaIdContainer.end() == mediaIdContainerIter)
+                {
+                    throw PushException(DB_ERROR,"media id by suite uid is not found",
+                                        __FILE__,__FUNCTION__,__LINE__);
+                }
+            }
+            iter->second.mMediaId = mediaIdContainerIter->second;
+        }//end if(-1 == iter->second.mMediaId)
+    }//end for
+
+    mediaIdContainer.clear();
+}
+
+/**
+ *
+ */
+void PushDBHandler::getMediaId(JavaStorage& aStorageObj,const Uid& aSuiteUid,
+                               std::map<Uid,int>& aMediaIdContainer)
+{
+    JavaStorageEntry findPattern;
+    JavaStorageApplicationEntry_t findPatterns;
+    JavaStorageApplicationList_t foundEntries;
+
+    findPattern.setEntry(ID,aSuiteUid.toString(),JavaStorageEntry::STRING);
+    findPatterns.insert(findPattern);
+    findPattern.setEntry(MEDIA_ID,L"");
+    findPatterns.insert(findPattern);
+
+    aStorageObj.search(APPLICATION_PACKAGE_TABLE,findPatterns,foundEntries);
+    fillMidletId(aSuiteUid,aMediaIdContainer,foundEntries);
+}
+
+/**
+ *
+ */
+void PushDBHandler::fillMidletId(const Uid& aSuiteUid,
+                                 std::map<Uid,int>& aMediaIdContainer,
+                                 JavaStorageApplicationList_t& aFoundEntries)
+{
+    JavaStorageEntry findPatternForMediaId;
+    std::wstring empty = L"";
+    findPatternForMediaId.setEntry(MEDIA_ID,empty);
+
+    JavaStorageApplicationList_t::iterator iter;
+    for (iter = aFoundEntries.begin(); iter != aFoundEntries.end(); ++iter)
+    {
+        int mediaId = 0;
+        if ((true == getDbValueAsInt(iter,findPatternForMediaId,mediaId)))
+            aMediaIdContainer.insert(std::pair<Uid,int>(aSuiteUid,mediaId));
+    }//end for
+}
+
+/**
+ *
+ */
+void PushDBHandler::fillAlarmData(std::list<DbAlarmData>& aAlarmList,
+                                  JavaStorageApplicationList_t& aFoundEntries)
+{
+    JELOG2(EJavaPush);
+
+    JavaStorageEntry findPatternForUid;
+    std::wstring empty = L"";
+    findPatternForUid.setEntry(ID,empty);
+
+    JavaStorageEntry findPatternForTime;
+    findPatternForTime.setEntry(ALARM_TIME,empty);
+
+    JavaStorageApplicationList_t::iterator iter;
+    for (iter = aFoundEntries.begin(); iter != aFoundEntries.end(); ++iter)
+    {
+        // Get application ID.
+        Uid tmpUid;
+        long long tmpTime = 0LL;
+        if ((true == getDbValueAsUid(iter,findPatternForUid,tmpUid))
+                && (true == getDbValueAsLongLong(iter,findPatternForTime,tmpTime)))
+        {
+            DbAlarmData alarmData(tmpUid,tmpTime,true);
+            aAlarmList.push_back(alarmData);
+        }
+    }//end for
+}
+
+/**
+ *
+ */
+void PushDBHandler::fillMidletSuiteInfo(std::multimap<Uid,MidletSuiteData>& aMidletSuiteInfo,
+                                        JavaStorageApplicationList_t& aFoundEntries)
+{
+    JELOG2(EJavaPush);
+
+    JavaStorageEntry findPatternForSuiteUid;
+    std::wstring empty = L"";
+    findPatternForSuiteUid.setEntry(PACKAGE_ID,empty);
+
+    JavaStorageEntry findPatternForMidletUid;
+    findPatternForMidletUid.setEntry(ID,empty);
+
+    JavaStorageEntry findPatternForMainClass;
+    findPatternForMainClass.setEntry(MAIN_CLASS,empty);
+
+    JavaStorageApplicationList_t::iterator iter;
+    for (iter = aFoundEntries.begin(); iter != aFoundEntries.end(); ++iter)
+    {
+        Uid tmpSuiteUid;
+        Uid tmpMidletUid;
+        std::wstring className;
+        if ((true == getDbValueAsUid(iter,findPatternForSuiteUid,tmpSuiteUid))
+                && (true == getDbValueAsUid(iter,findPatternForMidletUid,tmpMidletUid))
+                && (true == getDbValueAsWStr(iter,findPatternForMainClass,className)))
+        {
+            MidletSuiteData dataObj(tmpMidletUid,className);
+            aMidletSuiteInfo.insert(std::pair<Uid,MidletSuiteData>(tmpSuiteUid,dataObj));
+        }
+    }//end for
+}
+
+/**
+ *
+ */
+bool PushDBHandler::getDbValueAsUid(JavaStorageApplicationList_t::iterator& aIter,
+                                    JavaStorageEntry& aFindPattern,Uid& aOutput)
+{
+    JavaStorageApplicationEntry_t::iterator tmpIter = aIter->find(aFindPattern);
+    if (tmpIter != aIter->end())
+    {
+        std::wstring uidAsStr = tmpIter->entryValue();
+        if (0 != uidAsStr.compare(L""))
+        {
+            Uid tmpUid(uidAsStr);
+            aOutput = uidAsStr;
+            return true;
+        }
+    }//end if(tmpIter != aIter->end())
+    return false;
+}
+
+/**
+ *
+ */
+bool PushDBHandler::getDbValueAsLongLong(JavaStorageApplicationList_t::iterator& aIter,
+        JavaStorageEntry& aFindPattern,long long& aOutput)
+{
+    JavaStorageApplicationEntry_t::iterator tmpIter = aIter->find(aFindPattern);
+    if (tmpIter != aIter->end())
+    {
+        std::wstring longLongAsStr = tmpIter->entryValue();
+        if (0 != longLongAsStr.compare(L""))
+        {
+            aOutput = JavaCommonUtils::wstringToLongLong(longLongAsStr);
+            return true;
+        }
+    }//end if(tmpIter != aIter->end())
+    return false;
+}
+
+/**
+ *
+ */
+bool PushDBHandler::getDbValueAsInt(JavaStorageApplicationList_t::iterator& aIter,
+                                    JavaStorageEntry& aFindPattern,int& aOutput)
+{
+    JavaStorageApplicationEntry_t::iterator tmpIter = aIter->find(aFindPattern);
+    if (tmpIter != aIter->end())
+    {
+        std::wstring intAsStr = tmpIter->entryValue();
+        if (0 != intAsStr.compare(L""))
+        {
+            aOutput = JavaCommonUtils::wstringToInt(intAsStr);
+            return true;
+        }
+    }//end if(tmpIter != aIter->end())
+    return false;
+}
+
+/**
+ *
+ */
+bool PushDBHandler::getDbValueAsWStr(JavaStorageApplicationList_t::iterator& aIter,
+                                     JavaStorageEntry& aFindPattern,std::wstring& aOutput)
+{
+    JavaStorageApplicationEntry_t::iterator tmpIter = aIter->find(aFindPattern);
+    if (tmpIter != aIter->end())
+    {
+        aOutput = tmpIter->entryValue();
+        if (0 != aOutput.compare(L""))
+        {
+            return true;
+        }
+    }//end if(tmpIter != aIter->end())
+    return false;
+}
+
+/**
+ *
+ */
+void PushDBHandler::openDbStorage()
+{
+    JELOG2(EJavaPush);
+
+    if (0 == mDbStorage.get())
+        mDbStorage.reset(JavaStorage::createInstance());
+
+    mDbStorage->open("JavaStorage");
+}
+
+/**
+ * IMPLEMENTATION OF DbAlarmData CLASS.
+ */
+DbAlarmData::DbAlarmData(const Uid& aUid,const long long& aTimeInMilliSecs,bool aValidateTime)
+        : mUid(aUid),mTimeInMilliSecs(aTimeInMilliSecs),mValidateTime(aValidateTime)
+{
+}
+
+DbAlarmData::~DbAlarmData()
+{
+}
+
+DbAlarmData::DbAlarmData(const DbAlarmData& x)
+{
+    *this = x;
+}
+
+const Uid& DbAlarmData::getUid() const
+{
+    return mUid;
+}
+
+long long DbAlarmData::getTime() const
+{
+    return mTimeInMilliSecs;
+}
+
+bool DbAlarmData::validateAlarmTime() const
+{
+    return mValidateTime;
+}
+
+DbAlarmData& DbAlarmData::operator=(const DbAlarmData& x)
+{
+    mUid = x.mUid;
+    mTimeInMilliSecs = x.mTimeInMilliSecs;
+    mValidateTime = x.mValidateTime;
+    return *this;
+}
+
+
+