/**

* 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:   tester for methods in VideoSortFilterProxyModel

*

*/

// Version : %version:  16 %

#include <e32err.h>

#include <w32std.h>

#include <hbapplication.h>

#include <hbinstance.h>

#include <QDebug>

#include <mpxplaybackframeworkdefs.h>

#include <mpxplaybackutility.h>

#include <mpxcommonvideoplaybackview.hrh>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessage.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediavideodefs.h>

#include <vcxmyvideosuids.h>

#include <mpxmediageneralextdefs.h>

#include "mpxcollectionutility.h"

#include "mpxcollectionplaylist.h"

#include "testmpxvideoviewwrapper.h"

#include "../stub/inc/videobaseplaybackview.h"

#include "../stub/inc/videoplaybackviewfiledetails.h"

#include "../stub/inc/videoplaybackdisplayhandler.h"

#include "../stub/inc/videoplaybackcontrolscontroller.h"

#define protected public

#include "mpxvideoviewwrapper.h"

#undef protected

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

// main

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

//

int main(int argc, char *argv[])

{

    HbApplication app(argc, argv);

    HbMainWindow window;

    TestMPXVideoViewWrapper tv;

    char *pass[3];

    pass[0] = argv[0];

    pass[1] = "-o";

    pass[2] = "c:\\data\\testmpxvideoviewwrapper.txt";

    int res = QTest::qExec(&tv, 3, pass);

    return res;

}

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

// init

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

//

void TestMPXVideoViewWrapper::init()

{

    mBaseVideoView    = new VideoBasePlaybackView();

    TRAPD( err, mVideoViewWrapper = CMPXVideoViewWrapper::NewL( mBaseVideoView ) );

    QVERIFY( err == KErrNone );

}

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

// cleanup

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

//

void TestMPXVideoViewWrapper::cleanup()

{

    if ( mVideoViewWrapper )

    {

        delete mVideoViewWrapper;

        mVideoViewWrapper = NULL;

    }

    if ( mBaseVideoView )

    {

        delete mBaseVideoView;

        mBaseVideoView = NULL;

    }

}

void TestMPXVideoViewWrapper::testRequestMedia()

{

    init();

    //

    // If iMediaRequestStatus is not MediaNotRequested, doesn't request media

    //

    mVideoViewWrapper->iMediaRequestStatus = MediaDelivered;

    TRAPD(err, mVideoViewWrapper->RequestMediaL());

    QVERIFY( err == KErrNone );

    QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaDelivered );

    //

    // If iState is not EPbStateInitialised, doesn't request media

    //

    mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

    mVideoViewWrapper->iPlaybackUtility->iState = EPbStatePluginSeeking;

    TRAP(err, mVideoViewWrapper->RequestMediaL());

    QVERIFY( err == KErrNone );

    QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaNotRequested );

    //

    // If it is not playlist case, request playback media

    //

    mVideoViewWrapper->iPlaylistView = false;

    mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

    mVideoViewWrapper->iPlaybackUtility->iState = EPbStateInitialised;

    TRAP(err, mVideoViewWrapper->RequestMediaL());

    QVERIFY( err == KErrNone );

    QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaRequested );

    QVERIFY( ! mVideoViewWrapper->iCollectionMediaRequested );

    //

    // If it is playlist case && there isn't in memory plugin, request playback media

    //

    mVideoViewWrapper->iPlaylistView = true;

    mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

    mVideoViewWrapper->iPlaybackUtility->iState = EPbStateInitialised;

    mVideoViewWrapper->iCollectionUtility->Collection().iUid = TUid::Uid( KVcxUidMyVideosMpxCollection );

    TRAP(err, mVideoViewWrapper->RequestMediaL());

    QVERIFY( err == KErrNone );

    QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaRequested );

    QVERIFY( ! mVideoViewWrapper->iCollectionMediaRequested );

    //

    // If it is playlist case && there is in memory plugin, request collection media

    //

    mVideoViewWrapper->iPlaylistView = true;

    mVideoViewWrapper->iMediaRequestStatus = MediaNotRequested;

    mVideoViewWrapper->iPlaybackUtility->iState = EPbStateInitialised;

    mVideoViewWrapper->iCollectionUtility->Collection().iUid = TUid::Uid( KMpxInMemoryPluginUid );

    TRAP(err, mVideoViewWrapper->RequestMediaL());

    QVERIFY( err == KErrNone );

    QVERIFY( mVideoViewWrapper->iMediaRequestStatus == MediaRequested );

    QVERIFY( mVideoViewWrapper->iCollectionMediaRequested );

    cleanup();

}

void TestMPXVideoViewWrapper::testIsLive()

{

    init();

    TRAPD(err, mVideoViewWrapper->RequestMediaL());

    QVERIFY( err == KErrNone );

    mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLiveStreaming;

    QVERIFY( mVideoViewWrapper->IsLive() );

    mVideoViewWrapper->iFileDetails->mPlaybackMode = EMPXVideoLocal;

    QVERIFY( ! mVideoViewWrapper->IsLive() );

    cleanup();

}

void TestMPXVideoViewWrapper::testIsPlaylist()

{

    init();

    mVideoViewWrapper->iPlaylistView = true;

    QVERIFY( mVideoViewWrapper->IsPlaylist() == true );

    mVideoViewWrapper->iPlaylistView = false;

    QVERIFY( mVideoViewWrapper->IsPlaylist() == false );

    cleanup();

}

void TestMPXVideoViewWrapper::testHandleCommand()

{

    init();

    TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL() );

    QVERIFY( errReqMedia == KErrNone );

    //

    // Test 'Play' command

    //

    TRAPD( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlay ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

    //

    // Test 'Pause' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPause ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPause );

    //

    // Test 'Close' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdClose ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdClose );

    //

    // Test 'Seek Forward' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdSeekForward ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStartVideoSeekingForward );

    //

    // Test 'Seek Backward' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdSeekBackward ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStartVideoSeekingBackward );

    //

    // Test 'End Seek' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdEndSeek ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStopVideoSeeking );

    //

    // Test 'PlayPause' command

    //

    mVideoViewWrapper->iPlaybackState = EPbStatePlaying;

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlayPause ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPause );

    mVideoViewWrapper->iPlaybackState = EPbStatePaused;

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPlayPause ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

    //

    // Test 'Stop' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStop ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdStop );

    //

    // Test 'Decrease Volume' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdDecreaseVolume ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleDecreaseVolume );

    //

    // Test 'Increase Volume' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdIncreaseVolume ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdHandleIncreaseVolume );

    //

    // Test 'Natural Aspect Ratio' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdNaturalAspectRatio ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdNaturalAspectRatio );

    //

    // Test 'Zoom Aspect Ratio' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdZoomAspectRatio ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdZoomAspectRatio );

    //

    // Test 'Stretch Aspect Ratio' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdStretchAspectRatio ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iDisplayHandler->iCommand == EPbCmdStretchAspectRatio );

    //

    // Test 'Mute' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdMute ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdMuteVolume );

    //

    // Test 'Un-mute' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdUnMute ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdUnMuteVolume );

    //

    // Test 'Short Press Backward' command

    //

    mVideoViewWrapper->iPlaylistView = false;

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdShortPressBackward ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == EPbPropertyPosition );

    //

    // Test 'Reset Controls' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdResetControls ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdInitView );

    //

    // Test 'Next List Item' command

    //

    mVideoViewWrapper->iPlaylistView = true;

    mVideoViewWrapper->iFileDetails->mMultiItemPlaylist = true;

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdNextListItem ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdNext );

    //

    // Test 'Previous List Item' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdPreviousListItem ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPrevious );

    //

    // Test 'End Of Clip' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdEndOfClip ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdEndofClipReached );

    //

    // Test 'Custom Pause' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdCustomPause ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdCustomPause );

    //

    // Test 'Custom Play' command

    //

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdCustomPlay ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdCustomPlay );

    //

    // Test 'RealOne Bitmap Timeout' command

    //

    mVideoViewWrapper->iMediaRequestStatus = MediaDelivered;

    mVideoViewWrapper->iView->mStayPaused = false;

    TRAP( errHdlCmd, mVideoViewWrapper->HandleCommandL( EMPXPbvCmdRealOneBitmapTimeout ) );

    QVERIFY( errHdlCmd == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iCommand == EPbCmdPlay );

    cleanup();

}

void TestMPXVideoViewWrapper::testHandlePluginError()

{

    init();

    TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

    QVERIFY( errReqMedia == KErrNone );

    mVideoViewWrapper->HandlePluginError( KErrNotSupported );

    QVERIFY( mVideoViewWrapper->iView->mCurrentError == KErrNotSupported );

    cleanup();

}

void TestMPXVideoViewWrapper::testHandlePlaybackMessage()

{

    init();

    //***************************

    // Test Video Msg

    //***************************

    CMPXMessage* message = NULL;

    TRAP_IGNORE(

        message = CMPXMessage::NewL();

        message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMediaIdVideoPlayback );

        message->SetTObjectValueL<TMPXVideoPlaybackCommand>

                                            ( KMPXMediaVideoPlaybackCommand, EPbCmdTvOutEvent );

        message->SetTObjectValueL<TInt>( KMPXMediaVideoTvOutConnected, ETrue );

    );

    mVideoViewWrapper->HandlePlaybackMessage( message, KErrNone );

    QVERIFY( mVideoViewWrapper->iFileDetails->mTvOutConnected );

    if ( message )

    {

        delete message;

        message = NULL;

    }

    //***************************

    // Test General Msg

    //***************************

    TRAP_IGNORE(

        message = CMPXMessage::NewL();

        message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMessageGeneral );

        message->SetTObjectValueL<TInt>( KMPXMessageGeneralEvent, 28 );   // EReachedEndOfPlaylist = 28

        message->SetTObjectValueL<TInt>( KMPXMessageGeneralType, 0 );

        message->SetTObjectValueL<TInt>( KMPXMessageGeneralData, 0 );

    );

    mVideoViewWrapper->HandlePlaybackMessage( message, KErrNone );

    QVERIFY( ! mVideoViewWrapper->iView->mViewActive );

    if ( message )

    {

        delete message;

        message = NULL;

    }

    //***************************

    // Test Video Msg with err

    //***************************

    TRAP_IGNORE( message = CMPXMessage::NewL() );

    mVideoViewWrapper->HandlePlaybackMessage( message, KErrNotFound );

    QVERIFY( mVideoViewWrapper->iView->mCurrentError == KErrNotFound );

    if ( message )

    {

        delete message;

        message = NULL;

    }

    cleanup();

}

void TestMPXVideoViewWrapper::testSetProperty()

{

    init();

    TRAPD( errReqMedia, mVideoViewWrapper->RequestMediaL()) ;

    QVERIFY( errReqMedia == KErrNone );

    TMPXPlaybackProperty property = EPbPropertyMute;

    TInt propertyValue = 1;

    TRAPD( errSetProp, mVideoViewWrapper->SetPropertyL( property, propertyValue ) );

    QVERIFY( errSetProp == KErrNone );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iProperty == property );

    QVERIFY( mVideoViewWrapper->iPlaybackUtility->iPropertyValue == propertyValue );

    cleanup();

}

void TestMPXVideoViewWrapper::testHandleProperty()

{

    init();

    TRAPD(errReqMedia, mVideoViewWrapper->RequestMediaL());

    QVERIFY( errReqMedia == KErrNone );

    //

    // Duration

    //

    int value = 5000;

    TRAPD(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyDuration, value, KErrNone ) );

    QVERIFY( errHdlProp == KErrNone );

    QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetDuration );

    QVERIFY( mVideoViewWrapper->iControlsController->mValue == value );

    //

    // Position

    //

    value = 500;

    TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyPosition, value, KErrNone ) );

    QVERIFY( errHdlProp == KErrNone );

    QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetPosition );

    QVERIFY( mVideoViewWrapper->iControlsController->mValue == value );

    //

    // Volume

    //

    value = 10;

    TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyVolume, value, KErrNone ) );

    QVERIFY( errHdlProp == KErrNone );

    QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetVolume );

    QVERIFY( mVideoViewWrapper->iControlsController->mValue == value );

    //

    // Mute

    //

    value = 1;

    TRAP(errHdlProp, mVideoViewWrapper->HandlePropertyL( EPbPropertyMute, value, KErrNone ) );

    QVERIFY( errHdlProp == KErrNone );

    QVERIFY( mVideoViewWrapper->iControlsController->mReceivedEvent == EControlCmdSetVolume );

    QVERIFY( mVideoViewWrapper->iControlsController->mValue == 0 );

    cleanup();

}

void TestMPXVideoViewWrapper::testRetrieveFileNameAndMode()

{

    init();

    mVideoViewWrapper->iFileDetails->clearFileDetails();

    CMPXCommand* cmd = NULL;

    TRAP_IGNORE( cmd = CMPXCommand::NewL() );

    if ( cmd )