/*

* 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; Set state to EAppArc

        aRestoreState = EAppArc;

        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);