/*
* 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:  javaregistry implementation
 *
*/


#include "javaregistry.h"
#include "javaregistryapplicationentry.h"
#include "javaregistryentry.h"
#include "javaregistrypackageentry.h"
#include "logger.h"
#include "writeablejavaregistry.h"
#include "writeablejavaregistryentry.h"

using namespace Java;
using namespace Java::Manager::Registry;
// ============================ MEMBER FUNCTIONS ==============================

// ---------------------------------------------------------------------------
// CJavaRegistry::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CJavaRegistry* CJavaRegistry::NewL()
{
    JELOG2(EJavaStorage);
    LOG(EJavaStorage, EInfo, "CJavaRegistry::NewL");

    CJavaRegistry* self = CJavaRegistry::NewLC();
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
// CJavaRegistry::NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CJavaRegistry* CJavaRegistry::NewLC()
{
    JELOG2(EJavaStorage);
    LOG(EJavaStorage, EInfo, "CJavaRegistry::NewLC");

    CJavaRegistry* self = new(ELeave) CJavaRegistry();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
}

// ---------------------------------------------------------------------------
// CJavaRegistry::RegistryEntryExistsL
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CJavaRegistry::RegistryEntryExistsL(const TUid& aUid) const
{
    return iJavaReg->RegistryEntryExistsL(aUid);
}

// ---------------------------------------------------------------------------
// CJavaRegistry::GetRegistryEntryUidsL
// ---------------------------------------------------------------------------
//
EXPORT_C void CJavaRegistry::GetRegistryEntryUidsL(RArray<TUid>& aUids) const
{
    iJavaReg->GetRegistryEntryUidsL(aUids);
}

// ---------------------------------------------------------------------------
// CJavaRegistry::GetRegistryEntryUidsL
// ---------------------------------------------------------------------------
//
EXPORT_C void CJavaRegistry::GetRegistryEntryUidsL(
    TJavaRegistryEntryType aType, RArray<TUid>& aUids) const
{
    JELOG2(EJavaStorage);
    iJavaReg->GetRegistryEntryUidsL(aType, aUids);
}

// ---------------------------------------------------------------------------
// CJavaRegistry::RegistryEntryL
// ---------------------------------------------------------------------------
//
EXPORT_C CJavaRegistryEntry* CJavaRegistry::RegistryEntryL(
    const TUid& aUid) const
{
    JELOG2(EJavaStorage);
    if (0 == aUid.iUid)
    {
        WLOG(EJavaStorage,
             "Can't find entry for uid 0, returning NULL.");
        return NULL;
    }

    CWriteableJavaRegistryEntry* writableEntry
    = iJavaReg->RegistryEntryL(aUid);

    if (writableEntry == NULL)
    {
        WLOG(EJavaStorage,
             "Can't find entry for the given uid, returning NULL.");
        return NULL;
    }

    CleanupStack::PushL(writableEntry);

    CJavaRegistryEntry* regEntry = NULL;
    TJavaRegistryEntryType entryType = writableEntry->Type();

    if (EGeneralPackage <= entryType && entryType < EGeneralApplication)
    {
        CWriteableJavaRegistryPackageEntry* writablePackageEntry
        = (CWriteableJavaRegistryPackageEntry*) writableEntry;

        regEntry = new(ELeave)
        CJavaRegistryPackageEntry(writablePackageEntry);
        // pointer ownership passed over
        LOG(EJavaStorage, EInfo, "PackageEntry created");
    }
    else if (EGeneralApplication <= entryType)
    {
        CWriteableJavaRegistryApplicationEntry* writableAppEntry
        = (CWriteableJavaRegistryApplicationEntry*) writableEntry;

        regEntry = new(ELeave)
        CJavaRegistryApplicationEntry(writableAppEntry);
        // pointer ownership passed over
        LOG(EJavaStorage, EInfo, "ApplicationEntry created");
    }
    else
    {
        ELOG1(EJavaStorage, "Invalid type, returning NULL: %d", entryType);
        CleanupStack::PopAndDestroy(writableEntry);
        return NULL;
    }

    CleanupStack::Pop(writableEntry);
    return regEntry;
}

// ---------------------------------------------------------------------------
// CJavaRegistry::~CJavaRegistry
// ---------------------------------------------------------------------------
//
CJavaRegistry::~CJavaRegistry()
{
    JELOG2(EJavaStorage);
    if (iJavaReg)
    {
        delete iJavaReg;
        iJavaReg = NULL;
    }
}

// ---------------------------------------------------------------------------
// CJavaRegistry::CJavaRegistry
// ---------------------------------------------------------------------------
//
CJavaRegistry::CJavaRegistry()
{
}

// ---------------------------------------------------------------------------
// CJavaRegistry::ConstructL
// ---------------------------------------------------------------------------
//
void CJavaRegistry::ConstructL()
{
    JELOG2(EJavaStorage);
    iJavaReg = CWriteableJavaRegistry::NewL(EFalse);
}