// Copyright (c) 2002-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:

//

#include <barsread.h>    // TResourceReader

#include <bautils.h>     // BaflUtils

#include "textresolver.h"

#include <errorres.rsg>

#include <uikon/eikdefconst.h>

const TInt KUnknownError( 0 );

const TInt KBlankError( -2 );

const TInt KRIMask(0x00000fff);

_LIT(KErrorResResourceFileName, "z:\\resource\\errors\\ERRORRES.RSC"); 

_LIT(KRDSupport, "c:\\resource\\ErrRD");

_LIT(KTextResolverPanic,   "TextResolver");

GLDEF_C void Panic(TInt aPanic)

	{

    User::Panic(KTextResolverPanic, aPanic);

	}

CTextResolver::CTextResolver()

    {

    }

CTextResolver::CTextResolver(CCoeEnv& aEnv)

    :iCoe(&aEnv)

    {

    }

/**

 * Two-phase constructor method that is used to create a new instance

 * of the CTextResolver class. The implementation uses the passed 

 * CCoeEnv instance to access the resource files.

 *

 * @param aEnv the CCoeEnv instance to be used to access the resource

 * files.

 * @return a pointer to a new instance of the CTextResolver class.

 */

EXPORT_C CTextResolver* CTextResolver::NewL(CCoeEnv& aEnv)

    {

    CTextResolver* self = CTextResolver::NewLC(aEnv);

    CleanupStack::Pop(self);

    return self;

    }

 /**

 * Constructor creates a new instance of CTextResolver. The 

 * implementation uses the passed CCoeEnv instance to access the 

 * resource files. Leaves the object on the cleanup stack.

 *

 * @param aEnv the CCoeEnv instance to be used to access the resource

 * files.

 * @return a pointer to a new instance of the CTextResolver class.

 */

EXPORT_C CTextResolver* CTextResolver::NewLC(CCoeEnv& aEnv)

    {

    CTextResolver* self = new (ELeave) CTextResolver(aEnv);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

 /**

 * Constructor creates a new instance of CTextResolver. Resource files 

 * are accessed through the RResourceFile API.

 *

 * @return a pointer to a new instance of the CTextResolver class.

 */

EXPORT_C CTextResolver* CTextResolver::NewL()

    {

    CTextResolver* self = CTextResolver::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

 /**

 * Constructor creates a new instance of CTextResolver.Resource files 

 * are accessed through the RResourceFile API. Leaves the object on 

 * the cleanup stack.

 *

 * @return a pointer to a new instance of the CTextResolver class.

 */

EXPORT_C CTextResolver* CTextResolver::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

//

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

// CTextResolver::ConstructL

//

// Symbian OS default constructor, initializes variables and cache 

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

//

void CTextResolver::ConstructL()

    {

    // if no coe is present, connect new filesession.

    if (!iCoe)

    	{

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

		TFileName resFile(KErrorResResourceFileName);

		BaflUtils::NearestLanguageFile(iFs, resFile);

		iResFile.OpenL(iFs, resFile);

    	}

    iRDSupport = BaflUtils::FileExists(iCoe ? iCoe->FsSession() : iFs, KRDSupport);     

    }

/** 

* Destructor 

*/

EXPORT_C CTextResolver::~CTextResolver()

    {

    Reset();

    iResFile.Close();

    // if no coe is present, close filesession.

    if (!iCoe)

        iFs.Close();   

    delete iTitleText;

    delete iTextBuffer;

    delete iContextSeparator;

    }

/**

* Resolves the given error code and returns the error text for the

* resolved error. Resolved text can be of any length. This version 

* is for "normal" use.

*

* @param aError The error code to be resolved.

* @param aContext Optional context for error numbers. If the aContext 

* parameter is not passed to the function, it uses the default value

* ECtxAutomatic. 

* @return the error text for the resolved error. "System error" (in 

* English localisation) is returned when error code is not known. For 

* unknown errors blank error flag (flags are defined in 

* textresolver.hrh) is also set to hide errors without proper 

* explanation. There is no limit on how long the resolved string

* can be.

*/

EXPORT_C const TDesC& CTextResolver::ResolveErrorString(TInt aError, TErrorContext aContext)

    {

    TUint flags(0);

    TInt id(0);

	return ResolveErrorString(aError,id,flags,aContext);

	}

/**

* Resolves the given error code and returns the error text for the

* resolved error. Resolved text can be of any length. This version

* is for advanced use

*

* @param aError The error code to be resolved.

* @param aTextId ID of the returned text.

* @param aFlags The priority of the returned error. The priority is 

* defined by the this module! Flags are defined in textresolver.hrh.

* @param aContext Optional context for error numbers. If the aContext 

* parameter is not passed to the function, it uses the default value

* ECtxAutomatic. 

* @return the error text for the resolved error. "System error" (in 

* English localisation) is returned when error code is not known. For 

* unknown errors blank error flag (flags are defined in 

* textresolver.hrh) is also set to hide errors without proper 

* explanation. There is no limit on how long the resolved string 

* can be.

*/

EXPORT_C const TDesC& CTextResolver::ResolveErrorString(TInt aError, TInt& aTextId, TUint& aFlags, TErrorContext aContext)

    {

    aFlags = 0;

    if (iCoe)	// Use the resource loaded using the CCoeEnv to read the resource file

    	{

	    TRAPD(err, DoResolveErrorStringL(aError, aTextId, aFlags));

		if (err)

			{

			if ((!AddContextAndSeparator(aContext)))

				{

				// Even the resource file opening failed, return OOM flag

				aFlags |= EErrorResOOMFlag;

				return KNullDesC;

				}

			return *iTextBuffer;

			}            

		if(aFlags&ETextResolverUnknownErrorFlag)	// Error code not supported. No error text found.

	        {

	        // Error is not recognised 

	        aTextId = R_ERROR_RES_GENERAL;	// Read and return an "unknown error" text from the

	        								// Nokia-specific version of the errorres.rss file

	      	TPtr appTextPtr = iTitleText->Des();

	      	TPtr textPtr = iTextBuffer->Des();

	      	iCoe->ReadResourceL(appTextPtr, R_BASE);

	      	iCoe->ReadResourceL(textPtr, R_ERROR_RES_GENERAL);

	        }

		}

	else	// No CCoeEnv available

		{

		aTextId = 0;

        TRAPD(err, DoRawReadOfSystemErrorResourcesToArraysL(aError, aTextId));

        if(err)

            {

            // Cleaning needed since object not destroyed

            Reset();

            if (aTextId != R_ERROR_RES_NO_MEMORY || !AddContextAndSeparator(aContext))

                {

                // Even the resource file opening failed, return OOM flag

                aFlags |= EErrorResOOMFlag;

                return KNullDesC;

                }

            return *iTextBuffer;

            }            

        aTextId = ResourceForError(aError);

        switch (aTextId)

            {

            case KBlankError:

                {

                aFlags |= ETextResolverBlankErrorFlag;

                break;

                }

            case KUnknownError:

                {

                // Error is not recognised 

                aTextId = R_ERROR_RES_GENERAL;

				delete iTitleText;

                iTitleText = AllocReadUnicodeString(iResFile, R_BASE);

                aFlags |= ETextResolverUnknownErrorFlag;

                // No break here; Fall through to default case to resolve text for the general error

                }

            default:    

                {

                // --- Error recognised by the resolver, so get the text ---

				delete iTextBuffer;

                iTextBuffer = AllocReadUnicodeString(iResFile, aTextId);

                break;

                }

            };       

        }       

	if(aFlags&ETextResolverBlankErrorFlag)	// Error code supported, but no error text found.

		{

		delete iTextBuffer;

		iTextBuffer = NULL;				// Return no error text at all	

		}

    if (!AddContextAndSeparator(aContext))

		{

		aFlags |= EErrorResOOMFlag;

		return KNullDesC;

		}

    if (iRDSupport && iTextBuffer) 

        {

        HBufC* tempBuffer = iTextBuffer->ReAlloc(iTextBuffer->Length()+14);

        // if allocation succeeds, append error id. Otherwise iTextBuffer stays as it is

        if (tempBuffer)

            {

            iTextBuffer = tempBuffer;

            iTextBuffer->Des().Append(' ');

            iTextBuffer->Des().Append('(');

            iTextBuffer->Des().AppendNum(aError);

            iTextBuffer->Des().Append(')');

            }

        }

	else if (aFlags & ETextResolverUnknownErrorFlag)

		{ // We hide the errors we cannot give proper explanation, 

		  //i.e. "System Error" will not be shown.

		aFlags |= ETextResolverBlankErrorFlag;	

        }

    if (iTextBuffer)

        return *iTextBuffer;

    else

        return KNullDesC;

    }

TInt CTextResolver::ResourceForError(TInt aError)

    {

    ASSERT(!iCoe);

    const TInt errorCount = iStartError->Count();

    delete iTitleText;

    iTitleText = NULL;

    for (TInt cc = 0; cc < errorCount; ++cc)

        {

        const TInt starterror = (*iStartError)[cc];

        const TInt endError = starterror-(*iErrorTexts)[cc]->Count()+1;

        if (aError >= endError && aError <= starterror)

        	{

	        ASSERT(!iTitleText);

	        iTitleText = AllocReadUnicodeString(iResFile, (*iAppTexts)[cc]);

	        const TInt errorIndex = -(aError-starterror);

	        const TInt flags = (*iFlags)[cc]->At(errorIndex);

	        if (flags & ETextResolverPanicErrorFlag)

	            {

	            // --- Some errors are never meant to get to the UI level ---

	            // --- Those of them that do, result in a panic ---

	            Panic(aError);

	            }

	        else if (flags & ETextResolverBlankErrorFlag)

	            {

	            // --- Error code can be ignored from the users' perspective ---

	            // --- Return blank error text ---

	            return KBlankError;

	            }

	        else if (flags & ETextResolverUnknownErrorFlag)

	            {

	            // --- Error not recognised by TextResolver ---

	            // --- Will be passed on to UIKON for interpretation ---

	            return KUnknownError;

	            }

	        return (*iErrorTexts)[cc]->At(errorIndex); 

        	}

        }

   return KUnknownError;     

   }

/**

Read the system error texts from errorres.rss only, without using the Uikon CEikErrorResolver.

This will not pick up any appliation specific errors.

*/

void CTextResolver::DoRawReadOfSystemErrorResourcesToArraysL(TInt& aError, TInt& aTextId)

    {

    ASSERT(!iCoe);

    TResourceReader reader;

    ReadLocalizedSeparatorCharacterFromResourceAndPrepareResourceReaderLC(reader);

    // Lets handle KErrNoMemory as a special case, this this way we can maybe avoid extra "Resolving Errors"

    if (aError == KErrNoMemory) 

        {

        ASSERT(!iTextBuffer && !iTitleText);

		aTextId = R_ERROR_RES_NO_MEMORY;

		iTextBuffer = AllocReadUnicodeString(iResFile, aTextId);

		iTitleText = AllocReadUnicodeString(iResFile, R_BASE);

        User::Leave(KErrNoMemory);

        }

	if(iStartError && iErrorTexts && iFlags && iAppTexts)

		{

		CleanupStack::PopAndDestroy(); // rBuffer

		return;	// Already all done

		}

	// The resource data is used differenciate between the old and new resource formats 

	// (i.e, resources using title text and one's without using title text)

	// This API only support the new format, so just check that it is on the new format

    const TInt dummy = reader.ReadInt16();

    const TInt version = reader.ReadInt16();

    __ASSERT_ALWAYS(dummy == 0 && version == 2, User::Leave(KErrNotSupported));

    // Read into the error arrays

    const TInt arrayCount = reader.ReadInt16();

    ASSERT(!iStartError && !iErrorTexts && !iFlags && !iAppTexts);

    iStartError = new(ELeave) CArrayFixFlat<TInt>(arrayCount);

    iErrorTexts = new(ELeave) CArrayPtrSeg<CErrorResourceIdArray>(arrayCount);

    iFlags = new(ELeave) CArrayPtrSeg<CErrorResourceFlagArray>(arrayCount);

    iAppTexts = new(ELeave) CArrayFixFlat<TInt>(arrayCount);

    for (TInt cc = 0; cc < arrayCount; ++cc)

        {

        // Read in error array

        iAppTexts->AppendL(reader.ReadInt32()); // Application indicators  

        iStartError->AppendL(reader.ReadInt32());

        const TInt listId = reader.ReadInt32();

        TResourceReader reader2;

        HBufC8* rBuffer = iResFile.AllocReadL(listId & KRIMask); // Remove offset from id

        reader2.SetBuffer(rBuffer);

        CleanupStack::PushL(rBuffer);

        const TInt count = reader2.ReadInt16();

        CArrayFixFlat<TInt>* array = new(ELeave) CErrorResourceIdArray(count);

        CleanupStack::PushL(array);

        CArrayFixFlat<TInt>* flagarray = new(ELeave) CErrorResourceFlagArray(count);

        CleanupStack::PushL(flagarray);

        for (TInt dd = 0; dd < count; ++dd)

            {                   

            const TInt flags = reader2.ReadInt8();

            flagarray->AppendL(flags);

            // Append resource id for this error text

            array->AppendL(reader2.ReadInt32());

            }

        iFlags->AppendL(flagarray);

        CleanupStack::Pop(flagarray); 

        iErrorTexts->AppendL(array);

        CleanupStack::Pop(array);

        CleanupStack::PopAndDestroy(rBuffer);

        }

    CleanupStack::PopAndDestroy(); // reader's rBuffer

    }

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

// CTextResolver::Reset()

//

// Reset the member variables

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

//

void CTextResolver::Reset()

    {

    if (iBaseResourceFileOffset)

        {

        iCoe->DeleteResourceFile(iBaseResourceFileOffset);

        iBaseResourceFileOffset = 0;

        }

    if (iErrorTexts)

        {

        iErrorTexts->ResetAndDestroy();

        delete iErrorTexts;

        iErrorTexts = NULL;

        }

    if (iFlags)

        {

        iFlags->ResetAndDestroy();

        delete iFlags;

        iFlags = NULL;

        }

    delete iStartError;

    iStartError = NULL;

    delete iAppTexts;   

    iAppTexts = NULL;

    }

/**

ErrorResolver resource files in the ?:/resource/errors/ folder must always begin with

an array of error texts. The Nokia-specific version of the errorres.rss file also 

contains the localized titel/text separator character at the end of the file.

This method reads the separator character from file using the CCoeEnv provided.

*/

void CTextResolver::ReadLocalizedSeparatorCharacterFromResourceL(CCoeEnv& aCoeEnv)

	{

	ASSERT(&aCoeEnv);

	if (!iBaseResourceFileOffset)

    	{

    	TFileName filename(KErrorResResourceFileName);

    	BaflUtils::NearestLanguageFile(aCoeEnv.FsSession(), filename);

    	iBaseResourceFileOffset = aCoeEnv.AddResourceFileL(filename);

		ASSERT(!iContextSeparator);

		iContextSeparator = aCoeEnv.AllocReadResourceL(R_LOCALIZED_CONTEXT_SEPARATOR);

		}

	}

/**

ErrorResolver resource files in the ?:/resource/errors/ folder must always begin with

an array of error texts. The Nokia-specific version of the errorres.rss file also 

contains the localized titel/text separator character at the end of the file.

This method reads the separator character from file WITHOUT using a CCoeEnv.

*/

void CTextResolver::ReadLocalizedSeparatorCharacterFromResourceAndPrepareResourceReaderLC(TResourceReader& aResReader)

    {

    ASSERT(!iCoe);

    ASSERT(!iBaseResourceFileOffset);

    HBufC8* rBuffer = iResFile.AllocReadL(R_ERROR_RES_BASE_LIST & KRIMask); // Remove offset from id

    aResReader.SetBuffer(rBuffer);        

    CleanupStack::PushL(rBuffer);

    if(!iContextSeparator)

    	iContextSeparator = AllocReadUnicodeString(iResFile, R_LOCALIZED_CONTEXT_SEPARATOR);

    // Leave rBuffer on CleanupStack

    }

// returns NULL if out of memory

HBufC* CTextResolver::AllocReadUnicodeString(RResourceFile& aResFile, TInt aTextId)

    { 

    // Reading Unicode string w/o CCoe

    HBufC8* tempBuffer = NULL;

    HBufC* retBuffer = NULL;

    TRAPD(err, tempBuffer = aResFile.AllocReadL((KRIMask & aTextId))); // Remove offset from id

    if (!err)

        {

        __ASSERT_DEBUG((tempBuffer->Length()%2)==0,Panic(aTextId));

        // do bitwise shift to halve the length for mapping the tempBuffer to unicode.

        TInt newLen = tempBuffer->Length()>>1;

        TPtrC tempPointer((TText*)tempBuffer->Ptr(), newLen);

        retBuffer = tempPointer.Alloc();

        delete tempBuffer;

        }

    return retBuffer;

    }

TBool CTextResolver::AddContextAndSeparator(TErrorContext aContext)

    {

    TBool retval(EFalse); 

    if (iTextBuffer && iTitleText && iContextSeparator) // If we got all the parts we need...

        {

        //... then put them together according to the aContext argument

        // Context checked after validity of string buffers is checked, 

        // because EFalse return value is required if any of those is NULL.

        if (aContext == ECtxNoCtxNoSeparator)

            retval = ETrue;

        else

            {

            HBufC* tempBuffer = iTextBuffer->ReAlloc(iTextBuffer->Length()+iContextSeparator->Length()+iTitleText->Length()+1);

            // If allocation succeeds, insert context. Otherwise iTextBuffer stays as it is.

            if (tempBuffer)

                {

                iTextBuffer = tempBuffer;

				// Add the title ("context") text and separator before the error text

               	_LIT(KNewLineChar, "\n");

                iTextBuffer->Des().Insert(0, KNewLineChar);            

                iTextBuffer->Des().Insert(0, *iContextSeparator);

                if (aContext != ECtxNoCtx)

                    iTextBuffer->Des().Insert(0,*iTitleText);

                retval = ETrue;

                }

            }

        }

    return retval;

    }

void CTextResolver::AllocBuffersL()

	{

	delete iTitleText;

	iTitleText = NULL;

	delete iTextBuffer;

	iTextBuffer = NULL;

	iTitleText = HBufC::NewL(KEikErrorResolverMaxTextLength);

    iTextBuffer = HBufC::NewL(KEikErrorResolverMaxTextLength);

	}

void CTextResolver::DoResolveErrorStringL(TInt aError, TInt& aTextId, TUint& aFlags)

	{

	ASSERT(iCoe);

	AllocBuffersL();

   	TPtr errTextPtr = iTextBuffer->Des();

	TPtr errTitlePtr = iTitleText->Des();

    CEikonEnv::TErrorValidity errValidity = static_cast<CEikonEnv*>(iCoe)->DoGetErrorTextAndTitle(errTextPtr, aError, aTextId, aFlags, errTitlePtr, ETrue);

    if (errValidity == CEikonEnv::EErrorNumInvalid)

    	Panic(aError);

	// If either the iTextBuffer or iTitleText buffers were too small, 

	// they will contain the required length coded as digits into the buffer

	TLex sizeRealloc(*iTextBuffer);

    TInt sizeRequiredForTextBuffer = 0;

    TInt sizeRequiredForTitleBuffer = 0;

    // Try reading the size required, if any

    sizeRealloc.Val(sizeRequiredForTextBuffer);

    sizeRealloc = *iTitleText;

    sizeRealloc.Val(sizeRequiredForTitleBuffer);

    // If sizes were found, realloc and get the error text again

    if (sizeRequiredForTextBuffer || sizeRequiredForTitleBuffer)	

    	{	

		if (sizeRequiredForTextBuffer)

			{

			delete iTextBuffer;

			iTextBuffer = NULL;

			iTextBuffer = HBufC::NewL(sizeRequiredForTextBuffer);

			}

		if (sizeRequiredForTitleBuffer)

			{

			delete iTitleText;

			iTitleText = NULL;

			iTitleText = HBufC::NewL(sizeRequiredForTitleBuffer);

			}

	   	TPtr errTextPtr(iTextBuffer->Des());

		TPtr errTitlePtr(iTitleText->Des());

		errValidity = static_cast<CEikonEnv*>(iCoe)->DoGetErrorTextAndTitle(errTextPtr, aError, aTextId, aFlags, errTitlePtr, ETrue);

		if (!iTextBuffer->Length())

			{

			delete iTextBuffer;

			iTextBuffer = NULL;

			}

    	}

    ReadLocalizedSeparatorCharacterFromResourceL(*iCoe);

	}

//  End of File