/*

* 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:    UString converter implementation class that converts symbian data 

*                types to UString types

*

*/

#include "glxustringconverter.h"

#include "glxmediageneraldefs.h"

#include <AknUtils.h> 

#include <aknlocationed.h>      // CAknLocationEditor

#include <avkon.rsg>

#include <utf.h>                // CnvUtfConverter

#include <osn/osnnew.h>             // for new(EMM) 

#include <StringLoader.h>

#include <glxtracer.h> 

#include <glxmetadatadialog.rsg>

#include <lbsposition.h>        // for TCoordinate

#include <glxsettingsmodel.h>   // For Cenrep Keys

const TInt KBytesInKB = 1024;

const TInt KBytesInMB = 1024 * 1024;

_LIT( KBlankText, " " );

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

// Constructor

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

//

CGlxUStringConverter::CGlxUStringConverter()

    {

    TRACER("CGlxUStringConverter::CGlxUStringConverter()");

    }

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

// Two phase Constructor

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

//

EXPORT_C CGlxUStringConverter* CGlxUStringConverter::NewL()

    {

    TRACER("CGlxUStringConverter::NewL");

    CGlxUStringConverter* self =  CGlxUStringConverter::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// Two phase Constructor

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

//   

CGlxUStringConverter* CGlxUStringConverter::NewLC()

    {

    TRACER("CGlxUStringConverter::NewLC");

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

    CleanupStack::PushL(self );

    return self;

    }

CGlxUStringConverter::~CGlxUStringConverter()

    {

    }

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

// Converts the TDesC into UString type

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

//  

EXPORT_C void CGlxUStringConverter::AsStringL(const TGlxMedia& aMedia, const TMPXAttribute& aAttribute, TInt aFormatString, HBufC*& aString ) const

    {

    TRACER("CGlxUStringConverter::AsStringL");

    const CGlxMedia* media = aMedia.Properties();

    if( media )

        {

        switch( media->AttributeTypeId(aAttribute) )

    		{

    		case EMPXTypeText:

                {

                aString = ( media->ValueText(aAttribute) ).Alloc();

                }

           break;

    		case EMPXTypeTObject:

    			{

    			if( aAttribute == KMPXMediaGeneralDate )

    				{

    				TTime date(0);

    				if( aFormatString == R_QTN_DATE_USUAL_WITH_ZERO )

                        {

                        HBufC* dateString = HBufC::NewLC(KMaxLongDateFormatSpec);

                        TPtr dateStringPtr (dateString->Des());

                        media->GetValueTObject(date,KMPXMediaGeneralDate);

                        HBufC* dateFormat = CCoeEnv::Static()->AllocReadResourceLC

                            ( R_QTN_DATE_USUAL_WITH_ZERO );

                        date.FormatL( dateStringPtr , *dateFormat );

                        CleanupStack::PopAndDestroy(dateFormat);

                        AknTextUtils::LanguageSpecificNumberConversion( dateStringPtr );

                        HBufC* timeString = HBufC::NewLC(KMaxTimeFormatSpec);

                        TPtr timeStringPtr (timeString->Des());

                        media->GetValueTObject(date,KMPXMediaGeneralDate);

                        HBufC* timeFormat = CCoeEnv::Static()->AllocReadResourceLC

                             ( R_QTN_TIME_USUAL_WITH_ZERO );

                        date.FormatL(  timeStringPtr , *timeFormat );

                        CleanupStack::PopAndDestroy(timeFormat);

                        AknTextUtils::LanguageSpecificNumberConversion( timeStringPtr );

                        HBufC* dateAndTime = HBufC::NewLC(dateStringPtr.Length()+timeStringPtr.Length()+1);

                        TPtr dateAndTimePtr (dateAndTime->Des());

                        dateAndTimePtr = dateStringPtr;

                        dateAndTimePtr.Append( KBlankText );

                        dateAndTimePtr.Append(timeStringPtr);

                        aString = dateAndTime->Alloc();                       

                        CleanupStack::PopAndDestroy(dateAndTime);

                        CleanupStack::PopAndDestroy(timeString);

                        CleanupStack::PopAndDestroy(dateString);

                        }

    				else if( aFormatString == R_QTN_TIME_USUAL_WITH_ZERO)

    					{

    					TBuf<20> timeString;

    					media->GetValueTObject(date,KMPXMediaGeneralDate);

    					HBufC* timeFormat = CCoeEnv::Static()->AllocReadResourceLC

    						( R_QTN_TIME_USUAL_WITH_ZERO );

    					date.FormatL(  timeString , *timeFormat );

    					CleanupStack::PopAndDestroy(timeFormat);

    					AknTextUtils::LanguageSpecificNumberConversion( timeString );

    					aString = timeString.Alloc();

    					}

                    else if( aFormatString == R_QTN_DATE_USUAL)

                        {

                        TBuf<20> dateString;

                        media->GetValueTObject(date,KMPXMediaGeneralDate);

                        HBufC* dateFormat = CCoeEnv::Static()->AllocReadResourceLC

                            ( R_QTN_DATE_USUAL );

                        date.FormatL(  dateString , *dateFormat );

                        CleanupStack::PopAndDestroy(dateFormat);

                        AknTextUtils::LanguageSpecificNumberConversion( dateString );

                        aString = dateString.Alloc();

                        }

    				}

    			else if( aAttribute == KMPXMediaGeneralSize )

    				{

                    GetFormattedItemSizeL(*media, aString);

    				}

    			else if( aAttribute == KGlxMediaGeneralLocation )

    				{

    				TCoordinate coordinate;

    				if(aMedia.GetCoordinate( coordinate ))

    					{

    					GetFormatLocationL(coordinate, aString);

    					}

    				else

    				    {

    				    HBufC* locationTextBuf = HBufC::NewLC(1); 

    				    TPtr ptr(locationTextBuf->Des());

    				    _LIT(KFormat," ");

     				    ptr.Append(KFormat);

    				    aString = locationTextBuf->Alloc();

    				    CleanupStack::PopAndDestroy(locationTextBuf);

    				    }

    				}

    			else if( aAttribute == KMPXMediaGeneralDuration )

    				{

    				TReal32 duration( 0 );

    				aMedia.GetDuration( duration );

    				TBuf<20> timeBuf(0);

    				if(duration)

    					{

    					GetFormattedDurationL(duration, aString);	

    					}

				    }

    			else if( aAttribute == KGlxMediaGeneralDimensions )

    				{

    				TSize resolution;

    				if(aMedia.GetDimensions(resolution))

    					{

    					GetFormatResolutionL(resolution, aString);

    					}

    				}

    			else 

    				{

    				// no implementation

    				}

    			}

    		break;

    		default:

    		break;

    		}

        }

    }

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

// Returns the item size in the required format

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

//

void CGlxUStringConverter::GetFormattedItemSizeL(const CGlxMedia& aMedia, HBufC*& aString) const

 	{

 	TRACER("CGlxUStringConverter::GetFormattedItemSizeL");

    TInt size(0);

    if(aMedia.GetValueTObject( size, KMPXMediaGeneralSize ))

        {

		if(size >= KBytesInMB)

            {

            TInt mbSize = size / KBytesInMB ; // Size in MB

        	aString = StringLoader::LoadL(R_QTN_SIZE_MB, mbSize);

            }

        else if(size >= KBytesInKB)

            {

            aString = HBufC::NewL(64);

            TInt kBsize = size / KBytesInKB;  // bytes to kB

            HBufC* textSizeKb = CCoeEnv::Static()->AllocReadResourceLC( R_QTN_SIZE_KB );

            TPtr ptr = aString->Des();

            TPtr sizePtr = textSizeKb->Des();

            StringLoader::Format(ptr,sizePtr, -1, kBsize);

            CleanupStack::PopAndDestroy(textSizeKb);

            }

        else

			{

			HBufC* textSizeB = CCoeEnv::Static()->AllocReadResourceLC( R_QTN_SIZE_B );

			aString = HBufC::NewL(64);

			TPtr ptr = aString->Des();

            TPtr sizePtr = textSizeB->Des();

            StringLoader::Format(ptr, sizePtr, -1, size);

            CleanupStack::PopAndDestroy(textSizeB);

            }

        if(aString)

            {

            TPtr ptr = aString->Des();

            AknTextUtils::LanguageSpecificNumberConversion(ptr);

            }

        }

 	}

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

// Returns the item location in the required format

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

//	

void CGlxUStringConverter::GetFormatLocationL(const TCoordinate& aCoordinate, HBufC*& aString ) const

	{

	TRACER("CGlxUStringConverter::GetFormatLocationL");

    CGlxSettingsModel* settingsModel = CGlxSettingsModel::InstanceL();

    CleanupClosePushL(*settingsModel);

    TBool showGeoCoordinates = settingsModel->ShowGeoCoordinatesInDisplay();

    CleanupStack::PopAndDestroy(settingsModel);  

	if (showGeoCoordinates)

		{

		//Show geocoordinates

		TPosition origin;

		origin.SetCoordinate(aCoordinate.Latitude(),aCoordinate.Longitude());

		HBufC* latBuf = CAknLocationEditor::DisplayableLocationL( origin, CAknLocationEditor::ELatitudeOnly );

		HBufC* longBuf = CAknLocationEditor::DisplayableLocationL( origin, CAknLocationEditor::ELongitudeOnly );

		HBufC* combinedLocationTextBuf = HBufC::NewLC( latBuf->Length() + longBuf->Length() + 2 ); 

		TPtr ptr(combinedLocationTextBuf->Des());

		_LIT(KFormat,", ");

		ptr.Append(*latBuf);

		ptr.Append(KFormat);

		ptr.Append(*longBuf);

	    aString = combinedLocationTextBuf->Alloc();

		CleanupStack::PopAndDestroy(combinedLocationTextBuf);

	    if( latBuf )

	        {

	        delete latBuf;

	        latBuf = NULL;

	        }

	    if( longBuf )

	        {

	        delete longBuf;

	        longBuf = NULL;

	        }

		}

	else

		{

		//Hide geocoordinates

		TBuf<KMaxInfoName> noLocationTextBuf;

		noLocationTextBuf.AppendNum(0);

		noLocationTextBuf.AppendNum(0);

	    aString = noLocationTextBuf.Alloc();

        }

    }

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

// Returns the item duration in the required format

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

//

 void CGlxUStringConverter::GetFormattedDurationL(const TReal& aDuration , HBufC*& aString ) const

 	{

 	TRACER("CGlxUStringConverter::GetFormattedDurationL");

 	TInt resourceId = R_QTN_TIME_DURAT_LONG;

	if( aDuration <= 3600 ) //60 seconds *60 minutes

		{

		// minute:seconds format

		resourceId = R_QTN_TIME_DURAT_MIN_SEC;

		}

	// This class does not have access to a CEikonEnv and hence 

	// pls ignore the code scanner warning - Using CEikonEnv::Static

	HBufC* timeFormat = CEikonEnv::Static()->AllocReadResourceLC( resourceId );

	TTime time( 0 );

	TBuf<20> timeBuf;

	time += TTimeIntervalSeconds ( aDuration );

	time.FormatL( timeBuf , *timeFormat );

    //to convert between arabic-indic digits and european digits.

    //based on existing language setting.

    AknTextUtils::LanguageSpecificNumberConversion(timeBuf);

	CleanupStack::PopAndDestroy(timeFormat);

	aString = timeBuf.Alloc();

 	}

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

// Returns the item resolution in the required format

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

//	

void CGlxUStringConverter::GetFormatResolutionL(const TSize& aSize, HBufC*& aString  ) const

    {

    TRACER("CGlxUStringConverter::GetFormatResolutionL");

    CArrayFix<TInt>* array = new (ELeave) CArrayFixFlat<TInt>(2);

	CleanupStack::PushL(array);

	array->AppendL(aSize.iWidth);

	array->AppendL(aSize.iHeight);

	//@todo: to be included when the metadata dialog's resource file is ready.

    HBufC* formatString = 

    StringLoader::LoadL(R_GLX_METADATA_VIEW_RESOLUTION_DETAIL_NSERIES,*array,CCoeEnv::Static());

	CleanupStack::PopAndDestroy(array);

	aString = formatString->Alloc();

	if( formatString )

	    {

    	delete formatString;

    	formatString = NULL;

	    }

    }