--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javamanager/javabackup/midp2backup_usif/src.s60/javastoragebackuputil.cpp Tue Jul 06 20:36:19 2010 +0300
@@ -0,0 +1,2084 @@
+/*
+* Copyright (c) 2008-2009 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: Implementation of CStorageBackupUtil
+*
+*/
+
+
+#include "javastoragebackuputil.h"
+#include "midp2backupplugin.h"
+#include "midp2backupdataids.h"
+
+#include "javastorageentry.h"
+#include "javastorage.h"
+#include "javastoragenames.h"
+
+#include "logger.h"
+#include "javauid.h"
+#include "javaoslayer.h"
+#include "javacommonutils.h"
+#include "s60commonutils.h"
+#include "javasymbianoslayer.h"
+
+#include <memory>
+#include <s32mem.h>
+
+using namespace std;
+using namespace java::storage;
+using namespace java::backup;
+
+// ======== MEMBER FUNCTIONS ========
+
+CStorageBackupUtil::CStorageBackupUtil()
+{
+ LOG(EBackup, EInfo, "CStorageBackupUtil constructor");
+}
+
+void CStorageBackupUtil::ConstructL()
+{
+ LOG(EBackup, EInfo, "CStorageBackupUtil::ConstructL");
+
+ iFirstCalltoBackupStorageData = ETrue;
+ iFirstCalltoRestoreStorageData = ETrue;
+
+ iBufferSpaceLeft = 0;
+
+ iRemainingString = EFalse;
+ iStrCount = 0;
+
+ for (int tableNumber = 0; tableNumber < NUMBER_OF_TABLES; tableNumber++)
+ {
+ iTableSize[tableNumber] = 0;
+ }
+}
+
+CStorageBackupUtil* CStorageBackupUtil::NewL()
+{
+ LOG(EBackup, EInfo, "CStorageBackupUtil::NewL");
+
+ CStorageBackupUtil* self = new(ELeave) CStorageBackupUtil();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+
+ return self;
+}
+
+CStorageBackupUtil::~CStorageBackupUtil()
+{
+ LOG(EBackup, EInfo, "CStorageBackupUtil Destructor");
+
+ // clear the vectors to free all the heap data.
+ iStringVector.clear();
+}
+
+
+void CStorageBackupUtil::BackupStorageDataL(RDesWriteStream& aStream, TBool& aBackupNotFinished, TInt& aBufferSpaceLeft)
+{
+ LOG(EBackup, EInfo, "CStorageBackupUtil::BackupStorageDataL");
+
+ iBufferSpaceLeft = aBufferSpaceLeft;
+
+ if (iFirstCalltoBackupStorageData)
+ {
+ int err = FillVectorWithStorageData();
+
+ if (err != KErrNone)
+ {
+ User::Leave(err);
+ }
+ LOG1(EBackup, EInfo, "Total no of rows in vector: %d", iStringVector.size());
+
+ // First write the total no of rows in the vector to the stream
+
+ aStream.WriteInt32L(iStringVector.size());
+ iBufferSpaceLeft -= sizeof(TInt32);
+
+ /* Then write the number of rows in each table to the stream.
+ This will be used while writing the data to storage. */
+
+ for (int tableNumber = 0; tableNumber < NUMBER_OF_TABLES; tableNumber++)
+ {
+ aStream.WriteInt16L(iTableSize[tableNumber]);
+ iBufferSpaceLeft -= sizeof(TInt16);
+ }
+
+ iFirstCalltoBackupStorageData = EFalse;
+ }
+
+ // Now write the actual string data into the stream.
+
+ while (iBufferSpaceLeft > 0 && iStrCount < iStringVector.size())
+ {
+ WriteStringtoStreamL(aStream, iStringVector[iStrCount]);
+ LOG1(EBackup, EInfo, "StrCount = %d", iStrCount);
+ }
+
+ if (iStrCount >= iStringVector.size())
+ {
+ LOG(EBackup, EInfo, "Backup of storage data finished");
+ aBackupNotFinished = EFalse;
+ }
+}
+
+void CStorageBackupUtil::RestoreStorageDataL(RDesReadStream& aStream, TInt& aRestoreState, TInt& aBufferSpaceLeft)
+{
+ LOG(EBackup, EInfo, "CStorageBackupUtil::RestoreStorageDataL()");
+
+ iBufferSpaceLeft = aBufferSpaceLeft;
+
+ if (iFirstCalltoRestoreStorageData)
+ {
+ // the no of strings in the stream
+ iStrCount = aStream.ReadInt32L();
+ iBufferSpaceLeft -= sizeof(TInt32);
+
+ // read the number of rows in each table
+ for (int tableNumber = 0; tableNumber < NUMBER_OF_TABLES; tableNumber++)
+ {
+ iTableSize[tableNumber] = aStream.ReadInt16L();
+ iBufferSpaceLeft -= sizeof(TInt16);
+ }
+ iFirstCalltoRestoreStorageData = EFalse;
+ }
+
+ while (iBufferSpaceLeft > 0 && iStrCount > 0)
+ {
+ ReadStringfromStreamL(aStream);
+ }
+
+ if (iStrCount == 0)
+ {
+ LOG1(EBackup, EInfo, "Finished reading from stream, row count = %d", iStringVector.size());
+
+
+ int err = WriteDataToStorage();
+
+ if (err != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(&aStream);
+ User::Leave(KErrGeneral);
+ }
+
+ // Storage restore is over; Change the state
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+ aRestoreState = EScr;
+#else
+ aRestoreState = EAppArc;
+#endif // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+
+ aBufferSpaceLeft = iBufferSpaceLeft;
+ }
+}
+
+
+void CStorageBackupUtil::WriteStringtoStreamL(RDesWriteStream& aStream, wstring aStr)
+{
+ iLenOfString = aStr.length();
+
+ // if length of string is 0, do not write any string to the stream.
+ if (iLenOfString == 0)
+ {
+ aStream.WriteInt16L(iLenOfString*2);
+ iBufferSpaceLeft -= sizeof(TInt16);
+ iStrCount++;
+ }
+
+ else
+ {
+ /* if space is not enough for writing the complete string,
+ do not write it. Could be written next time. */
+ if (((iLenOfString*2) + sizeof(TInt16)) > iBufferSpaceLeft)
+ {
+ LOG(EBackup, EInfo, "Stream size is not enough to hold the string");
+ // set the bufferspaceleft to zero
+ iBufferSpaceLeft = 0;
+ }
+ // stream has enough space for the length and the string data.
+ else
+ {
+ aStream.WriteInt16L(iLenOfString*2);
+ iBufferSpaceLeft -= sizeof(TInt16);
+
+ HBufC* tempstr = java::util::S60CommonUtils::wstringToDes(aStr.c_str());
+ TPtrC tempStr = tempstr->Des();
+ aStream.WriteL(tempStr);
+ iBufferSpaceLeft -= (iLenOfString*2);
+ delete tempstr;
+
+ iStrCount++;
+ }
+ }
+}
+
+void CStorageBackupUtil::ReadStringfromStreamL(RDesReadStream& aStream)
+{
+ wstring emptyString;
+
+ /* if only part of the string was read last time,
+ read the remaining and append it to that string. */
+ if (iRemainingString)
+ {
+ // if the whole string cannot be read, read part of it and store it.
+ if (iLenOfString > iBufferSpaceLeft)
+ {
+ LOG(EBackup, EInfo, "Cant read the full string; read only part of it");
+
+ HBufC* data = HBufC::NewL(iBufferSpaceLeft/2+1);
+ TPtr pdata = data->Des();
+
+ aStream.ReadL(pdata, iBufferSpaceLeft/2);
+ iLenOfString -= iBufferSpaceLeft;
+ iBufferSpaceLeft = 0;
+
+ wchar_t* str = desToWstring(pdata);
+ wstring stringData(str);
+ iHalfReadString += stringData;
+
+ delete data;
+ iRemainingString = ETrue;
+ }
+ // else read the complete string
+ else
+ {
+ HBufC* data = HBufC::NewL(iLenOfString/2+1);
+ TPtr pdata = data->Des();
+
+ aStream.ReadL(pdata, iLenOfString/2);
+ iBufferSpaceLeft -= (iLenOfString);
+
+ wchar_t* str = desToWstring(pdata);
+ wstring stringData(str);
+ iHalfReadString += stringData;
+
+ iStringVector.push_back(iHalfReadString);
+
+ delete data;
+ iStrCount--;
+ iRemainingString = EFalse;
+ iHalfReadString = emptyString;
+ }
+ }
+
+ else
+ {
+ iLenOfString = aStream.ReadInt16L();
+ iBufferSpaceLeft -= sizeof(TInt16);
+
+ if (iLenOfString > 0)
+ {
+ // if full string cannot be read, read only part of it.
+ if (iLenOfString > iBufferSpaceLeft)
+ {
+ /* if the stream does not have even part of the string,
+ just set the iRemainingFlag to ETrue so that the
+ string can be read next time. */
+
+ if (iBufferSpaceLeft == 0)
+ {
+ iRemainingString = ETrue;
+ iHalfReadString = emptyString;
+ }
+ // else stream contains part of the stream. Read it
+ else
+ {
+ LOG(EBackup, EInfo, "Cant read the full string; read only part of it");
+
+ HBufC* data = HBufC::NewL(iBufferSpaceLeft/2+1);
+ TPtr pdata = data->Des();
+
+ aStream.ReadL(pdata, iBufferSpaceLeft/2);
+ iLenOfString -= iBufferSpaceLeft;
+ iBufferSpaceLeft = 0;
+
+ wchar_t* str = desToWstring(pdata);
+ wstring stringData(str);
+ iHalfReadString = stringData;
+ delete data;
+ iRemainingString = ETrue;
+ }
+ }
+ // else full string can be read
+ else
+ {
+ HBufC* data = HBufC::NewL(iLenOfString/2+1);
+ TPtr pdata = data->Des();
+
+ aStream.ReadL(pdata, iLenOfString/2);
+ iBufferSpaceLeft -= (iLenOfString);
+
+ wchar_t* str = desToWstring(pdata);
+ wstring stringData(str);
+
+ iStringVector.push_back(stringData);
+ iStrCount--;
+ delete data;
+ }
+ }
+ /* if length of string is 0, do not read anything from the stream;
+ just push an empty string into the vector */
+ else
+ {
+ iStringVector.push_back(emptyString);
+ iStrCount--;
+ }
+ }
+}
+
+
+int CStorageBackupUtil::FillVectorWithStorageData()
+{
+ // get data from storage
+
+ LOG(EBackup, EInfo, "CStorageBackupUtil::FillVectorsWithData");
+
+ auto_ptr<JavaStorage> js(JavaStorage::createInstance());
+ LOG(EBackup, EInfo, "Opening connection to JAVA_DATABASE");
+
+ try
+ {
+ js->open(JAVA_DATABASE_NAME);
+ LOG(EBackup, EInfo, "Opening commection succeeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Opening JAVA_DATABASE failed; %S", jse.toString().c_str());
+ return KErrGeneral;
+ }
+
+ JavaStorageEntry attribute;
+ JavaStorageApplicationEntry_t findPattern;
+ JavaStorageApplicationList_t foundEntries;
+
+
+ // table 1 : Application package table
+ {
+ LOG(EBackup, EInfo, "Read entries from APPLICATION_PACKAGE_TABLE");
+
+ try
+ {
+ js->search(APPLICATION_PACKAGE_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[0] = FillVectorwithAppPackageTableData(foundEntries);
+ foundEntries.clear();
+
+ if (iTableSize[0] == 0)
+ {
+ LOG(EBackup, EInfo, "No data in Storage; So no midlets in system;");
+ return KErrGeneral;
+ }
+ }
+
+
+ // table 2: Application table
+ {
+ LOG(EBackup, EInfo, "Read entries from APPLICATION_TABLE");
+
+ try
+ {
+ js->search(APPLICATION_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[1] = FillVectorwithAppTableData(foundEntries);
+
+ foundEntries.clear();
+ }
+
+ // table 3: Application package attributes table
+
+ /* for this table, since there are very large number of rows,
+ read the data from the table suite-by-suite
+ ie. read entries for the first suite, then read entries for the
+ second suite. This would prevent stack overflow */
+ {
+ LOG(EBackup, EInfo, "Read entries from APPLICATION_PACKAGE_ATTRIBUTES_TABLE");
+
+ int rowCount = 0;
+
+ for (int suiteNumber = 0; suiteNumber < iTableSize[0]; suiteNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[suiteNumber*14]);
+ findPattern.insert(attribute);
+
+ try
+ {
+ js->search(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ rowCount += FillVectorwithAppPackageAttTableData(foundEntries);
+
+ foundEntries.clear();
+ findPattern.clear();
+ }
+ iTableSize[2] = rowCount;
+ }
+
+ // table 4: Midp package table
+ {
+ LOG(EBackup, EInfo, "Read entries from MIDP_PACKAGE_TABLE");
+
+ try
+ {
+ js->search(MIDP_PACKAGE_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[3] = FillVectorwithMidpPackageTableData(foundEntries);
+
+ foundEntries.clear();
+ }
+
+ // table 5: Midp permissions table
+
+ /* for this table, since there are very large number of rows,
+ read the data from the table suite-by-suite
+ ie. read entries for the first suite, then read entries for the
+ second suite. This would prevent stack overflow */
+ {
+ LOG(EBackup, EInfo, "Read entries from MIDP_PERMISSIONS_TABLE");
+
+ int rowCount = 0;
+
+ for (int suiteNumber = 0; suiteNumber < iTableSize[0]; suiteNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[suiteNumber*14]);
+ findPattern.insert(attribute);
+
+ try
+ {
+ js->search(MIDP_PERMISSIONS_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ rowCount += FillVectorwithMidpPermTableData(foundEntries);
+
+ foundEntries.clear();
+ findPattern.clear();
+ }
+ iTableSize[4] = rowCount;
+ }
+
+ // table 6: Midp function group settings table
+ {
+ LOG(EBackup, EInfo, "Read entries from MIDP_FUNC_GRP_SETTINGS_TABLE");
+
+ try
+ {
+ js->search(MIDP_FUNC_GRP_SETTINGS_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[5] = FillVectorwithMidpFuncGrpSetTableData(foundEntries);
+
+ foundEntries.clear();
+ }
+
+ // table 7: push registration table
+ {
+ LOG(EBackup, EInfo, "Read entries from PUSH_REGISTRATIONS_TABLE");
+
+ try
+ {
+ js->search(PUSH_REGISTRATIONS_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[6] = FillVectorwithPushRegTableData(foundEntries);
+
+ foundEntries.clear();
+ }
+
+ // table 8: alarm registration table
+ {
+ LOG(EBackup, EInfo, "Read entries from ALARM_REGISTRATIONS_TABLE");
+
+ try
+ {
+ js->search(ALARM_REGISTRATIONS_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[7] = FillVectorwithAlarmRegTableData(foundEntries);
+
+ foundEntries.clear();
+ }
+
+ // table 9: runtime settings table
+ {
+ LOG(EBackup, EInfo, "Read entries from RUNTIME_SETTINGS_TABLE");
+
+ try
+ {
+ js->search(RUNTIME_SETTINGS_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[8] = FillVectorwithRuntimeSetTableData(foundEntries);
+
+ foundEntries.clear();
+ }
+
+ // table 10: pre-install table
+ {
+ LOG(EBackup, EInfo, "Read entries from PREINSTALL_TABLE");
+
+ try
+ {
+ js->search(PREINSTALL_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[9] = FillVectorwithPreinstallTableData(foundEntries);
+
+ foundEntries.clear();
+ }
+
+ // Data read from JAVA_DATABASE; So close the connection
+ js->close();
+
+ // table 11: ota status table
+ /* Stored in another database called javaotadatabase.
+ so open a new connection to that database. */
+ {
+ LOG(EBackup, EInfo, "Read entries from OTA_STATUS_TABLE");
+
+ auto_ptr<JavaStorage> jos(JavaStorage::createInstance());
+
+ try
+ {
+ jos->open(JAVA_OTA_DATABASE_NAME);
+ ILOG(EBackup, "Opening connection to OTA database succeeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Opening OTA database failed: %s", jse.toString().c_str());
+ return KErrGeneral;
+ }
+
+ try
+ {
+ jos->search(OTA_STATUS_TABLE, findPattern, foundEntries);
+ LOG(EBackup, EInfo, "Search in Java Storage succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Search in Java Storage failed; %s", jse.toString().c_str());
+ jos->close();
+ return KErrGeneral;
+ }
+
+ iTableSize[10] = FillVectorwithOtaStatusTableData(foundEntries);
+
+ foundEntries.clear();
+ jos->close();
+ }
+
+ //################ printing the vectors #############
+ //printVector();
+ //###################################################
+
+ ILOG(EBackup, "Vector filled with data");
+ return KErrNone;
+}
+
+
+int CStorageBackupUtil::WriteDataToStorage()
+{
+ JELOG2(EBackup);
+ ILOG(EBackup, "Create instance of JAVA_DATABASE_NAME and open the database");
+
+ auto_ptr<JavaStorage> js(JavaStorage::createInstance());
+
+ try
+ {
+ js->open(JAVA_DATABASE_NAME);
+ ILOG(EBackup, "Opening database succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Opening database failed: %S", jse.toString().c_str());
+ return KErrGeneral;
+ }
+
+ try
+ {
+ js->startTransaction();
+ ILOG(EBackup, "Transaction started");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "startTransaction() failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ ILOG(EBackup, "Before writing data to storage, existing data must be cleared");
+
+ // call delete * from table one-by-one
+ {
+ JavaStorageApplicationEntry_t emptyEntry;
+
+ try
+ {
+ js->remove(APPLICATION_PACKAGE_TABLE, emptyEntry);
+ js->remove(APPLICATION_TABLE, emptyEntry);
+ js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, emptyEntry);
+ js->remove(MIDP_PACKAGE_TABLE, emptyEntry);
+ js->remove(MIDP_PERMISSIONS_TABLE, emptyEntry);
+ js->remove(MIDP_FUNC_GRP_SETTINGS_TABLE, emptyEntry);
+ js->remove(PUSH_REGISTRATIONS_TABLE, emptyEntry);
+ js->remove(ALARM_REGISTRATIONS_TABLE, emptyEntry);
+ js->remove(RUNTIME_SETTINGS_TABLE, emptyEntry);
+ js->remove(PREINSTALL_TABLE, emptyEntry);
+
+ ILOG(EBackup, "Data removed successfully from table");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Failed during removal of entries from table: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ }
+
+ JavaStorageEntry attribute;
+ JavaStorageApplicationEntry_t insertEntry;
+
+ ILOG(EBackup, "Start transaction for writing into the database");
+
+ int count = 0;
+ // table 1 : Application package table
+ {
+ LOG(EBackup, EInfo, "Writing to APPLICATION_PACKAGE_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[0]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(PACKAGE_NAME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(VENDOR, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(VERSION, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(ROOT_PATH, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(MEDIA_ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(INITIAL_SIZE, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(JAD_PATH, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(JAR_PATH, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(JAD_URL, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(JAR_URL, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(ACCESS_POINT, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(CONTENT_INFO, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(CONTENT_ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(APPLICATION_PACKAGE_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 2: Application table
+ {
+ LOG(EBackup, EInfo, "Writing to APPLICATION_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[1]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(PACKAGE_ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(NAME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(MAIN_CLASS, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(AUTORUN, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(APPLICATION_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 3: Application package attributes table
+ {
+ LOG(EBackup, EInfo, "Writing to APPLICATION_PACKAGE_ATTRIBUTES_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[2]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(NAME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(VALUE, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(TRUSTED, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 4: Midp package table
+ {
+ LOG(EBackup, EInfo, "Writing to MIDP_PACKAGE_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[3]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(TYPE, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(SECURITY_DOMAIN, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(SECURITY_DOMAIN_CATEGORY, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(HASH, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(CERT_HASH, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(RMS, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(VALID_CERTS, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(ON_SCREEN_KEYPAD, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(SECURITY_WARNINGS, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(MIDP_PACKAGE_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 5: Midp permissions table
+ {
+ LOG(EBackup, EInfo, "Writing to MIDP_PERMISSIONS_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[4]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(CLASS, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(NAME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(ACTION, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(FUNCTION_GROUP, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(MIDP_PERMISSIONS_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 6: Midp function group settings table
+ {
+ LOG(EBackup, EInfo, "MIDP_FUNC_GRP_SETTINGS_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[5]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(FUNCTION_GROUP, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(ALLOWED_SETTINGS, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(CURRENT_SETTING, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(BLANKET_PROMPT, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(MIDP_FUNC_GRP_SETTINGS_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 7: push registration table
+ {
+ LOG(EBackup, EInfo, "Writing to PUSH_REGISTRATIONS_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[6]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(URL, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(NAME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(FILTER, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(REGISTRATION_TYPE, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(PUSH_REGISTRATIONS_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 8: alarm registration table
+ {
+ LOG(EBackup, EInfo, "Writing to ALARM_REGISTRATIONS_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[7]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(ALARM_TIME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(ALARM_REGISTRATIONS_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+
+ // table 9: runtime settings table
+ {
+ LOG(EBackup, EInfo, "Writing to RUNTIME_SETTINGS_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[8]; rowNumber++)
+ {
+ attribute.setEntry(EXTENSIONS, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(RUNTIME_SETTINGS_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ // table 10: pre-install table
+ {
+ LOG(EBackup, EInfo, "Writing to PREINSTALL_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[9]; rowNumber++)
+ {
+ attribute.setEntry(NAME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(VENDOR, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(VERSION, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(INSTALL_STATE, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ js->write(PREINSTALL_TABLE, insertEntry);
+ ILOG(EBackup, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+ }
+
+ ILOG(EBackup, "Data written to JAVA_DATABASE; So Commit the transaction and close the database");
+ ILOG(EBackup, "Committing the transaction");
+
+ try
+ {
+ js->commitTransaction();
+ ILOG(EBackup, "Transaction committed successfully");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Committing the transaction failed: %S", jse.toString().c_str());
+ js->close();
+ return KErrGeneral;
+ }
+
+ ILOG(EBackup, "Close the database");
+
+ // close the JAVA_DATABASE
+ js->close();
+
+
+ // table 11: ota status table
+ /* stored in another database called javaotadatabase.
+ so open a new connection to that database */
+
+ {
+ ILOG(EBackup, "Create instance of JAVA_OTA_DATABASE_NAME and open the database");
+ auto_ptr<JavaStorage> jos(JavaStorage::createInstance());
+
+ try
+ {
+ jos->open(JAVA_OTA_DATABASE_NAME);
+ ILOG(EBackup, "Opening database succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Opening database failed: %S", jse.toString().c_str());
+ return KErrGeneral;
+ }
+
+ ILOG(EBackup, "Start a transaction for writing to this database");
+
+ try
+ {
+ jos->startTransaction();
+ ILOG(EBackup, "Transaction started");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "startTransaction() failed: %S", jse.toString().c_str());
+ jos->close();
+ return KErrGeneral;
+ }
+
+ ILOG(EBackup, "Before writing data to this database, existing data must be cleared");
+
+ try
+ {
+ JavaStorageApplicationEntry_t emptyEntry;
+ jos->remove(OTA_STATUS_TABLE, emptyEntry);
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Removing data from OTA database failed: %S", jse.toString().c_str());
+ jos->close();
+ return KErrGeneral;
+ }
+
+ LOG(EBackup, EInfo, "Writing to OTA_STATUS_TABLE");
+
+ for (int rowNumber = 0; rowNumber < iTableSize[10]; rowNumber++)
+ {
+ attribute.setEntry(ID, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(CREATION_TIME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(TYPE, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(OTA_CODE, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(URL, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(LATEST_RETRY_TIME, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ attribute.setEntry(RETRY_COUNT, iStringVector[count++]);
+ insertEntry.insert(attribute);
+
+ try
+ {
+ jos->write(OTA_STATUS_TABLE, insertEntry);
+ LOG(EBackup, EInfo, "Writing to table succeded");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());
+ jos->close();
+ return KErrGeneral;
+ }
+ insertEntry.clear();
+ }
+
+ ILOG(EBackup, "Data written to JAVA_OTA_DATABASE; commit the transaction and close the database");
+ ILOG(EBackup, "Committing the transaction");
+
+ try
+ {
+ jos->commitTransaction();
+ LOG(EBackup, EInfo, "Transaction committed successfully");
+ }
+ catch (JavaStorageException jse)
+ {
+ ELOG1(EBackup, "Committing the transaction failed: %S", jse.toString().c_str());
+ jos->close();
+ return KErrGeneral;
+ }
+
+ LOG(EBackup, EInfo, "Close the database");
+
+ // close the OTA_DATABASE
+ jos->close();
+ }
+
+ LOG(EBackup, EInfo, "Data written to Storage");
+ return KErrNone;
+}
+
+
+int CStorageBackupUtil::FillVectorwithAppPackageTableData(JavaStorageApplicationList_t& foundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = foundEntries.begin(); applications != foundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(PACKAGE_NAME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(VENDOR, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(VERSION, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(ROOT_PATH, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(MEDIA_ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(INITIAL_SIZE, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(JAD_PATH, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(JAR_PATH, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(JAD_URL, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(JAR_URL, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(ACCESS_POINT, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(CONTENT_INFO, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(CONTENT_ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithAppTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(PACKAGE_ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(NAME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(MAIN_CLASS, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(AUTORUN, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithAppPackageAttTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(NAME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(VALUE, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(TRUSTED, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithMidpPackageTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(TYPE, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(SECURITY_DOMAIN, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(SECURITY_DOMAIN_CATEGORY, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(HASH, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(CERT_HASH, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(RMS, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(VALID_CERTS, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(ON_SCREEN_KEYPAD, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(SECURITY_WARNINGS, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithMidpPermTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(CLASS, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(NAME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(ACTION, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(FUNCTION_GROUP, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithMidpFuncGrpSetTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(FUNCTION_GROUP, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(ALLOWED_SETTINGS, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(CURRENT_SETTING, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(BLANKET_PROMPT, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithPushRegTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(URL, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(NAME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(FILTER, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(REGISTRATION_TYPE, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithAlarmRegTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(ALARM_TIME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithRuntimeSetTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(EXTENSIONS, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithPreinstallTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(NAME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(VENDOR, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(VERSION, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(INSTALL_STATE, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+
+int CStorageBackupUtil::FillVectorwithOtaStatusTableData(JavaStorageApplicationList_t& afoundEntries)
+{
+ const wstring emptyString;
+ wstring str;
+
+ JavaStorageEntry attribute;
+
+ /* Initialise Iterators to iterate through all applications
+ matched with search patterns. */
+ JavaStorageApplicationList_t::const_iterator applications;
+ JavaStorageApplicationEntry_t::const_iterator findIterator;
+
+ int rowsCount=0;
+ for (applications = afoundEntries.begin(); applications != afoundEntries.end(); applications++)
+ {
+ attribute.setEntry(ID, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(CREATION_TIME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(TYPE, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(OTA_CODE, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(URL, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(LATEST_RETRY_TIME, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ attribute.setEntry(RETRY_COUNT, L"");
+ str = emptyString;
+ findIterator = (*applications).find(attribute);
+
+ if (findIterator != (*applications).end())
+ {
+ str = (*findIterator).entryValue();
+ }
+ iStringVector.push_back(str);
+
+ rowsCount++;
+ }
+ ILOG1(EBackup, "for loop crossed with i = %d", rowsCount);
+ return rowsCount;
+}
+