/*

* Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:    Utility class and constants used by Iptv application.*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32debug.h>

#include <f32file.h>    // RFs

#include <apgcli.h>     // RApaLsSession

#include <s32mem.h>

#include <centralrepository.h>

#include <pathinfo.h> 

//#include <oem/mplayerconstants.h> // Some Mime types used by player.

#include <bautils.h>

#include <bldvariant.hrh>

#include "CIptvUtil.h"

#include "IptvDebug.h"

#include <WlanCdbCols.h>

#include "CIptvDriveMonitor.h"

#include "IptvExternalFolderInfo.h"

// CONSTANTS

_LIT(KIptvRootPathC, ":\\data\\videocenter");  // System drive

_LIT(KIptvRootPathE, ":\\data\\videocenter");  // E drive and other drives

// Permanent folders. Beginning of path is generated dynamically.

_LIT( KMyVideosExternalFolderOwn, "My Videos" );

_LIT(KSlash,"\\");

_LIT(KColonAndSlash, ":\\");

static const TInt KNumberOfLanguages = 96;

typedef struct

	{

	TLanguage iLanguage;

	char* iLanguageCode;

	} SLanguageItem;

static const SLanguageItem languageArray[ KNumberOfLanguages ] =

	{

		{ ELangEnglish, "en" },

		{ ELangFrench, "fr" },

		{ ELangGerman, "de" },

		{ ELangSpanish, "es" },

		{ ELangItalian, "it" },

		{ ELangSwedish, "sv" },

		{ ELangDanish, "da" },

		{ ELangNorwegian, "nn" },

		{ ELangFinnish, "fi" },

		{ ELangAmerican, "am" },

		{ ELangSwissFrench, "sf" },

		{ ELangSwissGerman, "sg" },

		{ ELangPortuguese, "pt" },

		{ ELangTurkish, "tr" },

		{ ELangIcelandic, "is" },

		{ ELangRussian, "ru" },

		{ ELangHungarian, "hu" },

		{ ELangDutch, "nl" },

		{ ELangBelgianFlemish, "bl" },

		{ ELangAustralian, "au" },

		{ ELangBelgianFrench, "bf" },

		{ ELangAustrian, "as" },

		{ ELangNewZealand, "nz" },

		{ ELangInternationalFrench, "if" },

		{ ELangCzech, "cs" },

		{ ELangSlovak, "sk" },

		{ ELangPolish, "pl" },

		{ ELangSlovenian, "sl" },

		{ ELangTaiwanChinese, "tc" },

		{ ELangHongKongChinese, "hk" },

		{ ELangPrcChinese, "zh" },

		{ ELangJapanese, "ja" },

		{ ELangThai, "th" },

		{ ELangAfrikaans, "af" },

		{ ELangAlbanian, "sq" },

		{ ELangAmharic, "ah" },

		{ ELangArabic, "ar" },

		{ ELangArmenian, "hy" },

		{ ELangTagalog, "tl" },

		{ ELangBelarussian, "be" },

		{ ELangBengali, "bn" },

		{ ELangBulgarian, "bg" },

		{ ELangBurmese, "my" },

		{ ELangCatalan, "ca" },

		{ ELangCroatian, "hr" },

		{ ELangCanadianEnglish, "ce" },

		{ ELangInternationalEnglish, "ie" },

		{ ELangSouthAfricanEnglish, "sa" },

		{ ELangEstonian, "et" },

		{ ELangFarsi, "fa" },

		{ ELangCanadianFrench, "cf" },

		{ ELangScotsGaelic, "gd" },

		{ ELangGeorgian, "ka" },

		{ ELangGreek, "el" },

		{ ELangCyprusGreek, "gr" },

		{ ELangGujarati, "gu" },

		{ ELangHebrew, "he" },

		{ ELangHindi, "hi" },

		{ ELangIndonesian, "id" },

		{ ELangIrish, "ga" },

		{ ELangSwissItalian, "sz" },

		{ ELangKannada, "kn" },

		{ ELangKazakh, "kk" },

		{ ELangKhmer, "km" },

		{ ELangKorean, "ko" },

		{ ELangLao, "lo" },

		{ ELangLatvian, "lv" },

		{ ELangLithuanian, "lt" },

		{ ELangMacedonian, "mk" },

		{ ELangMalay, "ms" },

		{ ELangMalayalam, "ml" },

		{ ELangMarathi, "mr" },

		{ ELangMoldavian, "mo" },

		{ ELangMongolian, "mn" },

		{ ELangNorwegianNynorsk, "nn" },

		{ ELangBrazilianPortuguese, "bp" },

		{ ELangPunjabi, "pa" },

		{ ELangRomanian, "ro" },

		{ ELangSerbian, "sr" },

		{ ELangSinhalese, "si" },

		{ ELangSomali, "so" },

		{ ELangInternationalSpanish, "os" },

		{ ELangLatinAmericanSpanish, "ls" },

		{ ELangSwahili, "sw" },

		{ ELangFinlandSwedish, "fs" },

		{ ELangTamil, "ta" },

		{ ELangTelugu, "te" },

		{ ELangTibetan, "bo" },

		{ ELangTigrinya, "ti" },

		{ ELangCyprusTurkish, "ct" },

		{ ELangTurkmen, "tk" },

		{ ELangUkrainian, "uk" },

		{ ELangUrdu, "ur" },

		{ ELangVietnamese, "vi" },

		{ ELangWelsh, "cy" },

		{ ELangZulu, "zu" }

	};    

// ============================ MEMBER FUNCTIONS ===============================

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

// CIptvUtil::LongPrintL()

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

// 		        

#if IPTV_LOGGING_METHOD != 0

EXPORT_C void CIptvUtil::LongPrintL( TDesC& aData )

    {

    const TInt KMaxLength = 80;

    TInt length = aData.Length();

    if ( length > KMaxLength )

        {                

        for ( TInt i = 0; i <= length; i += KMaxLength )

            {

            HBufC* temp = HBufC::NewLC( KMaxLength );

            TInt counter = length - i;

            if ( counter < KMaxLength )

                {

                temp->Des().Copy( aData.Mid( i, counter ) );

                }

            else

                {                                                    

                temp->Des().Copy( aData.Mid( i, KMaxLength ) );

                }

            IPTVLOGSTRING2_HIGH_LEVEL("Value = %S", temp);

            CleanupStack::PopAndDestroy( temp );

            }

        }

    else

        {            

        IPTVLOGSTRING2_HIGH_LEVEL("Value = %S", &aData);

        }

    }    

#else

EXPORT_C void CIptvUtil::LongPrintL( TDesC& /*aData*/ )

    {

    }

#endif

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

// CIptvUtil::StringToInt()

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

// 

EXPORT_C TUint32 CIptvUtil::StringToInt(TDesC& value)

    {

    TUint32 id = 0;

    if (value.Compare(_L("")) != 0)

        {

        TLex l(value);

        l.Val(id, EDecimal);

        }                

    return id;

    }

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

// CIptvUtil::GetPathL()

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

//   

EXPORT_C void CIptvUtil::GetPathL( RFs& aFs,

                                   TIptvPathSelection aSelection,

                                   TDes& aPath,

                                   TDriveNumber aDrive,

                                   TBool aCreatePath )

    {

	IPTVLOGSTRING_HIGH_LEVEL( "CIptvUtil::GetPathL(1) - Enter" );

	TChar driveChar;

    TUint driveDoubleChar;

	aFs.DriveToChar( aDrive, driveChar );

    driveDoubleChar = driveChar;

    // Most of the data is stored to "private" folder that is hidden so that 

    // harvesters don't find possible thumbnail pictures, etc. in them.

    if ( aSelection != EIptvPathMyVideosVideo )

        {

    	if ( aDrive == EDriveC )

    	   {

    	   aPath.Format( _L("%c%S"), driveDoubleChar, &KIptvRootPathC );

    	   }

    	else

    	   {

    	   aPath.Format( _L("%c%S"), driveDoubleChar, &KIptvRootPathE );

    	   }

        if ( aCreatePath )

            {

        	EnsureAndHidePathL( aFs, aPath, ETrue );

            }

        }

    // Videos and their thumbnails are stored under \My Videos.

    else

        {

        if ( aDrive == EDriveC )

            {

            TFileName cRoot = PathInfo::PhoneMemoryRootPath();

            aPath.Format( _L("%S%S"), &cRoot, &KMyVideosExternalFolderOwn );

            }

    	else

            {

            aPath.Format( _L("%c%S%S"), driveDoubleChar,

                                        &KColonAndSlash,

                                        &KMyVideosExternalFolderOwn );

            }

        if ( aCreatePath )

            {        

            EnsureAndHidePathL( aFs, aPath, EFalse );

            }

        }

	// Add subfolder based on the exact path requested.

    switch ( aSelection )

        {

        case EIptvPathWritableRoot:

            {

            }

        	break;

        case EIptvPathTmp:

            {

        	_LIT( KTempSuffix, "\\tmp" );

            aPath.Append( KTempSuffix );

            }

            break;

        case EIptvPathMyVideosDb:

            {

        	_LIT( KMyVideosDbSuffix, "\\mv" );

            aPath.Append( KMyVideosDbSuffix );

            }

            break;

        case EIptvPathMyVideosVideo:

            {

        	_LIT( KMyVideosVideoSuffix, "\\Downloads" );

            aPath.Append( KMyVideosVideoSuffix );

            }

            break;

        case EIptvPathEcg:

            {

        	_LIT( KContentGuideSuffix, "\\ecg" );

            aPath.Append( KContentGuideSuffix );

            }

            break;

        case EIptvPathService:

            {

        	_LIT( KServicePathSuffix, "\\srv" );

            aPath.Append( KServicePathSuffix );

            }

            break;

        case EIptvPathEcgLive:

            {

        	_LIT( KEcgLiveSuffix, "\\ecg\\live" );

        	aPath.Append( KEcgLiveSuffix );

            }

        	break;

        case EIptvPathTmpLive:

            {

        	_LIT( KTmpLiveSuffix, "\\tmp\\live" );

        	aPath.Append( KTmpLiveSuffix );

            }

        	break;

        default:

            {

		    IPTVLOGSTRING_HIGH_LEVEL("CIptvUtil::GetPathL(1) - Invalid argument!" );            

            User::Leave( KErrPathNotFound );

            }

            break;

        }

    // Add trailing slash.

    aPath.Append( KSlash );

    // Ensure / hide the path, depending on exact path.

    if ( aCreatePath )

        {

        if ( aSelection == EIptvPathMyVideosVideo )

            {

            EnsureAndHidePathL( aFs, aPath, EFalse );

            }

        else

            {

            EnsureAndHidePathL( aFs, aPath, ETrue );

            }

        }

    IPTVLOGSTRING2_HIGH_LEVEL( "CIptvUtil::GetPathL(1) - Exit (%S)", &aPath );

    }

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

// CIptvUtil::GetPathL()

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

//  

EXPORT_C void CIptvUtil::GetPathL( RFs& aFs,

                                   TIptvPathSelection aSelection,

								   TUint32 aServiceId,

								   TDes& aPath,

								   TBool aCreatePath )

	{

	IPTVLOGSTRING_HIGH_LEVEL("CIptvUtil::GetPathL(2) - Enter" );

	switch ( aSelection )

		{

		case EIptvPathEcgLive:

		case EIptvPathTmpLive:

			{

			// First get normal path based on TIptvPathSelection

			GetPathL( aFs, aSelection, aPath, EDriveC, aCreatePath );

			// Append serviceId directory at the end of the path as a directory

			aPath.AppendNum( aServiceId );

			// Finally add '\' at the end of the path

			aPath.Append( KSlash );

			}

			break;

		case EIptvPathRssSearchThumbnail:

		case EIptvPathRssThumbnail:

			{

			// First of all get the ecg path for thumbnails.

			// Thumbnail path is c:\data\videocenter\ecg\<serviceId>\(stbn/tbn)

			GetPathL( aFs, EIptvPathEcg, aPath, EDriveC, aCreatePath );

			// Append serviceid and slash

			aPath.AppendNum( aServiceId );

			aPath.Append( KSlash );

            if ( aCreatePath )

                {

                EnsureAndHidePathL( aFs, aPath, ETrue );

                }

			// Select thumbnail dir based on what client requested

			if ( aSelection == EIptvPathRssThumbnail )

				{

				_LIT( KIptvVodThumbnailDir, "tbn\\" );

				aPath.Append( KIptvVodThumbnailDir );

				}

			else

				{

				_LIT( KSearchThumbnailDir, "stbn\\");

				aPath.Append( KSearchThumbnailDir );

				}

			// Now in aPath we have either

			// \\data\\videocenter\\ecg\\<serviceId>\\tbn\\

			// or

			// \\data\\videocenter\\ecg\\<serviceId>\\stbn\\

			// First one is for vod, second one is for search

			}

			break;

		default:

		    {

		    IPTVLOGSTRING_HIGH_LEVEL("CIptvUtil::GetPathL(2) - Invalid argument!" );

		    User::Leave( KErrPathNotFound );

		    }

			break;

		}

    if ( aCreatePath )

        {

        EnsureAndHidePathL( aFs, aPath, ETrue );

        }

    IPTVLOGSTRING2_HIGH_LEVEL("CIptvUtil::GetPathL(2) - Exit (%S)", &aPath );

	}

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

// CIptvUtil::ReadDes

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

//

EXPORT_C void CIptvUtil::ReadDesFromStreamL(TDes& aDes, RReadStream& aStream)

    {

    TInt i;

    TInt length = aStream.ReadUint16L();

    aDes.Zero();

    if ( aDes.MaxLength() < length )

        {

        User::Leave( KErrArgument );

        }

    for(i = 0; i < length; i++)

        {

        aDes.Append(aStream.ReadUint16L());

        }

    }

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

// CIptvUtil::WriteDes

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

//

EXPORT_C void CIptvUtil::WriteDesToStreamL(const TDesC& aDes, RWriteStream& aStream)

    {

    TInt i;

    TInt length = aDes.Length();

    aStream.WriteUint16L(length);

    for(i = 0; i < length; i++)

        {

        aStream.WriteUint16L(aDes[i]);

        }

    }

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

// CIptvUtil::ReadDes8

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

//

EXPORT_C void CIptvUtil::ReadDes8FromStreamL(TDes8& aDes, RReadStream& aStream)

    {

    TInt i;

    TInt length = aStream.ReadUint16L();

    aDes.Zero();

    if ( aDes.MaxLength() < length )

        {

        User::Leave( KErrArgument );

        }    

    for(i = 0; i < length; i++)

        {

        aDes.Append(aStream.ReadUint8L());

        }

    }

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

// CIptvUtil::WriteDes8

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

//

EXPORT_C void CIptvUtil::WriteDes8ToStreamL(const TDesC8& aDes, RWriteStream& aStream)

    {

    TInt i;

    TInt length = aDes.Length();

    aStream.WriteUint16L(length);

    for(i = 0; i < length; i++)

        {

        aStream.WriteUint8L(aDes[i]);

        }

    }

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

// CIptvUtil::ReadUint64FromStream

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

//

EXPORT_C void CIptvUtil::ReadUint64FromStreamL(TUint64& aData, RReadStream& aStream)

    {

    TUint low  = static_cast<TUint>(aStream.ReadUint32L());

    TUint high = static_cast<TUint>(aStream.ReadUint32L());

    aData  = high;

    aData  = aData << 32;

    aData |= low;

    }

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

// CIptvUtil::WriteTUint64ToStreamL

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

//

EXPORT_C void CIptvUtil::WriteUint64ToStreamL(const TUint64 aData, RWriteStream& aStream)

    {

    aStream.WriteUint32L( aData & 0x00000000FFFFFFFFULL);

    aStream.WriteUint32L( (aData & 0xFFFFFFFF00000000ULL) >> 32);