/*
* Copyright (c) 2006-2007 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:  Utility class for meta data gathering for audio files
*
*/


// INCLUDE FILES
// System
#include <e32std.h>
#include <e32base.h>

// upnp stack api
#include <upnpitem.h> // CUpnpItem
#include <upnpstring.h>
#include <upnpelement.h>
#include <upnpdlnaprotocolinfo.h>
#include <upnpprotocolinfo.h>

// upnpframework / avcontroller helper api
#include "upnpconstantdefs.h" // for upnp class defs

// upnpframework internal api's
#include "upnpresresolver.h" // CUpnpResResolver
#include "upnpresparameters.h"

// utilities internal
#include "upnpcommonutils.h"
#include "upnpcdsreselementutility.h"

_LIT( KHttp, "http://" );
const TInt KColon = 58;
const TInt KIpAddLen = 25;

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

// --------------------------------------------------------------------------
// CUpnpCdsResElementUtility::AddResElementL
// 
// (other items were commented in a header).
// --------------------------------------------------------------------------
//
EXPORT_C void UpnpCdsResElementUtility::AddResElementL( 
                                                CUpnpItem& aItem, 
                                                const TDesC& aFilename )
    {

    // Create CUpnpElement for res
    CUpnpElement* elRes = CUpnpElement::NewL( KElementRes() );
    CleanupStack::PushL( elRes );
    elRes->SetFilePathL( aFilename );
 
    // Create res resolver component and put it to CleanupStack
    CUpnpResResolver* resolver = CUpnpResResolver::NewLC();
    
    // Obtain res element parameters using res resolver component.
    CUpnpResParameters* resParameters = NULL;
	TRAPD(err, resParameters = resolver->GetResParametersL( aFilename ) );

   if (err == KErrGeneral)	
    {
	// File not recognized, handling it manually by adding
	// following res-item:  'http-get:*:MIMETYPE:*'

   		_LIT8( KProtInfo1, "http-get:");
    	_LIT8( KStar8, "*");
    	_LIT8( KColon8, ":");
    	HBufC8* mimetype = UPnPCommonUtils::ResolveMimeTypeL(aFilename);
    	CleanupStack::PushL( mimetype );
    	mimetype->Des().Trim();		// needs to be trimmed

        TInt resultLen = KProtInfo1().Length() + KStar8().Length() + 
    	KColon8().Length() + mimetype->Des().Length() + KColon8().Length() +
        KStar8().Length();
    	HBufC8* resValue = HBufC8::NewLC( resultLen );
        CleanupStack::Pop( resValue ); // temporarily pop so that mimetype can be destroyed
        
    // construct final value
	    resValue->Des().Append( KProtInfo1 );
	    resValue->Des().Append( KStar8 );
	    resValue->Des().Append( KColon8 );
	    resValue->Des().Append( *mimetype );
	    resValue->Des().Append( KColon8 );
	    resValue->Des().Append( KStar8 );
        
        CleanupStack::PopAndDestroy( mimetype );
        mimetype = NULL;
        CleanupStack::PushL( resValue );
        
		CUpnpProtocolInfo* pInfo = CUpnpProtocolInfo::NewL(*resValue);
		CleanupStack::PushL( pInfo );
		CUpnpAttribute* attribute = CUpnpAttribute::NewLC( KAttributeProtocolInfo() );
		attribute->SetValueL( pInfo->ProtocolInfoL() );
		elRes->AddAttributeL( attribute );    
    	aItem.AddElementL(elRes);

		CleanupStack::Pop( attribute );
		CleanupStack::PopAndDestroy( pInfo );
		CleanupStack::PopAndDestroy( resValue );
		CleanupStack::PopAndDestroy( resolver );
    	CleanupStack::Pop( elRes );
  		resValue = NULL;
    	
    	return;
    }
    // Fixes ESLX-7B7HBL
    else if( err )
        {
        User::Leave( err );
        }

    CleanupStack::PushL( resParameters );

    // Add protocolInfo parameter to res element.
    if ( resParameters->ProtocolInfo().Length() > 0 ) 
        {
        CUpnpAttribute* prInfo = CUpnpAttribute::NewLC( KAttributeProtocolInfo() );
        prInfo->SetValueL( resParameters->ProtocolInfo() );   
        elRes->AddAttributeL( prInfo ); //transfer ownership
        CleanupStack::Pop( prInfo );       
        }

    // Add size parameter to res element.

    HBufC8* sizeString = resParameters->FileSizeL();
    if ( sizeString ) 
        {
        CleanupStack::PushL( sizeString );
        CUpnpAttribute* size =
            CUpnpAttribute::NewLC( KAttributeSize() );
        size->SetValueL( *sizeString );

        elRes->AddAttributeL( size ); //transfer ownership
        CleanupStack::Pop( size );        
        CleanupStack::PopAndDestroy( sizeString );
        sizeString = NULL;
        }

    if ( resParameters->IsImageFile() ) 
        {
        // In image case, add resolution parameter to res element.
        HBufC8* resolutionString = resParameters->ResolutionL();
        if ( resolutionString ) 
            {
            CleanupStack::PushL( resolutionString );
            CUpnpAttribute* resolution = 
                CUpnpAttribute::NewLC( KAttributeResolution() );
            resolution->SetValueL( *resolutionString );
            elRes->AddAttributeL( resolution ); //transfer ownership
            CleanupStack::Pop( resolution );            
            CleanupStack::PopAndDestroy( resolutionString );
            resolutionString = NULL;
            }
        }
    else if ( resParameters->IsAudioOrVideoFile() )
        {
        // In music or video case, add duration parameter to res element.
        HBufC8* durationString = resParameters->DurationL();
        if ( durationString ) 
            {
            CleanupStack::PushL( durationString );
            CUpnpAttribute* duration =
                CUpnpAttribute::NewLC( KAttributeDuration() );
            duration->SetValueL( *durationString );
            elRes->AddAttributeL( duration ); //transfer ownership
            CleanupStack::Pop( duration );
            CleanupStack::PopAndDestroy( durationString );
            durationString = NULL;
            }
        }

    CleanupStack::PopAndDestroy( resParameters );
    CleanupStack::PopAndDestroy( resolver );

    // Attach res element to aItem.
    aItem.AddElementL( elRes ); //transfer ownership
    CleanupStack::Pop( elRes );
    }

// --------------------------------------------------------------------------
// CUpnpCdsResElementUtility::IsUriAbsolute
// 
// (other items were commented in a header).
// --------------------------------------------------------------------------
EXPORT_C TBool UpnpCdsResElementUtility::IsUriAbsolute( const TDesC8& aUri )
    {
    TInetAddr addr;
    TBool retVal = EFalse;
    TBuf<KIpAddLen> ipAddrBuf;
    // if aUri.Length is less than KHttp().Length(),aUri is invalid
    if ( aUri.Length() >= KHttp().Length() )
		{
		TPtrC8 right = aUri.Right( aUri.Length() - KHttp().Length() );

		TInt posit = right.Locate( TChar( KColon ) );
		if( posit != KErrNotFound )
			{
			TPtrC8 ipAddr = right.Left( posit );
			if( ipAddr.Length() <= KIpAddLen )
				{
				ipAddrBuf.Copy( ipAddr );
				}
			}

		if( addr.Input( ipAddrBuf ) == KErrNone )
			{
			retVal = ETrue;
			}
		}

	return retVal;    
    }

//  End of File