/**
* 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: %

#include <e32err.h>
#include <w32std.h>

#include <mmf/common/mmferrors.h>
#include <caf/caferr.h>

#include <mpxvideoplaybackdefs.h>

#include <hbapplication.h>
#include <hbinstance.h>
#include <qgraphicssceneevent>
#include <QDebug>

#include "mpxvideoplaybackviewfiledetails.h"

#include "testvideoplaybackview.h"
#include "mpxvideoviewwrapper.h"

#define private public
#define protected public
#include "hbvideoplaybackview.h"
#include "hbvideobaseplaybackview.h"
#undef protected
#undef private




// ---------------------------------------------------------------------------
// main
// ---------------------------------------------------------------------------
//
int main(int argc, char *argv[])
{
    HbApplication app(argc, argv);
    HbMainWindow window;
    
    TestVideoPlaybackView tv;

    char *pass[3];
    pass[0] = argv[0];
    pass[1] = "-o";
    pass[2] = "c:\\data\\TestVideoPlaybackView.txt";
    
    int res = QTest::qExec(&tv, 3, pass);
    
    return res;
}


// ---------------------------------------------------------------------------
// init
// ---------------------------------------------------------------------------
//
void TestVideoPlaybackView::init()
{	  
	  mVideoView = new HbVideoPlaybackView();	  
}

// ---------------------------------------------------------------------------
// cleanup
// ---------------------------------------------------------------------------
//
void TestVideoPlaybackView::cleanup()
{
    delete mVideoView;
    mVideoView = NULL;
}

// ---------------------------------------------------------------------------
// setup
// ---------------------------------------------------------------------------
//
void TestVideoPlaybackView::setup()
{
    init();
    mVideoView->handleActivateView();
}


void TestVideoPlaybackView::testHandleActivateView()
{
    init();		
    mVideoView->handleActivateView();    
        
    QVERIFY( mVideoView->mVideoMpxWrapper->iMediaRequested == true );
    QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mBitRate, 16000 );
    QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mTitle, QString("Test Video Title") );
    
    cleanup();        
}

void TestVideoPlaybackView::testHandlePluginError()
{   
    //
    // playback view is closed after displaying these error notes
    //
    verifyHandlePluginError( KErrNotSupported );
    verifyHandlePluginError( KErrUnknown );
    verifyHandlePluginError( KErrMMDecoder );
    verifyHandlePluginError( KErrCorrupt );
    verifyHandlePluginError( KErrTooBig );
    verifyHandlePluginError( KErrMMInvalidProtocol );
    verifyHandlePluginError( KErrMMInvalidURL );
    verifyHandlePluginError( KErrArgument );
    verifyHandlePluginError( KErrSessionClosed ); 
    verifyHandlePluginError( KErrTimedOut );
    verifyHandlePluginError( KErrNotFound );
    verifyHandlePluginError( KErrMMNotEnoughBandwidth );   
    verifyHandlePluginError( KErrDisconnected );
    verifyHandlePluginError( KErrMMProxyServer ); 
    verifyHandlePluginError( KErrCouldNotConnect );
    verifyHandlePluginError( KErrAbort );
    verifyHandlePluginError( KErrCancel ); 
    verifyHandlePluginError( KErrMMDRMNotAuthorized );
    verifyHandlePluginError( KErrCANoRights );
    verifyHandlePluginError( KErrCANoPermission );
    verifyHandlePluginError( KMPXVideoTvOutPlaybackNotAllowedClose );
    
    //
    // playback view remains open after displaying these error notes
    //
    verifyHandlePluginError( KMPXVideoCallOngoingError, false );
    verifyHandlePluginError( KMPXVideoTvOutPlaybackNotAllowed, false );
    verifyHandlePluginError( KMPXVideoPlayOver2GDuringVoiceCallError, false );
            
    //
    // default error case, playback view is closed after displaying error note
    //
    verifyHandlePluginError( KErrGeneral );    
}

void TestVideoPlaybackView::testShowDialog()
{   
    //
    // construct and activate playback view
    //
    setup();
    
    //
    // ensure that playback view is currently activated
    //
    QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );
    
    //
    // test showDialog() method
    //
    mVideoView->showDialog( "test error msg" );
    
    //
    // connect and emit signal for handleClosePopupDialog() slot
    //
    connect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );
    emit commandSignal();     

    //
    // verify that playback view is properly closed
    //
    QVERIFY( mVideoView->mTimerForClosingView->isActive() );

    //
    // disconnect signal for handleClosePopupDialog() slot
    //
    disconnect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );
    
    //
    // destruct playback view
    //
    cleanup();    
}


void TestVideoPlaybackView::testGetWindow()
{      
    setup();
    
    QVERIFY( mVideoView->getWindow() != NULL );     
    
    cleanup();
}


void TestVideoPlaybackView::testIssuePlayCommand()
{      
    setup();
    
    mVideoView->issuePlayCommand();      
    
    //JAM remove
    QVERIFY( mVideoView->isEnabled() );
    
    cleanup();
}

void TestVideoPlaybackView::testEvent()
{
    setup();
    
    //
    // ensure default foreground is false
    //
    QCOMPARE( mVideoView->mVideoMpxWrapper->iForeground, 0 );

    //
    // declare foreground/background event
    //
    QEvent* windowActivate   = new QEvent( QEvent::WindowActivate );
    QEvent* windowDeactivate = new QEvent( QEvent::WindowDeactivate );
    
    //
    // verify the returned value (consumed) of HbVideoBasePlaybackView::event() 
    // for QEvent::WindowActivate is false
    //
    QVERIFY( ! mVideoView->event( windowActivate ) );  
    
    //
    // verify view is in foreground
    //
    QCOMPARE( mVideoView->mVideoMpxWrapper->iForeground, 1 );

    //
    // verify the returned value (consumed) of HbVideoBasePlaybackView::event() 
    // for QEvent::WindowDeactivate is false
    //
    QVERIFY( ! mVideoView->event( windowDeactivate ) );   
    
    //
    // verify view is in background
    //
    QCOMPARE( mVideoView->mVideoMpxWrapper->iForeground, 0 );
    
    //
    // clean up
    //
    delete windowActivate;
    windowActivate = NULL;
    delete windowDeactivate;
    windowDeactivate = NULL;
    cleanup();
}

void TestVideoPlaybackView::testClosePlaybackView()
{
    setup();
    
    QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );

    mVideoView->closePlaybackView();
    
    QVERIFY( mVideoView->mTimerForClosingView->isActive() );

    cleanup();
}

void TestVideoPlaybackView::testMousePressEvent()
{
    setup();
    
    //
    // declare QEvent::GraphicsSceneMousePress
    //
    QGraphicsSceneMouseEvent* event = new QGraphicsSceneMouseEvent( QEvent::GraphicsSceneMousePress );
        
    //
    // set m_accept value to false
    //        
    event->setAccepted( false );
    
    // 
    // simulate QEvent::GraphicsSceneMousePress event
    //
    mVideoView->mousePressEvent( event );  
    
    //
    // verify event has been accepted
    //        
    QVERIFY( event->isAccepted() );
    
    //
    // clean up
    //    
    delete event;
    event = NULL;    
    cleanup();
}

void TestVideoPlaybackView::testMouseReleaseEvent()
{
    setup();
    
    //
    // declare QEvent::GraphicsSceneMouseRelease
    //
    QGraphicsSceneMouseEvent* event = new QGraphicsSceneMouseEvent( QEvent::GraphicsSceneMouseRelease );
    
    //
    // connect to tappedOnScreen() signal and record its emission
    //
    QSignalSpy spy( mVideoView, SIGNAL(tappedOnScreen()) );  
    
    //
    // ensure signal has not been emitted yet
    //
    QCOMPARE(spy.count(), 0);     
    
    // 
    // simulate QEvent::GraphicsSceneMousePress event
    //
    mVideoView->mouseReleaseEvent( event );        
    
    //
    // ensure signal has been emitted and its emission count is incremented
    //    
    QCOMPARE(spy.count(), 1);  
    
    //
    // clean up
    //
    delete event;
    event = NULL;    
    spy.clear();
    cleanup();    
}


void TestVideoPlaybackView::testHandlePdlStateChange()
{
    setup();

    QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mClipName, QString("testClip.3gp") );
    
    mVideoView->handlePdlStateChange( 0 );
    
    QCOMPARE( mVideoView->mVideoMpxWrapper->iFileDetails->mClipName, QString("testClip.3gp") );
    
    cleanup();
}

void TestVideoPlaybackView::testHandleStoppedStateNoPrevView()
{    
    setup();

    QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );        
    mVideoView->handleStoppedState();

    QVERIFY( mVideoView->mTimerForClosingView->isActive() );    

    cleanup();   
}


void TestVideoPlaybackView::testHandleStoppedStatePrevView()
{ 
    setup();
           
    mVideoView->handleStoppedState();
    
    QVERIFY( mVideoView->mTimerForClosingView->isActive() );
    
    cleanup();
    
}

void TestVideoPlaybackView::testHandleBackNoPrevView()
{    
    setup();
       
    QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );
    mVideoView->handleBack();

    QVERIFY( mVideoView->mTimerForClosingView->isActive() );  
  
    cleanup();
    
}

void TestVideoPlaybackView::testHandleBackPrevView()
{  
    setup();
           
    mVideoView->handleBack();
    
    QVERIFY( mVideoView->mTimerForClosingView->isActive() ); 
    
    cleanup();
}

void TestVideoPlaybackView::testHandleSoftkeyback()
{        
    setup();
           
    mVideoView->handleSoftkeyBack();
    
    QVERIFY( mVideoView->mTimerForClosingView->isActive() ); 
    
    cleanup();    
}



void TestVideoPlaybackView::testDoClosePlayer()
{    
    // quits app - which can be problematic for the qvptestrunner app    

//    setup();
//    
//    mVideoView->handleActivateView();
//
//    mVideoView->doClosePlayer();
//    
//    cleanup();
    
}

void TestVideoPlaybackView::testHandleDeactivateView()
{    
    setup();
    
    mVideoView->handleDeactivateView();
    
    QVERIFY( mVideoView->mVideoMpxWrapper == NULL );   
    
    cleanup();        
}

void TestVideoPlaybackView::verifyHandlePluginError( TInt error, bool closeView )
{       
    //
    // construct and activate playback view
    //
    setup();
    
    //
    // ensure that playback view is currently open
    //
    QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );
    
    //
    // test handlePluginError() method
    //
    mVideoView->handlePluginError( error );   
    
    //
    // close playback view after error note has been launched
    //
    if ( closeView )
    {
        //
        // connect and emit signal for handleClosePopupDialog() slot
        //
        connect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );
        emit commandSignal();  

        //
        // verify that playback view is properly closed
        //
        QVERIFY( mVideoView->mTimerForClosingView->isActive() );
    
        //
        // disconnect signal for handleClosePopupDialog() slot
        //
        disconnect( this, SIGNAL( commandSignal() ), mVideoView, SLOT( handleClosePopupDialog() ) );
    }
    else
    {    
        //
        // verify that playback view is still open after error note has been launched
        //
        QVERIFY( ! mVideoView->mTimerForClosingView->isActive() );
    }        
    
    //
    // destruct playback view
    //
    cleanup();
}

// End of file