/*

* Copyright (c) 2005-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:  javaregstore implementation

*

*/

#include <s32file.h>

#include <memory>

#include "driveutilities.h"

#include "javaattributes.h"

#include "javacommonutils.h"

#include "javapropertyarray.h"

#include "javaregconverter.h"

#include "javaregstore.h"

#include "javaregproperty.h"

#include "javaregistrypropertyids.h"

#include "javareguidarrayconv.h"

#include "javastorageexception.h"

#include "javastoragenames.h"

#include "javasymbianoslayer.h"

#include "javauid.h"

#include "logger.h"

#include "midpregistrypropertyids.h"

#include "javareguidarrayconv.h"

using namespace Java::Manager::Registry;

using namespace java::storage;

using namespace java::util;

using namespace std;

// ---------------------------------------------------------------------------

// Constructs a java registry store object.

// ---------------------------------------------------------------------------

CJavaRegStore* CJavaRegStore::NewL()

{

    CJavaRegStore* self = NewLC();

    CleanupStack::Pop(self);

    return self;

}

// ---------------------------------------------------------------------------

// Constructs a java registry store object.

// ---------------------------------------------------------------------------

CJavaRegStore* CJavaRegStore::NewLC()

{

    CJavaRegStore* self = new(ELeave) CJavaRegStore();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

// ---------------------------------------------------------------------------

// Reads properties

// ---------------------------------------------------------------------------

void CJavaRegStore::ReadPropertiesL(

    TUid aUid, CJavaPropertyArray*& aProperties, TBool /*aAllEntries*/)

{

    JELOG(EJavaStorage, "CJavaRegStore::ReadPropertiesL()");

    Uid uid;

    TUidToUid(aUid, uid);

    JavaStorageApplicationEntry_t attributes;

    Java::TJavaRegistryEntryType appType = EGeneralApplication;

    EntryAttributesL(uid, appType, attributes);

    if (0 == attributes.size())

    {

        return;

    }

    PopulatePropertiesL(aProperties, attributes);

    attributes.clear();

    PopulateAppTypePropertiesL(uid, appType, aProperties);

}

// ---------------------------------------------------------------------------

// Get the stored uids for all drives.

// ---------------------------------------------------------------------------

void CJavaRegStore::GetUidsL(RArray<TUid>& aUids)

{

    JELOG(EJavaStorage, "CJavaRegStore::GetUidsL()");

    JavaStorageApplicationList_t apps;

    JavaStorageApplicationEntry_t searchQuery;

    JavaStorageEntry entry;

    entry.setEntry(ID, L"");

    searchQuery.insert(entry);

    entry.setEntry(PACKAGE_ID, L"");

    searchQuery.insert(entry);

    SearchL(APPLICATION_TABLE, searchQuery, apps);

    JavaStorageEntry attribute;

    attribute.setEntry(ID, L"");

    // Add all applications.

    AddUidsL(apps, attribute, aUids);

    attribute.setEntry(PACKAGE_ID, L"");

    // Add all application suites.

    AddUidsL(apps, attribute, aUids);

}

// ---------------------------------------------------------------------------

// CJavaRegStore::FindEntriesL

// ---------------------------------------------------------------------------

void CJavaRegStore::FindEntriesL(

    CJavaPropertyArray& aProperties,

    RArray<TUid>& aFoundUids, TBool /*aAllEntries*/)

{

    JELOG(EJavaStorage, "CJavaRegStore::FindEntriesL()");

    JavaStorageApplicationList_t apps;

    JavaStorageApplicationEntry_t searchQuery;

    JavaStorageEntry attribute;

    for (TInt i = 0; i < aProperties.Count(); i++)

    {

        if (EPropType == aProperties.At(i)->Id())

        {

            TInt32 value = JavaRegConverter::GetTInt(

                               aProperties.At(i)->Value(), 0);

            switch (value)

            {

            case EGeneralPackage:

            case EMidp2MidletSuite:

            {

                attribute.setEntry(PACKAGE_ID, L"");

                searchQuery.insert(attribute);

                SearchL(APPLICATION_TABLE, searchQuery, apps);

                searchQuery.clear();

                AddUidsL(apps, attribute, aFoundUids);

                break;

            }

            case EGeneralApplication:

            case EMidp2Midlet:

            {

                // To check if this is present.

                attribute.setEntry(PACKAGE_ID, L"");

                searchQuery.insert(attribute);

                attribute.setEntry(ID, L"");

                searchQuery.insert(attribute);

                SearchL(APPLICATION_TABLE, searchQuery, apps);

                searchQuery.clear();

                AddUidsL(apps, attribute, aFoundUids);

                break;

            }

            default:

            {

                LOG1(EJavaStorage,

                     EInfo,

                     "Unsupported app type: %d",

                     value);

                break;

            }

            }

        }

        else if (EPropName == aProperties.At(i)->Id()

                 && aProperties.At(i)->Value() != KNullDesC)

        {

            // This is search by NAME and VENDOR pair.

            auto_ptr<HBufC16> tempBuf(HBufC16::NewL(

                                          aProperties.At(i)->Value().Size() + 1));

            TPtr16 tempBufPtr(tempBuf->Des());

            tempBufPtr.Append(aProperties.At(i)->Value());

            wstring propName(desToWstring(tempBufPtr));

            tempBuf.reset(0);

            attribute.setEntry(PACKAGE_NAME, propName);

            searchQuery.insert(attribute);

            TBool found = EFalse;

            TInt index = 0;

            // Search EPropVendor from props.

            for (; index < aProperties.Count(); index++)

            {

                if (aProperties.At(index)->Id() == EPropVendor)

                {

                    found = ETrue;

                    break;

                }

            }

            if (found && aProperties.At(index)->Value() != KNullDesC)

            {

                auto_ptr<HBufC16>tempBuf2(HBufC16::NewL(

                                              aProperties.At(index)->Value().Size() + 1));

                TPtr16 tempBufPtr2(tempBuf2->Des());

                tempBufPtr2.Append(aProperties.At(index)->Value());

                wstring vendorProp(desToWstring(tempBufPtr2));

                tempBuf2.reset(0);

                attribute.setEntry(VENDOR, vendorProp);

                searchQuery.insert(attribute);

                attribute.setEntry(ID, L"");

                searchQuery.insert(attribute);

                SearchL(APPLICATION_PACKAGE_TABLE, searchQuery, apps);

                searchQuery.clear();

                AddUidsL(apps, attribute, aFoundUids);

            }

        }

        else

        {

            LOG1(EJavaStorage,

                 EInfo,

                 "Find by unsupported property: %d",

                 aProperties.At(i)->Id());

        }

    }

}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

CJavaRegStore::~CJavaRegStore()

{

    if (iStorage)

    {

        try

        {

            iStorage->close();

        }

        catch (JavaStorageException& jse)

        {

            ELOG1(EJavaStorage, "Storage close failed %s ",

                  jse.toString().c_str());

        }

        delete iStorage;

        iStorage = NULL;

    }

}

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

CJavaRegStore::CJavaRegStore()

{

}

// ---------------------------------------------------------------------------

// ConstructL

// ---------------------------------------------------------------------------

void CJavaRegStore::ConstructL()

{

    JELOG(EJavaStorage, "CJavaRegStore::ConstructL()");

    try

    {

        iStorage = JavaStorage::createInstance();

        iStorage->open();

    }

    catch (JavaStorageException& aJse)

    {

        ELOG1(EJavaStorage,

              "Cannot create storage: %s", aJse.toString().c_str());

        User::Leave(aJse.mStatus);

    }

}

// ---------------------------------------------------------------------------

// CJavaRegStore::MatchUid

// ---------------------------------------------------------------------------

//

TBool CJavaRegStore::MatchUidL(

    const JavaStorageApplicationList_t& aApps,

    const Uid& aUid,

    Java::TJavaRegistryEntryType& aType) const

{

    JELOG2(EJavaStorage);

    TBool match = EFalse;

    // No applications nor suites to match.

    if (aApps.size()== 0)

    {

        LOG(EJavaStorage, EInfo, "No apps to match");

        return EFalse;

    }

    JavaStorageEntry idQueryEntry;

    idQueryEntry.setEntry(ID, aUid.toString());

    JavaStorageEntry packageIdQueryEntry;

    packageIdQueryEntry.setEntry(PACKAGE_ID, aUid.toString());

    JavaStorageApplicationList_t::const_iterator appIter;

    for (appIter = aApps.begin(); appIter != aApps.end(); ++appIter)

    {

        JavaStorageApplicationEntry_t::const_iterator findIterator

        = (*appIter).find(idQueryEntry);

        if (findIterator != (*appIter).end())

        {

            aType = EMidp2Midlet;

            match = IsPresentL((*appIter));

            break;

        }

        findIterator = (*appIter).find(packageIdQueryEntry);

        if (findIterator != (*appIter).end())

        {

            aType = EMidp2MidletSuite;

            match = IsPresentL((*appIter));

            break;

        }

    }

    return match;

}

// ---------------------------------------------------------------------------

// CJavaRegStore::StorageEntry

// ---------------------------------------------------------------------------

//

void CJavaRegStore::StorageEntryL(

    const Uid& aUid,

    const string& aTableName,

    JavaStorageApplicationEntry_t& aAppEntry) const

{

    try

    {

        iStorage->read(aTableName, aUid, aAppEntry);

    }

    catch (JavaStorageException& jse)

    {

        ELOG1(EJavaStorage, "Read failed: %s ",

              jse.toString().c_str());

        User::Leave(jse.mStatus);

    }

}

// ---------------------------------------------------------------------------

// CJavaRegStore::PopulatePropertiesL

// ---------------------------------------------------------------------------

//

void CJavaRegStore::PopulatePropertiesL(

    CJavaPropertyArray*& aProperties,

    const JavaStorageApplicationEntry_t& aAttrs) const

{

    aProperties = CJavaPropertyArray::NewLC();

    JavaStorageApplicationEntry_t::const_iterator iter;

    for (iter = aAttrs.begin(); iter != aAttrs.end(); ++iter)

    {

        // These are deleted after response is written to the client.

        CJavaProperty* prop = CreatePropertyL(

                                  (*iter).entryName(), (*iter).entryValue());

        if (prop)

        {

            aProperties->Append(prop);

        }

    }

    CleanupStack::Pop(aProperties);

}

// ---------------------------------------------------------------------------

// CJavaRegStore::CreatePropertyL

// ---------------------------------------------------------------------------

//

CJavaProperty* CJavaRegStore::CreatePropertyL(const wstring& aName,

        const wstring& aValue) const

{

    TInt id = KErrNotFound;

    CJavaProperty* prop = NULL;

    if (NAME == aName || PACKAGE_NAME == aName)

    {

        id = EPropName;

    }

    else if (PACKAGE_ID == aName)

    {

        TUid uid;

        java::util::Uid omjUid(aValue);

        TInt err = uidToTUid(omjUid, uid);

        if (KErrNone == err)

        {

            HBufC* intBuf = NULL;  // This is allocated at StoreTIntL

            JavaRegConverter::StoreTIntL(uid.iUid, intBuf);

            CleanupStack::PushL(intBuf);

            prop = CJavaProperty::NewL(EPropInstallPackage, intBuf->Des());

            CleanupStack::PopAndDestroy(intBuf);

        }

        else

        {

            ELOG1(EJavaStorage, "UidToTUid conversion err: %d", err);

        }

        id = KErrNotFound;

    }

    else if (VERSION == aName)

    {

        HBufC* versionBuf = NULL;  // This is allocated at StoreTIntL

        try

        {

            JavaRegConverter::StoreTAppVersionL(

                wstringToAppVersion(aValue), versionBuf);

            CleanupStack::PushL(versionBuf);

            prop = CJavaProperty::NewL(EPropVersion, versionBuf->Des());

            CleanupStack::PopAndDestroy(versionBuf);

        }

        catch (ExceptionBase& e)

        {

            ELOG1WSTR(EJavaStorage,

                      "Version UTF-8 conversion failed: '%s'", aValue);

        }

        id = KErrNotFound;

    }

    else if (VENDOR == aName)

    {

        id = EPropVendor;

    }

    else if (JAR_PATH == aName)

    {

        id = EPropJarPath;

    }

    else if (JAR_URL == aName)

    {

        id = EPropJarUrl;

    }

    else if (ROOT_PATH == aName)

    {

        try

        {

            wstring::size_type start = 0;

            wstring::size_type end = 1;

            char* driveLetter =  JavaCommonUtils::wstringToUtf8(

                                     aValue.substr(start, end));

            TInt driveNumber = -1;

            TInt err = RFs::CharToDrive(driveLetter[0], driveNumber);

            if (KErrNone != err)

            {

                WLOG2(EJavaStorage,

                      "Drive number conversion error: %d, Drive letter: %c",

                      err, driveLetter[0]);

                driveNumber = EDriveC;

            }

            delete[] driveLetter;

            HBufC* intBuf = NULL;  // This is allocated at StoreTIntL

            JavaRegConverter::StoreTIntL(driveNumber, intBuf);

            CleanupStack::PushL(intBuf);

            prop = CJavaProperty::NewL(EPropDrive, intBuf->Des());

            CleanupStack::PopAndDestroy(intBuf);

        }

        catch (ExceptionBase& e)

        {

            ELOG1WSTR(EJavaStorage, "ROOT_PATH utf-8 conversion failed: '%s'", aValue);

        }

        id = KErrNotFound;

    }

    else if (JAD_PATH == aName)

    {

        id = EPropJadPath;

    }

    else if (JAD_URL == aName)

    {

        id = EPropJadUrl;

    }

    else if (INITIAL_SIZE == aName)

    {

        TInt initialSize = JavaCommonUtils::wstringToInt(aValue);

        HBufC* intBuf = NULL;  // This is allocated at StoreTIntL

        JavaRegConverter::StoreTIntL(initialSize, intBuf);

        CleanupStack::PushL(intBuf);

        prop = CJavaProperty::NewL(EPropSize, intBuf->Des());

        CleanupStack::PopAndDestroy(intBuf);

        id = KErrNotFound;

    }

    if (KErrNotFound != id)

    {

        auto_ptr<HBufC> valueBuf(wstringToBuf(aValue));

        prop = CJavaProperty::NewL(id, valueBuf->Des());

    }

    // Ownership is transfered.

    return prop;

}

// ---------------------------------------------------------------------------

// CJavaRegStore::AddUidsL

// ---------------------------------------------------------------------------

//

void CJavaRegStore::AddUidsL(

    const JavaStorageApplicationList_t& aApps,

    const JavaStorageEntry& aEntry,

    RArray<TUid>& aUids) const

{

    JavaStorageApplicationList_t::const_iterator iter;

    for (iter = aApps.begin(); iter != aApps.end(); ++iter)

    {