/*

* 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( KAac16,             ".AAC" );

_LIT16( KWma16,             ".WMA" );

_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( KAac,                "audio/aac" );

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

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

_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  

    if ( ext.FindC( KHtml16 ) == 0 && 

         ext.Length() == KHtml16().Length() )

        {

        mimetype = HBufC8::NewLC( KHtml().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ext.FindC( KXml16 ) == 0 && 

              ext.Length() == KXml16().Length() )

        {

        mimetype = HBufC8::NewLC( KXml().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ext.FindC( KTxt16 ) == 0 && 

              ext.Length() == KTxt16().Length() )

        {

        mimetype = HBufC8::NewLC( KTxt().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ( ext.FindC( KJpg16 ) == 0 && 

                ext.Length() == KJpg16().Length() ) ||

                ( ext.FindC( KJpeg16 ) == 0 && 

                  ext.Length() == KJpeg16().Length() ) )

        {

        mimetype = HBufC8::NewLC( KJpg().Length() );

        mimetype->Des().Zero();

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

        }       

    else if ( ext.FindC( KGif16 ) == 0 && 

              ext.Length() == KGif16().Length() )

        {

        mimetype = HBufC8::NewLC( KGif().Length() );

        mimetype->Des().Zero();

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

        }   

    else if ( ext.FindC( KPng16 ) == 0 && 

              ext.Length() == KPng16().Length() )

        {

        mimetype = HBufC8::NewLC( KPng().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ( ext.FindC( KMpg16 ) == 0 &&

                ext.Length() == KMpg16().Length() ) ||

                ( ext.FindC( KMpeg16 ) == 0 &&

                  ext.Length() == KMpeg16().Length() ) )

        {

        mimetype = HBufC8::NewLC( KMpeg().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ( ext.FindC( KMpeg416 ) == 0 && 

                ext.Length() == KMpeg416().Length() ) )

        {

        mimetype = HBufC8::NewLC( KMpeg4().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ext.FindC( KAvi16 ) == 0 && 

              ext.Length() == KAvi16().Length() )

        {

        mimetype = HBufC8::NewLC( KAvi().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ext.FindC( KMp316 ) == 0 && 

              ext.Length() == KMp316().Length() )

        {

        mimetype = HBufC8::NewLC( KMp3().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ext.FindC( KXHtml16 ) == 0 && 

              ext.Length() == KXHtml16().Length() )

        {

        mimetype = HBufC8::NewLC( KXHtml().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ext.FindC( KAac16 ) == 0 && 

              ext.Length() == KAac16().Length() )

        {

        mimetype = HBufC8::NewLC( KAac().Length() );

        mimetype->Des().Zero();

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

        }

    else if ( ext.FindC( KWma16 ) == 0 && 

              ext.Length() == KWma16().Length() )

        {

        mimetype = HBufC8::NewLC( KWma().Length() );

        mimetype->Des().Zero();

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

        }

    else

        {

        // Mime type not recognized. Return NULL.        

        }

    if( mimetype )

        {

        CleanupStack::Pop( 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;