// Copyright (c) 2010 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:

//

/**

 @file

 @internalComponent

*/

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include "cmtpplaybackmap.h"

#include "cmtpplaybackcommand.h"

#include "cmtpplaybackcontroldp.h"

#include "mtpplaybackcontrolpanic.h"

const TInt KPlaybackRatePlay = 1000;

const TInt KPlaybackRatePause = 0;

const TInt KPlaybackRateFF = 2000;

const TInt KPlaybackRateREW = -2000;

/**

Two-phase constructor.

@param aPlugin The data provider plugin

@return a pointer to the created playback checker object

*/  

CMTPPlaybackMap* CMTPPlaybackMap::NewL(MMTPDataProviderFramework& aFramework,

                                       CMTPPlaybackProperty& aProperty)

    {

    CMTPPlaybackMap* self = new (ELeave) CMTPPlaybackMap(aFramework, aProperty);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor.

*/    

CMTPPlaybackMap::~CMTPPlaybackMap()

    {    

    }

/**

Constructor.

*/    

CMTPPlaybackMap::CMTPPlaybackMap(MMTPDataProviderFramework& aFramework, 

                                 CMTPPlaybackProperty& aProperty):

    iFramework(aFramework),iProperty(aProperty)

    {    

    }

/**

Second-phase constructor.

*/        

void CMTPPlaybackMap::ConstructL()

    {

    }

TInt CMTPPlaybackMap::GetPlaybackControlCommand(const TMTPPbCtrlData& aData, 

                                                CMTPPlaybackCommand** aCmd)

    {

    TInt result = KErrNotSupported;

    switch(aData.iOptCode)

        {

        case EMTPOpCodeSetDevicePropValue:

        case EMTPOpCodeResetDevicePropValue:

            {

            result = HandleSetDevicePropValue(aData, aCmd);            

            }

            break;

        case EMTPOpCodeGetDevicePropValue:

        case EMTPOpCodeGetDevicePropDesc:

            {

            result = HandleGetDevicePropValue(aData, aCmd);            

            }

            break;

        case EMTPOpCodeSkip:

            {

            result = HandleSkip(aData, aCmd);            

            }

            break;

        default:

            break;

        }

    return result;

    }

TInt CMTPPlaybackMap::HandleSetDevicePropValue(const TMTPPbCtrlData& aData, 

                                               CMTPPlaybackCommand** aCmd)

    {

    TRAPD(err, HandleSetDevicePropValueL(aData, aCmd));

    return err;

    }

void CMTPPlaybackMap::HandleSetDevicePropValueL(const TMTPPbCtrlData& aData, 

                                               CMTPPlaybackCommand** aCmd)

    {

    __ASSERT_DEBUG((aData.iOptCode == EMTPOpCodeSetDevicePropValue) ||

                    (aData.iOptCode == EMTPOpCodeResetDevicePropValue),

                    Panic(EMTPPBArgumentErr));

    switch(aData.iDevPropCode)

        {

        case EMTPDevicePropCodeVolume:

            {

            TUint32 val = aData.iPropValUint32.Value();

            CMTPPbCmdParam* param = CMTPPbCmdParam::NewL(val);

            CleanupStack::PushL(param);

            *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdSetVolume, param);

            CleanupStack::Pop(param);

            }

            break;

        case EMTPDevicePropCodePlaybackRate:

            {

            TInt32 val = aData.iPropValInt32.Value();

            TMTPPlaybackCommand cmd = EPlaybackCmdNone;

            switch(val)

                {

                case KPlaybackRateFF:

                    cmd = EPlaybackCmdSeekForward;

                    break;

                case KPlaybackRatePlay:

                    cmd = EPlaybackCmdPlay;

                    break;

                case KPlaybackRatePause:

                    cmd = EPlaybackCmdPause;

                    break;

                case KPlaybackRateREW:

                    cmd = EPlaybackCmdSeekBackward;

                    break;

                default:

                    break;

                }

            if(cmd != EPlaybackCmdNone)

                {

                *aCmd = CMTPPlaybackCommand::NewL(cmd, NULL);

                }

            else

                {

                *aCmd = NULL;

                }

            }

            break;

        case EMTPDevicePropCodePlaybackObject:

            {

            TUint32 handle = aData.iPropValUint32.Value();

            if(handle == 0)

                {

                *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdStop, NULL);

                }

            else

                {

                TFileName suid;

                TUint format;

                GetObjecInfoFromHandleL(handle, suid, format);

                TMTPPbCategory cat = EMTPPbCatNone;

                switch(format)

                    {

                    case 0xBA05://Abstract Audio & Video Playlist

                    case 0xBA11://M3U Playlist

                        cat = EMTPPbCatPlayList;

                        break;

                    case 0xBA03://Abstract Audio Album

                        cat = EMTPPbCatAlbum;

                        break;

                    case 0x3009://MP3

                    case 0xB903://AAC (Advance Audio Coding)

                    case 0xB901://WMA (Windows Media Audio)

                    case 0x3008://WAV (Waveform audio format)

                        cat = EMTPPbCatMusic;

                        break;

                    default:

                        break;

                    }

                if(cat != EMTPPbCatNone)

                    {

                    CMTPPbCmdParam* param = CMTPPbCmdParam::NewL(cat, suid);

                    CleanupStack::PushL(param);

                    *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdInitObject, param);

                    CleanupStack::Pop(param);

                    }

                else

                    {

                    *aCmd = NULL;

                    }

                }

            }

            break;

        case EMTPDevicePropCodePlaybackContainerIndex:

            {

            TUint32 index = aData.iPropValUint32.Value();

            CMTPPbCmdParam* param = CMTPPbCmdParam::NewL(index);

            CleanupStack::PushL(param);

            *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdInitIndex, param);

            CleanupStack::Pop(param);

            }

            break;

        case EMTPDevicePropCodePlaybackPosition:

            {

            TUint32 position = aData.iPropValUint32.Value();

            CMTPPbCmdParam* param = CMTPPbCmdParam::NewL(position);

            CleanupStack::PushL(param);

            *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdSetPosition, param);

            CleanupStack::Pop(param);

            }

            break;

        default:

            break;

        }

    }

TInt CMTPPlaybackMap::HandleGetDevicePropValue(const TMTPPbCtrlData& aData, 

                                               CMTPPlaybackCommand** aCmd)

    {

    TRAPD(err, HandleGetDevicePropValueL(aData, aCmd));

    return err;

    }

void CMTPPlaybackMap::HandleGetDevicePropValueL(const TMTPPbCtrlData& aData, 

                                               CMTPPlaybackCommand** aCmd)

    {

    __ASSERT_DEBUG((aData.iOptCode == EMTPOpCodeGetDevicePropValue) ||

                    (aData.iOptCode == EMTPOpCodeGetDevicePropDesc),

                    Panic(EMTPPBArgumentErr));

    switch(aData.iDevPropCode)

        {

        case EMTPDevicePropCodeVolume:

            {

            TMTPPlaybackCommand cmd = EPlaybackCmdGetVolumeSet;

            if(aData.iOptCode == EMTPOpCodeGetDevicePropValue)

                {

                cmd = EPlaybackCmdGetVolume;

                }

            *aCmd = CMTPPlaybackCommand::NewL(cmd, NULL);

            }

            break;

        case EMTPDevicePropCodePlaybackRate:

            {

            *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdGetState, NULL);

            }

            break;

        case EMTPDevicePropCodePlaybackObject:

            {

            *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdGetObject, NULL);

            }

            break;

        case EMTPDevicePropCodePlaybackContainerIndex:

            {

            *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdGetIndex, NULL);

            }

            break;

        case EMTPDevicePropCodePlaybackPosition:

            {

            *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdGetPosition, NULL);

            }

            break;

        default:

            break;

        }

    }

TInt CMTPPlaybackMap::HandleSkip(const TMTPPbCtrlData& aData, 

                                 CMTPPlaybackCommand** aCmd)

    {

    TRAPD(err, HandleSkipL(aData, aCmd));

    return err;

    }

void CMTPPlaybackMap::HandleSkipL(const TMTPPbCtrlData& aData, 

                                 CMTPPlaybackCommand** aCmd)

    {

    TInt32 step = aData.iPropValInt32.Value();

    CMTPPbCmdParam* param = CMTPPbCmdParam::NewL(step);

    CleanupStack::PushL(param);

    *aCmd = CMTPPlaybackCommand::NewL(EPlaybackCmdSkip, param);

    CleanupStack::Pop(param);

    }

TInt32 CMTPPlaybackMap::PlaybackRateL(TMTPPlaybackState aState)

    {

    TInt32 rate = KPlaybackRatePause;

    switch(aState)

        {

        case EPlayStateForwardSeeking:

            rate = KPlaybackRateFF;

            break;

        case EPlayStatePlaying:

            rate = KPlaybackRatePlay;

            break;

        case EPlayStatePaused:

            rate = KPlaybackRatePause;

            break;

        case EPlayStateBackwardSeeking:

            rate = KPlaybackRateREW;

            break;

        default:

            break;

        }

    return rate;

    }

TUint32 CMTPPlaybackMap::ObjectHandleL(const TDesC& aSuid)

    {

    CMTPObjectMetaData* meta(CMTPObjectMetaData::NewLC());

    TBool result = iFramework.ObjectMgr().ObjectL(aSuid, *meta);

    __ASSERT_DEBUG(meta, Panic(EMTPPBDataNullErr));

    TUint32 handle = meta->Uint(CMTPObjectMetaData::EHandle);

    CleanupStack::PopAndDestroy(meta);

    return handle;

    }

void CMTPPlaybackMap::GetObjecInfoFromHandleL(TUint32 aHandle, TDes& aSuid, TUint& aFormat) const

    {

    CMTPObjectMetaData* meta(CMTPObjectMetaData::NewLC());

    TBool result = iFramework.ObjectMgr().ObjectL(aHandle, *meta);

    __ASSERT_DEBUG(meta, Panic(EMTPPBDataNullErr));

    aSuid = meta->DesC(CMTPObjectMetaData::ESuid);

    aFormat = meta->Uint(CMTPObjectMetaData::EFormatCode);

    CleanupStack::PopAndDestroy(meta);

    }