/*

* 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:      Implementation file of CUpnpResParameters class. 

*                CUpnpResParameters is created to encapsulate information  

*                that is needed in a contentdirectory res element.

*

*/

// system includes

// user includes

#include "upnpresparameters.h"

#include "upnpdlnaprofiler.h"

_LIT( KComponentLogfile, "dlnaprofiler.txt");

#include "upnplog.h"

// constants

const TInt KMaxTintLength = 20; // max. TInt string representation length.

const TInt KMinutesInHour = 60;

const TInt KSecondsInMinute = 60;

const TInt KSecondsInHour = KMinutesInHour * KSecondsInMinute;

const TInt KHourMaxLength = 5;

const TInt KMinutesLength = 2;

const TInt KSecondsLength = 2;

_LIT( KResolutionDivider, "x" );

_LIT( KTimeDivider, ":" );

_LIT( KZero, "0" );

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

// NONE

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

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

// CUpnpResParameters C++ constructor

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

//

CUpnpResParameters::CUpnpResParameters()

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters constructor" );

    }

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

// CUpnpResParameters::ConstructL

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

//

void CUpnpResParameters::ConstructL()

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::ConstructL" );

    }

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

// CUpnpResParameters::NewL

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

//

EXPORT_C CUpnpResParameters* CUpnpResParameters::NewL()

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::NewL" );

    CUpnpResParameters* self = CUpnpResParameters::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpResParameters::NewLC

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

//

EXPORT_C CUpnpResParameters* CUpnpResParameters::NewLC()

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::NewLC" );

    CUpnpResParameters* self = new( ELeave ) CUpnpResParameters;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpResParameters destructor

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

//

CUpnpResParameters::~CUpnpResParameters()

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters destructor" );

    delete iProtocolInfo;

    delete iMimetype;

    }

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

// CUpnpResParameters::ProtocolInfo

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

//

EXPORT_C const TDesC8& CUpnpResParameters::ProtocolInfo() const

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::ProtocolInfo" );

    if ( iProtocolInfo ) 

        {

        return *iProtocolInfo;

        }

    return KNullDesC8();

    }

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

// CUpnpResParameters::FileSizeL

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

//

EXPORT_C HBufC8* CUpnpResParameters::FileSizeL() const

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::FileSizeL" );

    HBufC8* retval = NULL;

    TBuf<KMaxTintLength> sizeOfFile;

    sizeOfFile.Num( iFileSize );

    retval = HBufC8::NewL( sizeOfFile.Length() );

    retval->Des().Append( sizeOfFile );

    return retval;

    }

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

// CUpnpResParameters::DurationL

//

//   Requirement [7.3.22.1]: The syntax of the res@duration must be 

//   compliant to the following definition:

//     duration = hours ":" minutes ":" seconds

//     hours = 1*5 DIGIT; 0-99999

//     minutes = 2 DIGIT ; 00-59

//     seconds = 2 DIGIT ["." 3 DIGIT] ; 00-59 (.000-.999) 

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

//

EXPORT_C HBufC8* CUpnpResParameters::DurationL() const

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::DurationL" );

    HBufC8* retval = NULL;

    // Leave if the duration has invalid value

    if( iDurationInSeconds < 0 )

        {

        User::Leave( KErrArgument );

        }

    TInt hour = iDurationInSeconds / KSecondsInHour;

    TInt min = (iDurationInSeconds % KSecondsInHour) / KSecondsInMinute;

    TInt sec = (iDurationInSeconds % KSecondsInHour) % KSecondsInMinute;

    // Leave if the duration is longer than allowed (99999h 99min 99sec)

    if( hour >= 100000 )

        {

        User::Leave( KErrArgument );

        }

    // Convert TInt to TBuf

    TBuf<KHourMaxLength> hours;

    hours.Num( hour );

    hours.Trim();

    TBuf<2> minutes;

    minutes.Num( min );

    TBuf<2> seconds;

    seconds.Num( sec );

    retval = HBufC8::NewL( hours.Length() + 

                           KTimeDivider().Length() + 

                           KMinutesLength +

                           KTimeDivider().Length() + 

                           KSecondsLength );

    retval->Des().Append( hours );

    retval->Des().Append( KTimeDivider() );

    if( min < 10 )

        {

        retval->Des().Append( KZero() );

        }

    retval->Des().Append( minutes );

    retval->Des().Append( KTimeDivider() );

    if( sec < 10 )

        {

        retval->Des().Append( KZero() );

        }

    retval->Des().Append( seconds );

    return retval;

    }

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

// CUpnpResParameters::ResolutionL

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

//

EXPORT_C HBufC8* CUpnpResParameters::ResolutionL() const

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::ResolutionL" );

    HBufC8* retval = NULL;

    TBuf<KMaxTintLength> width;

    width.Num( iResolution.iWidth );

    TBuf<KMaxTintLength> height;

    height.Num( iResolution.iHeight );

    retval = HBufC8::NewL( width.Length() + 

                          KResolutionDivider().Length() + 

                          height.Length() );

    retval->Des().Append( width );

    retval->Des().Append( KResolutionDivider() );

    retval->Des().Append( height );

    return retval;

    }

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

// CUpnpResParameters::IsImageFile

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

//

EXPORT_C TBool CUpnpResParameters::IsImageFile() const

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::IsImageFile" );

    TBool retval = EFalse;

    if ( iMimetype->Left( KMimeStartLength ).Compare( KImage() ) == 0 ) 

        {

        retval = ETrue;

        }

    return retval;

    }

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

// CUpnpResParameters::IsAudioOrVideoFile

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

//

EXPORT_C TBool CUpnpResParameters::IsAudioOrVideoFile() const

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::IsAudioOrVideoFile" );

    TBool retval = EFalse;

    if ( iMimetype->Left( KMimeStartLength ).Compare( KVideo() ) == 0 ||

         iMimetype->Left( KMimeStartLength ).Compare( KAudio() ) == 0 ) 

        {

        retval = ETrue;

        }

    return retval;

    }

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

// CUpnpResParameters::SetProtocolInfoL

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

//

void CUpnpResParameters::SetProtocolInfoL( const TDesC8& aProtocolInfo ) 

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::SetProtocolInfoL" );

    iProtocolInfo = aProtocolInfo.AllocL();    

    }

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

// CUpnpResParameters::SetMimetypeL

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

//  

void CUpnpResParameters::SetMimetypeL( const TDesC8& aMimetype )

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::SetMimetypeL" );

    iMimetype = aMimetype.AllocL();

    }

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

// CUpnpResParameters::SetFileSize

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

//

void CUpnpResParameters::SetFileSize( TInt aFileSize )

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::SetFileSize" );

    iFileSize = aFileSize;

    }

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

// CUpnpResParameters::SetResolution

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

//

void CUpnpResParameters::SetResolution( TSize aResolution ) 

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::SetResolution" );

    iResolution = aResolution;

    }

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

// CUpnpResParameters::SetDurationInSeconds

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

//

void CUpnpResParameters::SetDurationInSeconds( TInt64 aDuration ) 

    {

    __LOG( "[UPnPDlnaProfiler] CUpnpResParameters::\

SetDurationInSeconds" );

    iDurationInSeconds = aDuration;

    }

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

// CUpnpResParameters::MimeType

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

//    

const TDesC8& CUpnpResParameters::MimeType() 

    {

    if ( iMimetype ) 

        {

        return *iMimetype;

        }

    return KNullDesC8();

    }

// end of file