/*
* Copyright (c) 2009 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:  Implement the operation: GetInterdenpendentPropDesc
*
*/


#include "cmediamtpdataprovidergetinterdependentpropdesc.h"
#include "mediamtpdataproviderconst.h"
#include "mmmtpdplogger.h"
#include "tobjectdescription.h"
#include "mmmtpdpdefs.h"
#include "mmmtpdpconfig.h"

// -----------------------------------------------------------------------------
// CMediaMtpDataProviderGetInterDependentPropDesc::NewL
// Two-phase construction method
// -----------------------------------------------------------------------------
//
MMmRequestProcessor* CMediaMtpDataProviderGetInterDependentPropDesc::NewL( MMTPDataProviderFramework& aFramework,
    MMTPConnection& aConnection,
    MMmMtpDpConfig& aDpConfig )
    {
    CMediaMtpDataProviderGetInterDependentPropDesc* self =
        new ( ELeave ) CMediaMtpDataProviderGetInterDependentPropDesc( aFramework,
            aConnection );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CMediaDpMtpGetInterDependentPropDesc::ConstructL
// Two-phase construction method
// -----------------------------------------------------------------------------
//
void CMediaMtpDataProviderGetInterDependentPropDesc::ConstructL()
    {

    }

// -----------------------------------------------------------------------------
// CMediaMtpDataProviderGetInterDependentPropDesc::~CMediaMtpDataProviderGetInterDependentPropDesc
// Destructor
// -----------------------------------------------------------------------------
//
CMediaMtpDataProviderGetInterDependentPropDesc::~CMediaMtpDataProviderGetInterDependentPropDesc()
    {
    delete iDataset;
    delete iProperties;
    }

// -----------------------------------------------------------------------------
// CMTPGetInterDependentPropDesc::CMTPGetInterDependentPropDesc
// Standard c++ constructor
// -----------------------------------------------------------------------------
//
CMediaMtpDataProviderGetInterDependentPropDesc::CMediaMtpDataProviderGetInterDependentPropDesc( MMTPDataProviderFramework& aFramework,
    MMTPConnection& aConnection ) :
    CRequestProcessor( aFramework, aConnection, 0, NULL )
    {
    PRINT( _L( "Operation: GetInterdependentPropDesc(0x9807)" ) );
    }

// -----------------------------------------------------------------------------
// CMediaMtpDataProviderGetInterDependentPropDesc::CheckRequestL
// Verify the reqeust and returns it
// -----------------------------------------------------------------------------
//
TMTPResponseCode CMediaMtpDataProviderGetInterDependentPropDesc::CheckRequestL()
    {
    TMTPResponseCode responseCode = CRequestProcessor::CheckRequestL();
    iFormatCode = Request().Uint32( TMTPTypeRequest::ERequestParameter1 );

    if ( EMTPRespCodeOK == responseCode )
        {
        TInt count = sizeof( KMediaMtpDataProviderSupportedFormats ) / sizeof( TUint16 );

        responseCode = EMTPRespCodeInvalidObjectFormatCode;

        for ( TInt i = 0; i < count; i++ )
            {
            if ( iFormatCode == KMediaMtpDataProviderSupportedFormats[i] )
                {
                responseCode = EMTPRespCodeOK;
                break;
                }
            }
        }

    return responseCode;
    }

// -----------------------------------------------------------------------------
// CMediaMtpDataProviderGetInterDependentPropDesc::ServiceL
// service a request at request phase
// -----------------------------------------------------------------------------
//
void CMediaMtpDataProviderGetInterDependentPropDesc::ServiceL()
    {
    PRINT( _L( "MM MTP => CMediaMtpDataProviderGetInterDependentPropDesc::ServiceL" ) );

    // Clear the data set.
    delete iDataset;
    iDataset = NULL;
    iDataset = CMTPTypeInterdependentPropDesc::NewL();

    TBool audioWaveCodecSupported = EFalse;
    TBool audioBitRateSupported = EFalse;
    TBool videoFourCcCodecSupported = EFalse;
    TBool videoBitRateSupported = EFalse;

    switch ( iFormatCode )
        {
        case EMTPFormatCodeWMA:
        case EMTPFormatCodeMP3:
        case EMTPFormatCodeAAC:
        case EMTPFormatCodeWAV:
            {
            TInt count = sizeof( KMmMtpDpSupportedPropMandatoryAudio ) / sizeof( TUint16 );

            for ( TInt i = 0; i < count; i++ )
                {
                switch ( KMmMtpDpSupportedPropMandatoryAudio[i] )
                    {
                    case EMTPObjectPropCodeAudioWAVECodec:
                        audioWaveCodecSupported = ETrue;
                        break;
                    case EMTPObjectPropCodeAudioBitRate:
                        audioBitRateSupported = ETrue;
                        break;
                    default:
                        PRINT( _L( "MM MTP <> CMediaMtpDataProviderGetInterDependentPropDesc::ServiceL default" ) );
                        // do nothing
                        break;
                    }
                }
            }
            break;

        case EMTPFormatCodeMP4Container:
            {
            TInt count = sizeof( KMmMtpDpSupportedPropMandatoryAudio ) / sizeof( TUint16 );

            for ( TInt i = 0; i < count; i++ )
                {
                switch ( KMmMtpDpSupportedPropMandatoryAudio[i] )
                    {
                    case EMTPObjectPropCodeAudioWAVECodec:
                        audioWaveCodecSupported = ETrue;
                        break;
                    case EMTPObjectPropCodeAudioBitRate:
                        audioBitRateSupported = ETrue;
                        break;
                    default:
                        // do nothing
                        break;
                    }
                }
            }
            break;

        case EMTPFormatCode3GPContainer:
            {
            TInt count = sizeof( KMmMtpDpSupportedPropMandatoryAudio ) / sizeof( TUint16 );

            for ( TInt i = 0; i < count; i++ )
                {
                switch ( KMmMtpDpSupportedPropMandatoryAudio[i] )
                    {
                    case EMTPObjectPropCodeAudioWAVECodec:
                        audioWaveCodecSupported = ETrue;
                        break;
                    case EMTPObjectPropCodeAudioBitRate:
                        audioBitRateSupported = ETrue;
                        break;
                    default:
                        // do nothing
                        break;
                    }
                }
            }
            break;

        case EMTPFormatCodeWMV:
        case EMTPFormatCodeASF:
            {
            TInt count = sizeof( KMmMtpDpSupportedPropMandatoryWMV ) / sizeof( TUint16 );

            for ( TInt i = 0; i < count; i++ )
                {
                switch (KMmMtpDpSupportedPropMandatoryWMV[i] )
                    {
                    case EMTPObjectPropCodeAudioWAVECodec:
                        audioWaveCodecSupported = ETrue;
                        break;
                    case EMTPObjectPropCodeAudioBitRate:
                        audioBitRateSupported = ETrue;
                        break;
                    case EMTPObjectPropCodeVideoFourCCCodec:
                        videoFourCcCodecSupported = ETrue;
                        break;
                    case EMTPObjectPropCodeVideoBitRate:
                        videoBitRateSupported = ETrue;
                        break;
                    default:
                        // do nothing
                        break;
                    }
                }
            }
            break;

        default:
            {
            PRINT1( _L( "MM MTP <> CMediaMtpDataProviderGetInterDependentPropDesc::ServiceL leave because of invalid formatcode = 0x%x" ), iFormatCode );
            User::Leave( KErrNotSupported );
            }
            break;
        }

    if ( audioWaveCodecSupported && audioBitRateSupported )
        {
        if ( videoFourCcCodecSupported && videoBitRateSupported )
            {
            iProperties = CMTPTypeInterdependentProperties::NewL();
            ServiceVideoFourCCCodecL();
            ServiceVideoBitrateL();
            iDataset->AppendL( iProperties );
//            CleanupStack::Pop();
            iProperties = NULL;
            }

        iProperties = CMTPTypeInterdependentProperties::NewL();
        ServiceAudioWaveCodecL();
        ServiceAudioBitrateL();
        iDataset->AppendL( iProperties );
//        CleanupStack::Pop();
        iProperties = NULL;
        }

    // Send the dataset.
    SendDataL( *iDataset );
    PRINT( _L( "MM MTP <= CMediaMtpDataProviderGetInterDependentPropDesc::ServiceL" ) );
    }

// -----------------------------------------------------------------------------
// CMediaMtpDataProviderGetInterDependentPropDesc::ServiceAudioWaveCodecL
//
// -----------------------------------------------------------------------------
//
void CMediaMtpDataProviderGetInterDependentPropDesc::ServiceAudioWaveCodecL()
    {
    CMTPTypeObjectPropDescEnumerationForm* form =
        CMTPTypeObjectPropDescEnumerationForm::NewLC( EMTPTypeUINT32 );

    switch( iFormatCode )
        {
        case EMTPFormatCodeWMA:
        case EMTPFormatCodeWMV:
        case EMTPFormatCodeASF:
            form->AppendSupportedValueL( TMTPTypeUint32( EMTPAudioWAVECodecWMA ) );
            break;

        case EMTPFormatCodeMP3:
            form->AppendSupportedValueL( TMTPTypeUint32( EMTPAudioWAVECodecMP3 ) );
            break;

        case EMTPFormatCodeMP4Container:
        case EMTPFormatCode3GPContainer:
        case EMTPFormatCodeAAC:
            form->AppendSupportedValueL( TMTPTypeUint32( EMTPAudioWAVECodecAAC ) );
            break;

        case EMTPFormatCodeWAV:
            form->AppendSupportedValueL( TMTPTypeUint32( EMTPAudioWAVECodecPCM ) );
            break;

        default:
            PRINT1( _L( "MM MTP <> CMediaMtpDataProviderGetInterDependentPropDesc::ServiceAudioWaveCodecL leave because of invalid formatcode = 0x%x" ), iFormatCode );
            User::Leave( KErrNotSupported );
            break;
        }

    CMTPTypeObjectPropDesc::TPropertyInfo propInfo;
    propInfo.iDataType = EMTPTypeUINT32;
    propInfo.iFormFlag = CMTPTypeObjectPropDesc::EEnumerationForm;
    propInfo.iGetSet = CMTPTypeObjectPropDesc::EReadWrite;
    SetFormForResponseL( EMTPObjectPropCodeAudioWAVECodec, propInfo, form );
    CleanupStack::PopAndDestroy( form );
    }

// -----------------------------------------------------------------------------
// CMediaMtpDataProviderGetInterDependentPropDesc::ServiceAudioBitrateL
//
// -----------------------------------------------------------------------------
//
void CMediaMtpDataProviderGetInterDependentPropDesc::ServiceAudioBitrateL()
    {
    switch( iFormatCode )
        {
        case EMTPFormatCodeWMA:
        case EMTPFormatCodeWMV:
        case EMTPFormatCodeASF:
            ServiceRangeFormDescriptionL( EMTPObjectPropCodeAudioBitRate,
                EMTPWMAMinBitrate,
                EMTPWMAMaxBitrate,
                EMTPAudioBitrateStep );
            break;

        case EMTPFormatCodeMP3:
            ServiceRangeFormDescriptionL( EMTPObjectPropCodeAudioBitRate,
                EMTPMP3MinBitrate,
                EMTPMP3MaxBitrate,
                EMTPAudioBitrateStep );
            break;

        case EMTPFormatCodeAAC:
            ServiceRangeFormDescriptionL( EMTPObjectPropCodeAudioBitRate,
                EMTPAACMinBitrate,
                EMTPAACMaxBitrate,
                EMTPAudioBitrateStep );
            break;

        case EMTPFormatCodeWAV:
            ServiceRangeFormDescriptionL( EMTPObjectPropCodeAudioBitRate,
                EMTPPCMMinBitrate,
                EMTPPCMMaxBitrate,
                EMTPAudioBitrateStep );
            break;

        case EMTPFormatCodeMP4Container:
        case EMTPFormatCode3GPContainer:
            ServiceRangeFormDescriptionL( EMTPObjectPropCodeAudioBitRate,
                EMTPAACPlusMinBitrate,
                EMTPAACPlusMaxBitrate,
                EMTPAudioBitrateStep );
            break;

        default:
            PRINT1( _L( "MM MTP <> CMediaMtpDataProviderGetInterDependentPropDesc::ServiceAudioBitrateL leave because of invalid formatcode = 0x%x" ), iFormatCode );
            User::Leave( KErrNotSupported );
            break;
        }
    }

// -----------------------------------------------------------------------------
// CMediaMtpDataProviderGetInterDependentPropDesc::ServiceVideoFourCCCodecL
// Create Description and create new ObjectPropDesc
// -----------------------------------------------------------------------------
//
void CMediaMtpDataProviderGetInterDependentPropDesc::ServiceVideoFourCCCodecL()
    {
    switch( iFormatCode )
        {
        case EMTPFormatCodeWMV:
        case EMTPFormatCodeASF:
            {
            CMTPTypeObjectPropDescEnumerationForm* form =
                CMTPTypeObjectPropDescEnumerationForm::NewL( EMTPTypeUINT32 );
            CleanupStack::PushL( form ); // + form

            TUint32 values[] =
                {
                EMTPVideoFourCCCodecWMV3
                };

            TInt numValues = sizeof ( values ) / sizeof ( values[0] ) ;
            for ( TInt i = 0; i < numValues; i++ )
                {
                TMTPTypeUint32 data( values[i] );
                form->AppendSupportedValueL( data );
                }
            // TODO:
            CMTPTypeObjectPropDesc::TPropertyInfo propInfo;
            propInfo.iDataType = EMTPTypeUINT32;
            propInfo.iFormFlag = CMTPTypeObjectPropDesc::EEnumerationForm;
            propInfo.iGetSet = CMTPTypeObjectPropDesc::EReadWrite;
            SetFormForResponseL( EMTPObjectPropCodeVideoFourCCCodec, propInfo, form );
            CleanupStack::PopAndDestroy( form ); // - form
            }
            break;

        default:
            {
            PRINT1( _L( "MM MTP <> CMediaMtpDataProviderGetInterDependentPropDesc::ServiceVideoFourCCCodecL leave because of invalid formatcode = 0x%x" ), iFormatCode );
            User::Leave( KErrNotSupported );
            }
            break;
        }
    }

void CMediaMtpDataProviderGetInterDependentPropDesc::ServiceVideoBitrateL()
    {
    switch( iFormatCode )
        {
        case EMTPFormatCodeWMV:
        case EMTPFormatCodeASF:
            ServiceRangeFormDescriptionL( EMTPObjectPropCodeVideoBitRate,
                EMTPWMVMinBitrate,
                EMTPWMVMaxBitrate,
                EMTPVideoBitrateStep,
                ETrue );
            break;

        default:
            PRINT1( _L( "MM MTP <> CMediaMtpDataProviderGetInterDependentPropDesc::ServiceVideoBitrateL leave because of invalid formatcode = 0x%x" ), iFormatCode );
            User::Leave( KErrNotSupported );
            break;
        }
    }

void CMediaMtpDataProviderGetInterDependentPropDesc::ServiceRangeFormDescriptionL( TUint16 aPropCode,
    TUint32 aMinValue,
    TUint32 aMaxValue,
    TUint32 aStepValue,
    TBool aIsReadOnly )
    {
    CMTPTypeObjectPropDescRangeForm* form =
        CMTPTypeObjectPropDescRangeForm::NewLC( EMTPTypeUINT32 ); // + form

    // Set expected values
    form->SetUint32L( CMTPTypeObjectPropDescRangeForm::EMinimumValue, aMinValue );
    form->SetUint32L( CMTPTypeObjectPropDescRangeForm::EMaximumValue, aMaxValue );
    form->SetUint32L( CMTPTypeObjectPropDescRangeForm::EStepSize, aStepValue );

    CMTPTypeObjectPropDesc::TPropertyInfo propInfo;
    propInfo.iDataType = EMTPTypeUINT32;
    propInfo.iFormFlag = CMTPTypeObjectPropDesc::ERangeForm;
    propInfo.iGetSet = !aIsReadOnly;
    SetFormForResponseL( aPropCode, propInfo, form );
    CleanupStack::PopAndDestroy( form ); // - form
    }

void CMediaMtpDataProviderGetInterDependentPropDesc::SetFormForResponseL( TUint16 aPropertyCode,
    CMTPTypeObjectPropDesc::TPropertyInfo& aPropInfo,
    const MMTPType* aForm )
    {
    CMTPTypeObjectPropDesc* propertyDesc = CMTPTypeObjectPropDesc::NewLC( aPropertyCode,
        aPropInfo,
        aForm );
    // Set group code
    propertyDesc->SetUint32L( CMTPTypeObjectPropDesc::EGroupCode, EGroupCodeMediaDB );

    iProperties->AppendL( propertyDesc );
    CleanupStack::Pop( propertyDesc );
    }

// end of file