/*

* 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 "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:  Upnp framework's common utility functions

*

*/

// INCLUDE FILES

// System

#include <e32std.h>

#include <upnpstring.h>

#include <apmrec.h>

#include <apgcli.h>

#include <WlanCdbCols.h>            // WLAN_SERVICE

#include <caf/content.h>                // CAF (WM-DRM check)

#include <caf/agent.h>                  // CAF (WM-DRM check)

#include <commdb.h>

#include <in_sock.h> 

#include <pathinfo.h>

// upnp stack api

#include <upnpcontainerlist.h>

#include <upnpcontainer.h>

#include <upnpitem.h>

#include <upnpdevice.h>

// upnpframework / avcontroller helper api

#include "upnpconstantdefs.h"

// utilities internal

#include "upnpfileutilitytypes.h"

#include "upnpcommonutils.h"

_LIT( KComponentLogfile, "upnputilities.txt");

#include "upnplog.h"

// CONSTANTS

_LIT8( KMimeAudio,          "audio" );

_LIT8( KMimeVideo,          "video" );

_LIT8( KMimeImage,          "image" );

_LIT8( KMimePlaylist,       "audio/mpegurl" );

_LIT16( KXHtml16,           ".XHTML" );

_LIT16( KHtml16,            ".HTML" );

_LIT16( KXml16,             ".XML" );

_LIT16( KTxt16,             ".TXT" );

_LIT16( KJpeg16,            ".JPEG" );

_LIT16( KJpg16,             ".JPG" );

_LIT16( KGif16,             ".GIF" );

_LIT16( KPng16,             ".PNG" );

_LIT16( KMpeg16,            ".MPEG" );

_LIT16( KMpg16,             ".MPG" );

_LIT16( KMpeg416,           ".MPEG4" );

_LIT16( KAvi16,             ".AVI" );

_LIT16( KMp316,             ".MP3" );

_LIT16( KMp416,             ".MP4" );

_LIT16( KAac16,             ".AAC" );

_LIT16( KWma16,             ".WMA" );

_LIT16( KTs16,              ".TS" );

_LIT16( KMts16,             ".MTS" );

_LIT16( KM2ts16,            ".M2TS" );

_LIT8( KXHtml,              "application/vnd.pwg-xhtml-print" );

_LIT8( KHtml,               "text/html" );

_LIT8( KXml,                "text/xml" );

_LIT8( KTxt,                "text/plain" );

_LIT8( KJpg,                "image/jpeg" );

_LIT8( KGif,                "image/gif" );

_LIT8( KPng,                "image/png" );

_LIT8( KMpeg,               "video/mpeg" );

_LIT8( KMpeg4,              "video/mpeg4" );

_LIT8( KMp3,                "audio/mpeg" );

_LIT8( KMp4,                "video/mp4" );

_LIT8( KAac,                "audio/aac" );

_LIT8( KWma,                "audio/x-ms-wma" );

_LIT8( KAvi,                "video/x-msvideo" );

_LIT8( KTs,                 "video/mpeg" );

_LIT8( KM2ts,               "video/vnd.dlna.mpeg-tts" );

_LIT(  KLineFeed,           "\r\n");

_LIT8( KHttpDes,            "http://" );

_LIT( KTemp,                "upnpfwtemp");

_LIT8( KUnderScore,         "_" );

_LIT8( KStar,               "*" );

_LIT8( KColon,              ":");

_LIT8( KKorp,               "<" );

_LIT8( KProk,               ">" );

_LIT8( KQuotation,          "\"" );

_LIT8( KDoubleBackSlash,    "\\" );

_LIT8( KSlash,              "/" );

_LIT8( KQuestionMark,       "?" );

_LIT8( KPipe,               "|" );

_LIT8( KTab,                "\t" );

_LIT8( KSpace,              " " );

const TInt KPlaceHolderLength       = 28;

const TInt KBufferLength            = 256;

const TInt KBufferLengthSmall       = 10;

const TInt KCodeSemicolon           = 58;

const TInt KMask                    = 0xFF;

const TInt KCodeDot                 = 46;

_LIT( KUpnpDateString,"%F%Y-%M-%D");

const TInt KMaxDateStringLength = 30;

_LIT8( KAudioSupport,        "audio/" );

_LIT8( KImageSupport,        "image/" );

_LIT8( KVideoSupport,        "video/" );

_LIT8( KImageJpeg,         	"=JPEG_" );

_LIT8( KImagePng,          	"=PNG_" );

_LIT8( KAudioAc3,         	"=AC3" );

_LIT8( KAudioAmr,         	"=AMR_" );

_LIT8( KAudioAtra,         	"=ATRAC3plus" );

_LIT8( KAudioLpcm,         	"=LPCM" );

_LIT8( KAudioMp3,         	"=MP3" );

_LIT8( KAudioAac,         	"=AAC_" );

_LIT8( KAudioHeaac,        	"=HEAAC_" );

_LIT8( KAudioBsac,         	"=BSAC_" );

_LIT8( KAudioWmab,         	"=WMABASE" );

_LIT8( KAudioWmaf,         	"=WMAFULL" );

_LIT8( KAudioWmap,         	"=WMAPRO" );

_LIT8( KVideoMpeg,          "=MPEG" );

_LIT8( KVideoAvc,          	"=AVC_" );

_LIT8( KVideoWmvm,         	"=WMVMED_" );

_LIT8( KVideoVmvh,          "=WMVHIGH_" );

_LIT8( KVideoWmvh,          "=WMVHM_" );

_LIT8( KVideoWmvspll,       "=WMVSPLL_" );

_LIT8( KVideoWmvspml,       "=WMVSPML_" );

// ============================ LOCAL FUNCTIONS =============================

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

// UPnPCommonUtils::MemoryCardStateL

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

//

EXPORT_C TBool UPnPCommonUtils::MemoryCardStateL()

    {

    TDriveInfo driveInfo;

    TBool status = EFalse;

    RFs fileServer;

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

    CleanupClosePushL( fileServer );

    TInt error = fileServer.Drive( driveInfo, EDriveE );

    CleanupStack::PopAndDestroy( &fileServer );

    //check if memory card is present

    if ( error == KErrNone && driveInfo.iType == EMediaHardDisk )

        {

        status = ETrue;

        }

    return status;

    }

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

// UPnPCommonUtils::ResolveMimeTypeL

// Resolves the MIME type of a file. Leaves in error cases.

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

EXPORT_C HBufC8* UPnPCommonUtils::ResolveMimeTypeL( const TDesC& aFileName )

    {

    HBufC8* mimetype = NULL;

    mimetype = GetMimeTypeByExtensionL( aFileName );

    // If the mime type was not recognized by the extension, try the 

    // platform mime type recognizer

    if( !mimetype )

        {           

        // finding server

        RApaLsSession sess; 

        TInt error = sess.Connect();

        // We have FS, File and RApaLs open

        if ( error == KErrNone )

            {

            CleanupClosePushL( sess );

            TUid id = TUid::Uid( 0 );

            TDataType type;

            error = sess.AppForDocument( aFileName, id, type );

            if( error == KErrNone )

                {

                mimetype = HBufC8::NewL( type.Des8().Length() + 

                                         KLineFeed().Length() );

                mimetype->Des().Append( type.Des8() );

                mimetype->Des().Append( KLineFeed() );

                }

            // Clean up

            CleanupStack::PopAndDestroy( &sess );

            }

        }

    return mimetype;

    }

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

// UPnPCommonUtils::GetMimeTypeByExtensionL

// Resolves the type of a file. Leaves in error cases.

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

EXPORT_C HBufC8* UPnPCommonUtils::GetMimeTypeByExtensionL(

    const TDesC& aFileName )

    {

    HBufC8* mimetype = NULL;

    HBufC* tempFilename = aFileName.AllocL();

    CleanupStack::PushL( tempFilename );

    // Convert letters to upper case

    tempFilename->Des().UpperCase();

    TParse parse;

    parse.Set( tempFilename->Des(), NULL, NULL );

    TBufC<KMaxName> ext( parse.Ext() );

    CleanupStack::PopAndDestroy( tempFilename );

    tempFilename = NULL;

    // FindC and length calculation is used,

    // because compareC does not work for undefined reason  

    GetMimeTypeforImageExtensionsL( ext,&mimetype );

    GetMimeTypeforAudioVideoExtensionsL( ext,&mimetype );

    GetMimeTypeforExtensionsL( ext,&mimetype );

    return mimetype;

    }

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

// UPnPCommonUtils::ResolveFileTypeL

// Resolves the MIME type of a file. Leaves in error cases.

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

EXPORT_C TUPnPItemType UPnPCommonUtils::ResolveFileTypeL(

                                                    const TDesC& aFileName )

    {

    TUPnPItemType returnValue = ETypeOther;

    if( aFileName != KNullDesC )

        {

        HBufC8* mimetype = NULL;

        mimetype = ResolveMimeTypeL( aFileName );

        if( mimetype )

            {

            CleanupStack::PushL( mimetype );

            if( mimetype->Des().Find( KMimeImage() ) >= 0 )

                {

                returnValue = ETypeImage;

                }

            else if( mimetype->Des().Find( KMimePlaylist() ) >= 0 )

                {

                returnValue = ETypePlaylist;

                }

            else if( mimetype->Des().Find( KMimeAudio() ) >= 0 )

                {

                returnValue = ETypeAudio;

                }

            else if( mimetype->Des().Find( KMimeVideo() ) >= 0 )

                {

                returnValue = ETypeVideo;

                }

            else

                {

                returnValue = ETypeOther;

                }

            // Clean up

            CleanupStack::PopAndDestroy( mimetype );

            mimetype = NULL;

            }

        else

            {

            returnValue = ETypeOther;

            }

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return returnValue;

    }

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

// UPnPCommonUtils::ReplacePlaceHolderInURIL

// Replaces IP address and port number placeholders of the RES element's URI

// string of the given item.

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

//

EXPORT_C void UPnPCommonUtils::ReplacePlaceHolderInURIL( 

                                            CUpnpItem& aItem,

                                            const TInetAddr& aAddress )

    {

    __LOG( "UPnPCommonUtils::ReplacePlaceHolderInURIL" );

    const RUPnPElementsArray& elms = aItem.GetElements();

    TInt count = elms.Count();

    TInt i = 0;

    for( ; i < count; i++)

        {

        if( elms[ i ]->Name() == KElementRes )

            {

            TPtrC8 ptrC( elms[ i ]->Value() );

            HBufC8* addrBuf = HBufC8::NewLC( KBufferLength );

            addrBuf->Des().Append( KHttpDes );

            TBuf8<KBufferLengthSmall> buf;

            TChar separator( KCodeSemicolon );

            TChar dot( KCodeDot );

            TUint32 addr = aAddress.Address();

            buf.Num( addr >> 24 ); // First part of the ip address

            addrBuf->Des().Append( buf );

            addrBuf->Des().Append( dot );

            buf.Num( ( addr >> 16 ) & KMask ); // Second part of ip address

            addrBuf->Des().Append( buf );

            addrBuf->Des().Append( dot );

            buf.Num( ( addr >> 8 ) & KMask ); // Third part of the ip address

            addrBuf->Des().Append( buf );

            addrBuf->Des().Append( dot );

            buf.Num( addr & KMask ); // last part of the ip address

            addrBuf->Des().Append( buf );

            addrBuf->Des().Append( separator );

            buf.Num( aAddress.Port() ); // port number

            addrBuf->Des().Append( buf );

            // Append rest of the uri

            addrBuf->Des().Append( ptrC.Mid( KPlaceHolderLength ) );

            __LOG8( *addrBuf );

            elms[ i ]->SetValueL( *addrBuf );

            CleanupStack::PopAndDestroy( addrBuf );

            i = count;

            }

        }    

    }

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

// UPnPCommonUtils::ReplaceIllegalFilenameCharactersL

// Replaces the illegal filename characters from the given filename string

// and returns a new fixed filename string. 8bit version.

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

//

EXPORT_C HBufC8* UPnPCommonUtils::ReplaceIllegalFilenameCharactersL( 

                                        const TDesC8& aFileName )

    {

    // Note that this implementation is a bit slow since it goes through the 

    // descriptor many times. Only one iteration would be optimal solution.

    HBufC8* buf = HBufC8::NewLC( aFileName.Length() );

    TPtr8 ptr = buf->Des();

    ptr.Copy( aFileName );

    UpnpString::StringReplaceInPlaceL( ptr, 

                                       KProk(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KKorp(),

                                       KUnderScore() );        

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KQuotation(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KDoubleBackSlash(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr, 

                                       KSlash(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KStar(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KPipe(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KColon(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KQuestionMark(),

                                       KUnderScore() );

    UpnpString::StringReplaceInPlaceL( ptr,

                                       KTab(),

                                       KUnderScore() );

    CleanupStack::Pop(); // Can't pop by name, name invalid now

    return buf;

    }    

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

// UPnPCommonUtils::ReplaceIllegalFilenameCharactersL

// Replaces the illegal filename characters from the given filename string

// and returns a new fixed filename string. 16bit version.

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

//

EXPORT_C HBufC* UPnPCommonUtils::ReplaceIllegalFilenameCharactersL( 

                                        const TDesC& aFilename )

    {

    HBufC8* convertedParam = NULL;

    convertedParam = UpnpString::FromUnicodeL( aFilename );

    CleanupStack::PushL( convertedParam );

    HBufC8* replacedFilename8 = NULL;

    replacedFilename8 = ReplaceIllegalFilenameCharactersL( *convertedParam );

    CleanupStack::PushL( replacedFilename8 );

    HBufC* replacedFilename16 = NULL;

    replacedFilename16 = UpnpString::ToUnicodeL( *replacedFilename8 );

    // Clean up

    CleanupStack::PopAndDestroy( replacedFilename8 );

    CleanupStack::PopAndDestroy( convertedParam );

    return replacedFilename16;

    }    

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

// UPnPCommonUtils::IsPlaylistContainerL

// Checks if the given CUpnpObject is a playlist container.

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

//

EXPORT_C TBool UPnPCommonUtils::IsPlaylistContainerL( 

                                        const CUpnpObject& aContainer )

    {

    TBool returnValue = EFalse;

    if( aContainer.ObjectType() != EUPnPContainer ||

        aContainer.ObjectClass() == KNullDesC8 )

        {

        User::Leave( KErrArgument );

        }

    else

        {

        if( aContainer.ObjectClass().CompareF( KClassPlaylist() ) == 0 )

            {

            returnValue = ETrue;

            }        

        }

    return returnValue;

    }

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

// UPnPCommonUtils::FindContainerByTitle

// Finds container from CUpnpContainerList by title field

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

//

EXPORT_C CUpnpContainer* UPnPCommonUtils::FindContainerByTitle(

    const CUpnpContainerList& aList, const TDesC8& aTitle )

    {

    TBool notFound( ETrue );

    TInt index( 0 );

    CUpnpContainer* tmp( NULL );

    while ( index < aList.ObjectCount() && notFound )

        {

        tmp = static_cast< CUpnpContainer* >

            ( aList[ index ] );

        if ( tmp->Title().Compare( aTitle ) == 0 )

            {

            notFound = EFalse;

            }

        else

            {

            tmp = NULL;

            }

        index++;

        }

    return tmp;

    }

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

// UPnPCommonUtils::IntToDesC8LC

// Returns IntValue for aObject

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