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

//

#include <e32math.h>

#include "testvideoplayer2.h"

#ifdef SYMBIAN_BUILD_GCE

#include <graphics/surfacemanager.h>

#endif

const TInt KSettingsAndAlignmentTest = 3;

//

// RTestVclntPlayAviFile

//

/**

 * RTestVclnt2PlayFile::Constructor

 */

RTestVclnt2PlayFile::RTestVclnt2PlayFile(const TDesC& aTestName, 

                                         const TDesC& aSectName, 

                                         const TDesC& aKeyName, 

                                         TInt aExpectedError)

    : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)

    {

    }

/**

 * RTestVclnt2PlayFile::NewL

 */

RTestVclnt2PlayFile* RTestVclnt2PlayFile::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)

    {

    RTestVclnt2PlayFile* self = new (ELeave) RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError);

    return self;

    }

/**

 * RTestVclnt2PlayFile::DoTestStepPreambleL

 */

TVerdict RTestVclnt2PlayFile::DoTestStepPreambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();

    }

/**

 * RTestVclnt2PlayFile::DoTestStepPostambleL

 */

TVerdict RTestVclnt2PlayFile::DoTestStepPostambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();        

    }

/**

 * RTestVclnt2PlayFile::FsmL

 */

void RTestVclnt2PlayFile::FsmL(TVclntTestPlayEvents aEventCode)

    {

    if (FsmCheck(aEventCode))

        {

        switch (aEventCode)

            {

            case EVPIdle:

                HandleIdleL();

                break;

            case EVPOpenComplete:

                HandleOpenCompleteL();

                break;

            case EVPPrepareComplete:                    

                HandlePrepareCompleteL();

                break;

            case EVPPlayComplete:

                HandlePlayCompleteL();

                break;

            }

        }

    }

void RTestVclnt2PlayFile::HandleIdleL()

	{

	// Open iVideoPlayer

    INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

    iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);

    PrepareState(EVPOpenComplete, KErrNone);

	}

void RTestVclnt2PlayFile::HandleOpenCompleteL()

	{

	// Prepare iVideoPlayer2

    INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));

    iVideoPlayer2->Prepare();

    PrepareState(EVPPrepareComplete, KErrNone);

	}

void RTestVclnt2PlayFile::HandlePrepareCompleteL()

	{

	// Add display window using default values - ie. video extent & window clipping 

	// defaulted to whole window

	INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));

	iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);

    // trigger the video to start playing                

    StartPlayback();

	}

void RTestVclnt2PlayFile::HandlePlayCompleteL()

	{

	iTestStepResult = EPass;

	CActiveScheduler::Stop();

	}

void RTestVclnt2PlayFile::StartPlayback()

	{

    iError = KErrTimedOut;

    INFO_PRINTF1(_L("iVideoPlayer2->Play()"));

    PrepareState(EVPPlayComplete, KErrNone);

    iVideoPlayer2->Play();

	}

#ifdef SYMBIAN_BUILD_GCE

//

// RTestMediaClientVideoDisplay

//

/**

 * RTestMediaClientVideoDisplay::Constructor

 */

RTestMediaClientVideoDisplay::RTestMediaClientVideoDisplay(const TDesC& aTestName, 

                                         const TDesC& aSectName, 

                                         const TDesC& aKeyName, 

                                         TInt aExpectedError)

    : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)

    {

    }

/**

 * RTestMediaClientVideoDisplay::NewL

 */

RTestMediaClientVideoDisplay* RTestMediaClientVideoDisplay::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)

    {

    RTestMediaClientVideoDisplay* self = new (ELeave) RTestMediaClientVideoDisplay(aTestName, aSectName, aKeyName, aExpectedError);

    return self;

    }

/**

 * RTestMediaClientVideoDisplay::DoTestStepPreambleL

 */

TVerdict RTestMediaClientVideoDisplay::DoTestStepPreambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();

    }

/**

 * RTestMediaClientVideoDisplay::DoTestStepPostambleL

 */

TVerdict RTestMediaClientVideoDisplay::DoTestStepPostambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();        

    }

/**

 * RTestMediaClientVideoDisplay::FsmL

 */

void RTestMediaClientVideoDisplay::FsmL(TVclntTestPlayEvents aEventCode)

    {

    if (FsmCheck(aEventCode))

        {

        switch (aEventCode)

            {

            case EVPIdle:

                HandleIdleL();

                break;

            case EVPOpenComplete:

                HandleOpenCompleteL();

                break;

            case EVPPrepareComplete:                    

                HandlePrepareCompleteL();

                break;

            case EVPPlayComplete:

                HandlePlayCompleteL();

                break;

            }

        }

    }

void RTestMediaClientVideoDisplay::HandleIdleL()

	{

	// Open iVideoPlayer

    INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

    iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);

    PrepareState(EVPOpenComplete, KErrNone);

	}

void RTestMediaClientVideoDisplay::HandleOpenCompleteL()

	{

	// Prepare iVideoPlayer2

    INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));

    iVideoPlayer2->Prepare();

    PrepareState(EVPPrepareComplete, KErrNone);

	}

void RTestMediaClientVideoDisplay::HandlePrepareCompleteL()

	{

	// trigger the video to start playing  

	StartPlayback();

	TInt displayId = iScreen->GetScreenNumber();

	TRect clipRect = TRect(iWindow->Size());

	TRect cropRegion = clipRect;

	// ==========================

    iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);

 	RSurfaceManager surfaceManager;

 	User::LeaveIfError(surfaceManager.Open());

	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

	RSurfaceManager::TSurfaceCreationAttributes& b=bf();

	b.iSize.iWidth = 320;

	b.iSize.iHeight = 240;

	b.iBuffers = 1;

	b.iPixelFormat = EUidPixelFormatXRGB_8888;	

	b.iStride = 320 * 4;

	b.iOffsetToFirstBuffer = 0;

	b.iAlignment=4;

	b.iContiguous=ETrue;

	TRect cropRect(0, 0, 320, 240);

	TVideoAspectRatio par(1,2);

	TSurfaceId surfaceId;

	User::LeaveIfError(surfaceManager.CreateSurface(bf, surfaceId));

    iMediaClientVideoDisplay->SurfaceCreated(surfaceId, cropRect, par, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceCreated()"));

    delete iMediaClientVideoDisplay;

    iMediaClientVideoDisplay = NULL;

    // ==================

    iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);

	TRect videoExtent = clipRect;

	TReal32 scaleWidth(100.0f);

	TReal32 scaleHeight(100.0f);

	TInt horizPos(EHorizontalAlignCenter);

	TInt vertPos(EVerticalAlignCenter);	

	TReal32 widthPercentage(50.0f); 

	TReal32 heightPercentage(50.0f);

	TReal32 widthP; 

	TReal32 heightP;

	RWindow newWindow;

	// Check for invalid rotation when adding new window

	INFO_PRINTF1(_L("Testing invalid rotations for AddDisplayWindowL"));

	TInt err = KErrNone;

	TVideoRotation rotation = static_cast<TVideoRotation>(-1);

	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for negative rotation"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	rotation = static_cast<TVideoRotation>(4);

	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for out of range rotation"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	rotation = EVideoRotationNone;

	// Check for invalid autoScaleType when adding new window

	INFO_PRINTF1(_L("Testing invalid autoScaleType for AddDisplayWindowL"));

	TAutoScaleType autoScaleType = static_cast<TAutoScaleType>(-1);

	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, autoScaleType, horizPos, vertPos, iWindow));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for negative scale"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	autoScaleType = static_cast<TAutoScaleType>(4);

	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, autoScaleType, horizPos, vertPos, iWindow));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for out of range scale"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow);

	INFO_PRINTF1(_L("iMediaClientVideoDisplay->AddDisplayWindowL()"));   

	// Check for invalid rotation when setting rotation for window

	INFO_PRINTF1(_L("Testing invalid rotation for SetRotationL"));

	TVideoRotation videoRotation = static_cast<TVideoRotation>(-1);

	TRAP(err, iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL(window) did not leave with KErrArgument for negative value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	videoRotation = static_cast<TVideoRotation>(4);

	TRAP(err, iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL(window) did not leave with KErrArgument for out of range value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	// Check for invalid rotation when setting rotation for all windows

	videoRotation = static_cast<TVideoRotation>(-1);

	TRAP(err, iMediaClientVideoDisplay->SetRotationL(videoRotation, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL() did not leave with KErrArgument for negative value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	videoRotation = static_cast<TVideoRotation>(4);

	TRAP(err, iMediaClientVideoDisplay->SetRotationL(videoRotation, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL() did not leave with KErrArgument for out of range value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	videoRotation = EVideoRotationClockwise180;

    iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));

    if (iMediaClientVideoDisplay->RotationL(*iWindow) != videoRotation)

        {

        ERR_PRINTF1(_L("iMediaClientVideoDisplay->RotationL() returns an unexpected value.  Test aborted."));

		iTestStepResult = EInconclusive;

		CActiveScheduler::Stop();

        }

	else

		{

		INFO_PRINTF1(_L("iMediaClientVideoDisplay->RotationL()"));	

		}

    iMediaClientVideoDisplay->SetScaleFactorL(*iWindow, widthPercentage, heightPercentage, cropRegion);

    iMediaClientVideoDisplay->SetScaleFactorL(widthPercentage, heightPercentage, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetScaleFactorL()"));

    iMediaClientVideoDisplay->SetRotationL(EVideoRotationClockwise90, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));

    iMediaClientVideoDisplay->GetScaleFactorL(*iWindow, widthP, heightP);

    INFO_PRINTF3(_L("iMediaClientVideoDisplay->GetScaleFactorL() %df %df"), &widthP, &heightP);

    iMediaClientVideoDisplay->SetVideoExtentL(*iWindow, videoExtent, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetVideoExtentL()"));

    iMediaClientVideoDisplay->SetWindowClipRectL(*iWindow, clipRect, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetWindowClipRectL()"));

	// Check for invalid autoScaleType when setting autoScaleType for window

	INFO_PRINTF1(_L("Testing invalid autoScaleType for SetAutoScaleL"));

	autoScaleType = static_cast<TAutoScaleType>(-1);

	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(*iWindow, autoScaleType, horizPos, vertPos, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL(window) did not leave with KErrArgument for negative value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	autoScaleType = static_cast<TAutoScaleType>(4);

	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(*iWindow, autoScaleType, horizPos, vertPos, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL(window) did not leave with KErrArgument for out of range value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	// Check for invalid autoScaleType when setting autoScaleType for all windows

	autoScaleType = static_cast<TAutoScaleType>(-1);

	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(autoScaleType, horizPos, vertPos, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL() did not leave with KErrArgument for negative value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

	autoScaleType = static_cast<TAutoScaleType>(4);

	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(autoScaleType, horizPos, vertPos, cropRegion));

	if (err != KErrArgument)

		{

		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL() did not leave with KErrArgument for out of range value"));

    	iTestStepResult = EFail;

    	CActiveScheduler::Stop();

    	return;

		}

    iMediaClientVideoDisplay->SetAutoScaleL(EAutoScaleBestFit, horizPos, vertPos, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetAutoScaleL()"));

    iMediaClientVideoDisplay->RedrawWindows(cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->RedrawWindows()"));   

	iMediaClientVideoDisplay->SurfaceParametersChanged(surfaceId, cropRect, par);

	INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceParametersChanged()"));

	iMediaClientVideoDisplay->RemoveSurface();

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->ReplaceSurface()"));

    iMediaClientVideoDisplay->RemoveDisplayWindow(*iWindow);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->RemoveDisplayWindow()"));

    surfaceManager.CloseSurface(surfaceId);

	surfaceId = TSurfaceId::CreateNullId();

	surfaceManager.Close();

    delete iMediaClientVideoDisplay;  

    iMediaClientVideoDisplay = NULL;              

   	}

void RTestMediaClientVideoDisplay::HandlePlayCompleteL()

	{

	iTestStepResult = EPass;

	CActiveScheduler::Stop();

	}

void RTestMediaClientVideoDisplay::StartPlayback()

	{

    iError = KErrTimedOut;

    INFO_PRINTF1(_L("iVideoPlayer2->Play()"));

    PrepareState(EVPPlayComplete, KErrNone);

    iVideoPlayer2->Play();

	}

#endif

//

// RTestVclnt2PerformActionDuringVideoPlayback

//

/**

 * RTestVclnt2PerformActionDuringVideoPlayback::Constructor

 */

RTestVclnt2PerformActionDuringVideoPlayback::RTestVclnt2PerformActionDuringVideoPlayback(

    const TDesC& aTestName, 

    const TDesC& aSectName, 

    const TDesC& aKeyName, 

    TInt aExpectedError)

    : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

    {

    }

/**

 * RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL

 */

void RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL()

    {

    if (iActionError != KErrNone)

        {

        ERR_PRINTF2(_L("Playback event left with error %d."), iActionError);

        iTestStepResult = EFail;

        }

    else 

        {

        iTestStepResult = EPass;

        }

	CActiveScheduler::Stop();        

    }