// 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