/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Test Harness for VideoPlayControls

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <e32std.h>

#include <w32std.h>

#include <coeaui.h>

#include <aknutils.h>

#include <aknviewappui.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "mpxvideoplaybackviewfiledetails.h"

#include "videoplaybackcontrolstest.h"

#include "mpxcommonvideoplaybackview.hrh"

#include "mpxvideoplaybackcontrolscontroller.h"

#include "mpxvideoplaybackcontrol.hrh"

#include "mpxvideo_debug.h"

// CONSTANTS

// ============================ MEMBER FUNCTIONS ===============================

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

// CVideoPlaybackControlsTest::Delete

// Delete here all resources allocated and opened from test methods.

// Called from destructor.

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

//

void CVideoPlaybackControlsTest::Delete()

{

}

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

// CVideoPlaybackControlsTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CVideoPlaybackControlsTest::RunMethodL( CStifItemParser& aItem )

{

    static TStifFunctionInfo const KFunctions[] =

    {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

        ENTRY( "CreateControls", CVideoPlaybackControlsTest::CreateControls ),

        ENTRY( "PointerEvent", CVideoPlaybackControlsTest::PointerEvent ),

        ENTRY( "KeyEvent", CVideoPlaybackControlsTest::KeyEvent ),

        ENTRY( "ExpectedResult",CVideoPlaybackControlsTest::ExpectedResult ),

        ENTRY( "SetAspectRatio", CVideoPlaybackControlsTest::SetAspectRatio ),

        ENTRY( "SetVolume", CVideoPlaybackControlsTest::SetVolume ),

        ENTRY( "SetState", CVideoPlaybackControlsTest::SetState ),

        ENTRY( "AddDefaultFileDetails", CVideoPlaybackControlsTest::AddDefaultFileDetails ),

        ENTRY( "AddLongFileDetails", CVideoPlaybackControlsTest::AddLongFileDetails ),

        ENTRY( "AddAudioOnlyFileDetails", CVideoPlaybackControlsTest::AddAudioOnlyFileDetails ),

        ENTRY( "SetDuration", CVideoPlaybackControlsTest::SetDuration ),

        ENTRY( "SoftkeyPressed", CVideoPlaybackControlsTest::SoftkeyPressed ),

        ENTRY( "ShowControls", CVideoPlaybackControlsTest::ShowControls ),

        ENTRY( "ToggleVisibility", CVideoPlaybackControlsTest::ToggleVisibility ),

        ENTRY( "HandleBackgroundEvnet", CVideoPlaybackControlsTest::HandleBackgroundEvnet ),

        ENTRY( "DeleteControls", CVideoPlaybackControlsTest::DeleteControls ),

        // PDL test cases

        ENTRY( "SetDownLoadSize", CVideoPlaybackControlsTest::SetDownLoadSize ),

        ENTRY( "SetDownLoadPostion", CVideoPlaybackControlsTest::SetDownLoadPostion ),

        ENTRY( "UpdateDownloadPosition", CVideoPlaybackControlsTest::UpdateDownloadPosition ),

        ENTRY( "SetDownLoadPaused", CVideoPlaybackControlsTest::SetDownLoadPaused ),

        ENTRY( "ClearDownLoadPaused", CVideoPlaybackControlsTest::ClearDownLoadPaused ),

        // TV out cases

        ENTRY( "TvOutConnected", CVideoPlaybackControlsTest::TvOutConnected ),

        ENTRY( "TvOutDisconnected", CVideoPlaybackControlsTest::TvOutDisconnected ),

        ENTRY( "HandleErrors", CVideoPlaybackControlsTest::HandleErrors ),

        // Media Details Viewer

        ENTRY( "ShowMediaDetailsViewer", CVideoPlaybackControlsTest::ShowMediaDetailsViewer ),

        ENTRY( "CloseMediaDetailsViewer", CVideoPlaybackControlsTest::CloseMediaDetailsViewer )

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

    };

    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

}

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

// CVideoPlaybackControlsTest::CreateController()

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

//

void CVideoPlaybackControlsTest::CreateController( const TDesC& aFileName, TInt aMode )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::CreateController( %S, %d )"), &aFileName, aMode );

    TInt result = KErrGeneral;

    if ( iAvkonViewAppUi->OrientationCanBeChanged() )

    {

        TRAPD( err, iAvkonViewAppUi->SetOrientationL( CAknAppUiBase::EAppUiOrientationLandscape ) );

        MPX_DEBUG(_L("CVideoPlaybackControlsTest::CreateController() err = [%d]"), err);

    }

    TRect rect = iAvkonViewAppUi->ApplicationRect();

    TRAP

    (

        result,

        {

            iContainer = CMPXVideoPlaybackContainer::NewL( aFileName );

            iContainer->SetRect( rect );

            CCoeEnv::Static()->AppUi()->AddToStackL( iContainer );

            iController =

                CMPXVideoPlaybackControlsController::NewL( iContainer,

                                                           rect,

                                                           iContainer->FileDetails( aMode ) );

            iContainer->SetController( iController );

        }

    );

    User::ResetInactivityTime();

}

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

// CVideoPlaybackControlsTest::DeleteControls()

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

//

TInt CVideoPlaybackControlsTest::DeleteControls()

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::DeleteControls()"));

    TInt err = KErrNone;

    TRAP( err, iAvkonViewAppUi->SetOrientationL( CAknAppUiBase::EAppUiOrientationAutomatic ) );

    if ( iController )

    {

        delete iController;

        iController = NULL;

    }

    CCoeEnv::Static()->AppUi()->RemoveFromStack( iContainer );

    if ( iContainer )

    {

        delete iContainer;

        iContainer = NULL;

    }

    return err;

}

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

// CVideoPlaybackControlsTest::CreateControls

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

//

TInt CVideoPlaybackControlsTest::CreateControls( CStifItemParser&  aItem )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::CreateControls()"));

    TInt mode = 0;

    TInt result = KErrNotFound;

    TPtrC filename;

    //

    // get file name first

    //

    result = aItem.GetNextString( filename );

    //

    // get mode next

    //

    if ( result == KErrNone )

    {

        result = aItem.GetNextInt( mode );

    }

    //

    // create controller

    //

    if ( result == KErrNone )

    {

        CreateController( GetFileNameAndPath( filename ), mode );

        iContainer->DrawNow();

    }

    return result;

}

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

// CVideoPlaybackControlsTest::SetAspectRatio

// Test creation of a general playback command.

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

//

TInt CVideoPlaybackControlsTest::SetAspectRatio( CStifItemParser&  aItem )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::SetAspectRatio()"));

    TInt aspectRatio = 0;

    TInt result = aItem.GetNextInt( aspectRatio );

    if ( result == KErrNone )

    {

        MPX_DEBUG(_L("CVideoPlaybackControlsTest::SetAspectRatio() [%d]"), aspectRatio);

        TRAP( result, iController->HandleEventL( EMPXControlCmdSetAspectRatio, aspectRatio ) );

    }

    return result;

}

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

// CVideoPlaybackControlsTest::SetVolume

// Test creation of a general playback command.

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

//

TInt CVideoPlaybackControlsTest::SetVolume( CStifItemParser&  aItem )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::SetVolume()"));

    TInt volume = 0;

    TInt result = aItem.GetNextInt( volume );

    if ( result == KErrNone )

    {

        MPX_DEBUG(_L("CVideoPlaybackControlsTest::SetVolume() [%d]"), volume);

        TRAP( result, iController->HandleEventL( EMPXControlCmdSetVolume,

                                                 (TInt64)volume ) );

    }

    return result;

}

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

// CVideoPlaybackControlsTest::SetDuration

// Test creation of a general playback command.

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

//

TInt CVideoPlaybackControlsTest::SetDuration( CStifItemParser&  aItem )

{

    TInt duration = 0;

    TInt result = aItem.GetNextInt( duration );

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::SetDuration() [%d]"), duration);

    if ( result == KErrNone )

    {

         TRAP( result, iController->HandleEventL( EMPXControlCmdSetDuration,

                                                   (TInt64)duration ) );

    }

    return result;

}

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

// CVideoPlaybackControlsTest::PointerEvent

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

//

TInt CVideoPlaybackControlsTest::PointerEvent( CStifItemParser&  aItem )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::PointerEvent()"));

    _LIT( KEventTypeParameter, "eventtype=" );

    _LIT( KPointerXParameter, "x=" );

    _LIT( KPointerYParameter, "y=" );

    TPointerEvent::TType type;

    TPoint position;

    TPtrC parameter;

    TInt result = KErrNone;

    while ( aItem.GetNextString( parameter ) == KErrNone )

    {

        if ( parameter.Find( KEventTypeParameter ) == 0 )

        {

            TPtrC parameterValue =

                parameter.Right( parameter.Length() - KEventTypeParameter().Length() );

            if ( ParseType( parameterValue, type ) != KErrNone )

            {

                result = KErrArgument;

            }

        }

        else if ( parameter.Find( KPointerXParameter ) == 0 )

        {

            TPtrC parameterValue =

                parameter.Right( parameter.Length() - KPointerXParameter().Length() );

            TLex parameterValueParser( parameterValue );

            if ( parameterValueParser.Val( position.iX ) != KErrNone )

            {

                result = KErrArgument;

            }

        }

        else if ( parameter.Find( KPointerYParameter ) == 0 )

        {

            TPtrC parameterValue =

                parameter.Right( parameter.Length() - KPointerYParameter().Length() );

            TLex parameterValueParser( parameterValue );

            if ( parameterValueParser.Val( position.iY ) != KErrNone )

            {

                result = KErrArgument;

            }

        }

        else

        {

             result = KErrArgument;

        }

    }

    TapOnScreen( type, position );

    return result;

}

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

// CVideoPlaybackControlsTest::KeyEvent

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

//

TInt CVideoPlaybackControlsTest::KeyEvent( CStifItemParser&  aItem )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::KeyEvent()"));

    _LIT( KEventTypeParameter, "eventtype=" );

    _LIT( KKeyScancode, "scancode=" );

    _LIT( KKeyDown, "EEventKeyDown" );

    _LIT( KKeyUp, "EEventKeyUp" );

    TInt type = 0;

    TInt scanCode = 0;

    TPtrC parameter;

    TInt result = KErrNone;

    while ( aItem.GetNextString( parameter ) == KErrNone )

    {

        if ( parameter.Find( KEventTypeParameter ) == 0 )

        {

            TPtrC parameterValue =

                parameter.Right( parameter.Length() - KEventTypeParameter().Length() );

            if ( parameterValue.Compare(KKeyDown) == 0 )

            {

                type = EEventKeyDown;

            }

            else if ( parameterValue.Compare(KKeyUp) == 0 )

            {

                type = EEventKeyUp;

            }

        }

        else if ( parameter.Find( KKeyScancode ) == 0 )

        {

            TPtrC parameterValue =

                parameter.Right( parameter.Length() - KKeyScancode().Length() );

            TLex parameterValueParser( parameterValue );

            if ( parameterValueParser.Val( scanCode ) != KErrNone )

            {

                result = KErrArgument;

            }

        }

        else

        {

             result = KErrArgument;

        }

    }

    // Now send the key event

    TRawEvent rawEvent;

    if ( type == EEventKeyDown )

    {

        rawEvent.Set( TRawEvent::EKeyDown , scanCode );

        iWsSession.SimulateRawEvent( rawEvent );

        iWsSession.Flush();

    }

    else if ( type == EEventKeyUp )

    {

        rawEvent.Set( TRawEvent::EKeyUp, scanCode );

        iWsSession.SimulateRawEvent( rawEvent );

        iWsSession.Flush();

    }

    return result;

}

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

// CVideoPlaybackControlsTest::ExpectedResult

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

//

TInt CVideoPlaybackControlsTest::ExpectedResult( CStifItemParser&  aItem )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::ExpectedResult()"));

    TInt command = 0;

    TInt value = 0 ;

    TInt result = aItem.GetNextInt( command );

    if ( result == KErrNone )

    {

        result = aItem.GetNextInt ( value );

        if ( result == KErrNone  )

        {

            TRAP( result, iContainer->ExpectedResultL( command, value ) );

        }

    }

    return result;

}

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

// CVideoPlaybackControlsTest::SetState

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

//

TInt CVideoPlaybackControlsTest::SetState( CStifItemParser&  aItem )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::SetState()"));

    TInt state = 0;

    TInt result = aItem.GetNextInt( state );

    if ( result == KErrNone )

    {

        TRAP( result, iController->HandleEventL( EMPXControlCmdStateChanged, state ) );

    }

    return result;

}

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

// CVideoPlaybackControlsTest::AddDefaultFileDetails

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

//

TInt CVideoPlaybackControlsTest::AddDefaultFileDetails()

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::AddDefaultFileDetails()"));

    TRAPD( result, iContainer->AddFileDetailsL() );

    return result;

}

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

// CVideoPlaybackControlsTest::AddAudioOnlyFileDetails

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

//

TInt CVideoPlaybackControlsTest::AddAudioOnlyFileDetails()

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::AddAudioOnlyFileDetails()"));

    TRAPD( result, iContainer->AddFileDetailsL( EFalse ) );

    return result;

}

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

// CVideoPlaybackControlsTest::AddLongFileDetails

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

//

TInt CVideoPlaybackControlsTest::AddLongFileDetails()

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::AddLongFileDetails()"));

    TRAPD( result, iContainer->AddLongFileDetailsL() );

    return result;

}

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

// CVideoPlaybackControlsTest::ParseType

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

//

TInt CVideoPlaybackControlsTest::ParseType( TDesC& aTypeName,

                                            TPointerEvent::TType& aType )

{

    MPX_DEBUG(_L("CVideoPlaybackControlsTest::ParseType()"));

    TBool err = KErrNone;

    _LIT( KButtonDown, "EButton1Down" );

    _LIT( KButtonDrag, "EDrag" );

    _LIT( KButtonUp, "EButton1Up" );

    if ( aTypeName.Compare(KButtonDown) == 0 )

    {

        aType = TPointerEvent::EButton1Down;

    }

    else if( aTypeName.Compare(KButtonUp) == 0 )

    {

        aType = TPointerEvent::EButton1Up;

    }

    else if( aTypeName.Compare(KButtonDrag) == 0 )

    {

        aType = TPointerEvent::EDrag;

    }