/*

* 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:   This class caches resource strings

*

*/

#include <glxlog.h>

#include <barsc.h>

#include <data_caging_path_literals.hrh>

#include <bautils.h>

#include <glxtracer.h>

#include "glxstringcache.h"

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

// NewL

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

//

CGlxStringCache::CGlxStringItem* CGlxStringCache::CGlxStringItem::NewL(TInt aId, HBufC* aString)

    {

    CGlxStringItem* self = new (ELeave) CGlxStringItem(aId);

    CleanupStack::PushL(self);

    self->ConstructL(aString);

    CleanupStack::Pop(self);

    return self;

    }

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

// ConstructL

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

//

void CGlxStringCache::CGlxStringItem::ConstructL(HBufC* aString)

    {

    if (NULL == aString)

        {

        User::Leave(KErrArgument);

        }

    iString = (*aString).AllocL();

    }

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

// Constructor

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

//

CGlxStringCache::CGlxStringItem::CGlxStringItem(TInt aId)

: iId(aId)

    {

    }

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

// Destructor

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

//

CGlxStringCache::CGlxStringItem::~CGlxStringItem()

    {

    delete iString;

    }

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

// GetId

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

//

TInt CGlxStringCache::CGlxStringItem::GetId() const

    {

    return iId;

    }

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

// GetString

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

//

HBufC* CGlxStringCache::CGlxStringItem::GetString()

    {

    return iString;

    }

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

// NewL

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

//

EXPORT_C CGlxStringCache* CGlxStringCache::NewL()

	{

	CGlxStringCache* self = new(ELeave) CGlxStringCache;

	return self;

	}

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

// Constructor

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

//

CGlxStringCache::CGlxStringCache()

    {

    TRACER("CGlxStringCache::CGlxStringCache()");

    iResourceFileName.Zero();

    }

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

// Destructor

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

//

CGlxStringCache::~CGlxStringCache()

    {

    TRACER("CGlxStringCache::~CGlxStringCache()");

    iStringCache.ResetAndDestroy();

    }

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

// Count

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

//

TInt CGlxStringCache::Count()

    {

    TRACER("TInt CGlxStringCache::Count()");

    return iStringCache.Count();

    }

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

// Find

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

//

HBufC* CGlxStringCache::FindL(TInt aId)

    {

    TRACER("HBufC* CGlxStringCache::FindL(TInt aId)");

    // Create a TIdentityRelation to be used in the Find

    TIdentityRelation<CGlxStringCache::CGlxStringItem> match(&MatchById);

    // Create a dummy string item with the correct id to use in the find

    CGlxStringItem* dummyItem = new (ELeave) CGlxStringItem(aId);

    // Call Find

    TInt index = iStringCache.Find(dummyItem, match);

    // delete the dummy item

    delete dummyItem;

    if (KErrNotFound != index)

        {

        // The string was found so create a copy and pass to caller

        CGlxStringItem* item = iStringCache[index];

        return item->GetString()->Des().AllocL();

        }

    // String was not found    

    return NULL;

    }

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

// InsertL

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

//

void CGlxStringCache::InsertL(TInt aId, HBufC* aString)

    {

    TRACER("void CGlxStringCache::InsertL(TInt aId, HBufC* aString)");

    // Create a TLinearOrder to be used in the InsertInOrder

    TLinearOrder<CGlxStringCache::CGlxStringItem> orderer(&OrderById);

    // Create the string item

    CGlxStringItem* item = CGlxStringItem::NewL(aId, aString);

    // attempt to insert it

    TInt err = iStringCache.InsertInOrder(item, orderer);

    switch (err)

        {

    case KErrNone:

        // Do nothing as item has been inserted into cache

        break;

    case KErrAlreadyExists:

        // This is not an error, but we must tidy up

        delete item;

        break;

    default:

        // We have an error

        delete item;

        User::Leave(err);

        break;

        }

    }

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

// Compares two Id's by subtraction

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

//

TInt CGlxStringCache::OrderById(const CGlxStringCache::CGlxStringItem& aItem1, const CGlxStringCache::CGlxStringItem& aItem2)

    {

    TRACER("TInt CGlxStringCache::OrderById()");

    return aItem1.GetId() - aItem2.GetId();

    }

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

// Compares two Id's logical equality

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

//

TBool CGlxStringCache::MatchById(const CGlxStringCache::CGlxStringItem& aItem1, const CGlxStringCache::CGlxStringItem& aItem2)

    {

    TRACER("TBool CGlxStringCache::MatchById()");

    return aItem1.GetId() == aItem2.GetId();

    }

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

// Load the String

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

//    

EXPORT_C HBufC* CGlxStringCache::LoadLocalizedStringLC(const TDesC& aResourceFile, const TInt aResourceId)

    {

    TRACER("HBufC* CGlxCollectionPluginBase::LoadLocalizedStringLC()");

    HBufC* string = NULL;

    TFileName resourceFile;

    resourceFile.Copy(aResourceFile);

    TRAPD(err, string = LoadLocalizedStringFromDriveL(resourceFile, aResourceId));

    switch (err)

        {

        case KErrNone:

            break;

        case KErrNotFound:

            {

            // Could not find resource file on drive z so try on drive c

            _LIT(KCDrive,"c");

            resourceFile.Copy(KCDrive);

            resourceFile.Append(aResourceFile.Mid(1));

            string = LoadLocalizedStringFromDriveL(resourceFile, aResourceId);

            }

            break;

        default:

            {

            GLX_DEBUG2("LEAVING LoadLocalizedStringLC with %d", err);

            User::Leave(err);

            }

            break;

        }

    CleanupStack::PushL(string);

    return string;

    }

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

// Loads the String from a drive

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

//    

HBufC* CGlxStringCache::LoadLocalizedStringFromDriveL(const TDesC& aResourceFile, const TInt aResourceId)

    {

    TRACER("HBufC* CGlxCollectionPluginBase::LoadLocalizedStringFromDriveL()");

    HBufC* string = NULL;

	if (NULL != (string = FindL(aResourceId)))

		{

		// String has been cached to return it

		return string;

		}

    // The string has not been cached to read from resource file

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    // find out if the resource name file has been cached

    TBool resoureFileNameCached = (0 != iResourceFileName.Length());

    TFileName resFile;

    if (resoureFileNameCached)

        {

        // Use cached resource file name

        resFile.Copy(iResourceFileName);

        }

    else

        {

        // Caluculate the path and language extension

        TParse parse;

        parse.Set( aResourceFile, &KDC_ECOM_RESOURCE_DIR, NULL );

        resFile.Copy(parse.FullName());

    	TLanguage language = ELangNone;

    	BaflUtils::NearestLanguageFile( fs, resFile, language);

    	// Do not cache the file name here as it could be the wrong drive

    	// causing a leave later

        }

    RResourceFile resourceFile; 

    resourceFile.OpenL(fs, resFile);

    CleanupClosePushL(resourceFile);

    resourceFile.ConfirmSignatureL(0);          // must use BA_RSS_SIGNATURE in resource file (not RSS_SIGNATURE).

    TResourceReader resReader;

    HBufC8* buf = resourceFile.AllocReadLC( aResourceId ); 

    resReader.SetBuffer( buf );

    string  = resReader.ReadHBufCL();

    CleanupStack::PopAndDestroy( buf );

    // We have succesfully read from the resource so 

    // check to see if we need to cache the file name

    if (!resoureFileNameCached)

        {

        // Cache the resource file name

        iResourceFileName.Copy(resFile);

        }

    CleanupStack::PopAndDestroy( &resourceFile );

    CleanupStack::PopAndDestroy( &fs );

    CleanupStack::PushL(string);    

    InsertL(aResourceId, string); // InsertL won't create duplicates

    CleanupStack::Pop(string);

    return string;

    }