/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#include <S32STRM.H>

#include <S32MEM.H>

#include "VCXTestLog.h"

#include "CIptvTestActiveWait.h"

#include "VCXTestCommon.h"

#include "FusionMpxPlayerTester.h"

#include "FusionMpxPlayerTestCommon.h"

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxviewutility.h>

#include <mpxmediabase.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectionutility.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxcollectionplaylist.h>

#include <mpxvideoplaybackdefs.h>

#include <vcxmyvideosuids.h>

#include <vcxmyvideosdefs.h>

// CONSTANTS

// From mpxvideoplayerconstants.h

const TUid KVideoPlaybackViewUid = { 0x200159AD };

_LIT8( KDATATYPEVIDEOHELIX, "video/videohelix" );

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

// CFusionMpxPlayerTester::NewL

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

//

CFusionMpxPlayerTester* CFusionMpxPlayerTester::NewL( MFusionMpxPlayerTesterObserver* aObserver )

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::NewL");

    CFusionMpxPlayerTester* self = new (ELeave) CFusionMpxPlayerTester();

    CleanupStack::PushL(self);

    self->ConstructL( aObserver );

    CleanupStack::Pop(self);

    VCXLOGLO1("<<<CFusionMpxPlayerTester::NewL");

    return self;

    }

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

// CFusionMpxPlayerTester::CFusionMpxPlayerTester

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

//

CFusionMpxPlayerTester::CFusionMpxPlayerTester()

    {

    }

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

// CFusionMpxPlayerTester::ConstructL

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

//

void CFusionMpxPlayerTester::ConstructL( MFusionMpxPlayerTesterObserver* aObserver )

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::ConstructL");

    iWait = CIptvTestActiveWait::NewL();

    iObserver = aObserver;

    iViewUtility = MMPXViewUtility::UtilityL();

    iViewUtility->AddObserverL( this );

    iViewUtility->ConstructDefaultViewHistoryL();

    VCXLOGLO1("<<<CFusionMpxPlayerTester::ConstructL");

    }

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

// CFusionMpxPlayerTester::~CFusionMpxPlayerTester

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

//

CFusionMpxPlayerTester::~CFusionMpxPlayerTester()

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::~CFusionMpxPlayerTester");

    if ( iViewUtility )

        {

        iViewUtility->RemoveObserver( this );

        iViewUtility->Close();

        VCXLOGLO1("CFusionMpxPlayerTester::~CFusionMpxPlayerTester - viewUtility destroyed.");

        }

    if( iPlaybackUtility )

        {

        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) ); 

        iPlaybackUtility->Close();

        VCXLOGLO1("CFusionMpxPlayerTester::~CFusionMpxPlayerTester - playbackutility destroyed.");

        }

    iExpectedGeneralMessages.Reset();

    delete iWait;

    iWait = NULL;    

    VCXLOGLO1("<<<CFusionMpxPlayerTester::~CFusionMpxPlayerTester");

    }

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

// CFusionMpxPlayerTester::OpenLocalFile

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

//

TInt CFusionMpxPlayerTester::OpenLocalFile( const TDesC& aFileName )

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::OpenLocalFile");

    VCXLOGLO2("CFusionMpxPlayerTester::OpenLocalFileL: aFileName: %S", &aFileName);

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EPlayerChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialising, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EMediaChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

    // Start playback is always true

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EInitializeComplete, KFusionTestMsgNone, 1 ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialised, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyPosition, 0 ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateBuffering, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

    if( !iPlaybackUtility )

        {

        iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer );

        iPlaybackUtility->AddObserverL( *this );

        iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse );

        }

    TInt err( KErrNone );

    TRAP( err, iViewUtility->PreLoadViewL( KVideoPlaybackViewUid ) );

    if( err == KErrNone ) 

        {       

        TRAP( err, iPlaybackUtility->InitL( aFileName ) );

        }

    else

        {

        VCXLOGLO2("CFusionMpxPlayerTester:: PreLoadViewL left: %d", err);

        }

    VCXLOGLO1("<<<CFusionMpxPlayerTester::OpenLocalFile");

    return err;

    }

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

// CFusionMpxPlayerTester::OpenUrlL

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

//

void CFusionMpxPlayerTester::OpenUrlL( const TDesC& aUrl, TInt aIapId )

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::OpenUrlL");

    VCXLOGLO2("CFusionMpxPlayerTester::OpenUrlL: aUrl: %S", &aUrl);

    VCXLOGLO2("CFusionMpxPlayerTester::OpenUrlL: aIapId: %d", aIapId);

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EPlayerChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialising, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EMediaChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

    // Start playback is always true

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EInitializeComplete, KFusionTestMsgNone, 1 ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialised, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyPosition, 0 ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateBuffering, KFusionTestMsgNone ) );

    iExpectedGeneralMessages.Append( 

            TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

    if( !iPlaybackUtility )

        {

        iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer );

        iPlaybackUtility->AddObserverL( *this );

        iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse );

        }

    TInt err( KErrNone );

    TRAP( err, iViewUtility->PreLoadViewL( KVideoPlaybackViewUid ) );

    if( err == KErrNone ) 

        {       

        iPlaybackUtility->InitStreamingL( aUrl,

                                      (TDesC8*)(&KDATATYPEVIDEOHELIX),

                                      aIapId );

        }

    else

        {

        VCXLOGLO2("CFusionMpxPlayerTester:: PreLoadViewL left: %d", err);

        }    

    VCXLOGLO1("<<<CFusionMpxPlayerTester::OpenUrlL");

    }

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

//   CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL()

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

//

void CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL( TMPXPlaybackCommand aCmd, TInt aData )

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL");

    TBuf<256> cmdName;

    GetGeneralPlaybackCommandDes( aCmd, cmdName );

    VCXLOGLO2(">>>CFusionMpxPlayerTester:: cmd: %S", &cmdName);

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );

    cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );

    cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, aCmd );

    AddExpectedGeneralPlaybackCommandMessages( aCmd, aData );

    if( aData != KTestUndefined )

        {

        cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralData, aData );

        }

    iPlaybackUtility->CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

    if( iExpectedGeneralMessages.Count() == 0 )

        {

        iObserver->TesterCommandComplete();

        }

    VCXLOGLO2("<<<CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL (%d)", aCmd );

    }

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

// CFusionMpxPlayerTester::CreateVideoPlaybackCommandL

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

//

void CFusionMpxPlayerTester::CreateVideoPlaybackCommandL( TMPXVideoPlaybackCommand aCmd )

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::CreateVideoPlaybackCommandL");

    TBuf<256> cmdName;

    GetVideoPlaybackCommandDes( aCmd, cmdName );

    VCXLOGLO2(">>>CFusionMpxPlayerTester:: cmd: %S", &cmdName);

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

    cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback );

    cmd->SetTObjectValueL<TMPXVideoPlaybackCommand>(KMPXMediaVideoPlaybackCommand, aCmd );

    AddExpectedVideoPlaybackCommandMessages( aCmd );

    iPlaybackUtility->CommandL( *cmd );

    CleanupStack::PopAndDestroy( cmd );

    if( iExpectedGeneralMessages.Count() == 0 )

        {

        iObserver->TesterCommandComplete();

        }

    VCXLOGLO1("<<<CFusionMpxPlayerTester::CreateVideoPlaybackCommandL");

    }

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

// CFusionMpxPlayerTester::CheckExpectedMessages

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

//

TInt CFusionMpxPlayerTester::CheckExpectedMessages()

    {

    VCXLOGLO1(">>>CFusionMpxPlayerTester::CheckExpectedMessages");

    TInt err( KErrNone );

    if( iExpectedGeneralMessages.Count() > 0 )

        {

        err = KErrCorrupt;

        VCXLOGLO1("CFusionMpxPlayerTester:: Did not get all expected general messages, error!");

        for( TInt i=0; i<iExpectedGeneralMessages.Count(); i++ )

            {

            TBuf<256> eventBuff( _L("") );

            TBuf<256> typeBuff( _L("") );

            TBuf<64> dataBuff( _L("") );

            TInt event = iExpectedGeneralMessages[i].iEvent;

            GetGeneralPlaybackEventDes( event, eventBuff );

            if( iExpectedGeneralMessages[i].iData != KFusionTestMsgNone )

                {

                dataBuff.AppendNum( iExpectedGeneralMessages[i].iData );

                }

            if( event == TMPXPlaybackMessage::EStateChanged )

                {

                GetStateDes( static_cast<TMPXPlaybackState>(iExpectedGeneralMessages[i].iType), typeBuff );

                }

            if( event == TMPXPlaybackMessage::EPropertyChanged )

                {

                GetPropertyDes( static_cast<TMPXPlaybackProperty>(iExpectedGeneralMessages[i].iType), typeBuff );

                }

            VCXLOGLO4("CFusionMpxPlayerTester:: event %S = %S ( %S )", &eventBuff, &typeBuff, &dataBuff);

            }

        }

    VCXLOGLO1("<<<CFusionMpxPlayerTester::CheckExpectedMessages");

    return err;

    }

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

// CFusionMpxPlayerTester::AddExpectedGeneralPlaybackCommandMessages

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

//

void CFusionMpxPlayerTester::AddExpectedGeneralPlaybackCommandMessages( TMPXPlaybackCommand aCmd, TInt &aData )

    {

    switch( aCmd )

        {

        case EPbCmdPlay: // 0 Play which ever track is currently stopped, paused etc.

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

            }

            break;

        case EPbCmdPlayWithFadeIn: // 1 uses KPbFadeInDuration

            {

            }

            break;

        case EPbCmdPause:    // 2

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePaused, KFusionTestMsgNone ) );

            }

            break;

        case EPbCmdStop:     // 3

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateStopped, KFusionTestMsgNone ) );

            }

            break;

        case EPbCmdNext:     // 4 No effect if no next track

            {

            }

            break;

        case EPbCmdPrevious: // 5 No effect if no previous track;

                        //   if pos>KPbReplayThreshold, replays current track

            {

            }

            break;

        case EPbCmdReplay:   // 6 Restart current track at beginning

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyPosition, 0 ) );           

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

            }

            break;

        case EPbCmdStartSeekForward:  // 7

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateSeekingForward, KFusionTestMsgNone ) );

            }

            break;

        case EPbCmdStartSeekBackward: // 8

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateSeekingBackward, KFusionTestMsgNone ) );

            }

            break;

        case EPbCmdStopSeeking:       // 9

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

            }

            break;

        case EPbCmdIncreaseVolume:    // 10

            {

            VCXLOGLO1("CFusionMpxPlayerTester:: Getting volume.");

            // Get volume.

            iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

            iWait->Start();

            TInt vol = iVolume + 10;

            if( vol > 100 ) vol = 100;

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, vol ) );           

            }

            break;

        case EPbCmdDecreaseVolume:    // 11

            {

            // Get volume.

            iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

            iWait->Start();

            TInt vol = iVolume - 10;

            if( vol < 0 ) 

                {

                vol = 0;

                }

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, vol ) );           

            }

            break;

        case EPbCmdMuteVolume:        // 12

            {

            // Get volume.

            iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

            iWait->Start();

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, 0 ) );

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyMute, 1 ) );

            iVolumeBeforeMute = iVolume;

            }

            break;

        case EPbCmdUnMuteVolume:      // 13

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, iVolumeBeforeMute ) );

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyMute, 0 ) );

            }

            break;

        case EPbCmdClose:             // 14

            {

            iExpectedGeneralMessages.Append( 

                    TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateStopped, KFusionTestMsgNone ) );

            }

            break;

        case EPbApplyEffect:          // 15 Apply an effect to the current playback,

                                 //    aData used to identify effect

            {

            }

            break;

        case EPbCmdPreservePosition:  // 16 Preserve playback position

            {

            }

            break;

        case EPbCmdPreserveState:     // 17 Preserve playback state

            {

            }

            break;

        case EPbCmdCloseItem:         // 18 Request to close the file handle

            {

            }

            break;

        case EPbCmdPlayPause:         // 19 Play/Pause toggle command

            {

            if( iState == EPbStatePlaying )

                {

                iExpectedGeneralMessages.Append( 

                        TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePaused, KFusionTestMsgNone ) );

                }

            else

            if( iState == EPbStatePaused )

                {

                iExpectedGeneralMessages.Append( 

                        TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

                }

            }

            break;

        case EPbCmdCancelInit:         // 20

            {

            if( !iInitComplete )

                {

                iExpectedGeneralMessages.Reset();

                iExpectedGeneralMessages.Append( 

                        TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateStopped, KFusionTestMsgNone ) );

                }

            }

            break;

        case EPbCmdResetPreserveState: // 21

            {

            }

            break;

        case EPbCmdUnloadNonActivePlugin: // 22 KMPXCommandPlaybackGeneralData is TUid.iUid

            {

            }