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

//

#include "mediaclientvideodisplaybody.h"

#include "mediaclientvideotrace.h"

#include <surfaceeventhandler.h>

CMediaClientVideoDisplayBody* CMediaClientVideoDisplayBody::NewL(TInt aDisplayId)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::NewL +++"));

	CMediaClientVideoDisplayBody* self = new (ELeave) CMediaClientVideoDisplayBody(aDisplayId);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::NewL ---"));

	return self;

	}

CMediaClientVideoDisplayBody* CMediaClientVideoDisplayBody::NewL(TInt aDisplayId, const TSurfaceId& aSurfaceId,

		const TRect& aCropRect, TVideoAspectRatio aAspectRatio)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::NewL +++"));

	if(aSurfaceId.IsNull())

		{

		User::Leave(KErrArgument);

		}

	CMediaClientVideoDisplayBody* self = new(ELeave) CMediaClientVideoDisplayBody(aDisplayId, aSurfaceId, aCropRect, aAspectRatio);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::NewL ---"));

	return self;

	}

void CMediaClientVideoDisplayBody::ConstructL()

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::ConstructL +++"));

	iExtDisplaySwitchingSupported = CExtDisplayConnectionProviderInterface::ExternalDisplaySupportedL();

	// Try and enable display switching by default. If this leaves then do so quietly.

	// Either the client has no scheduler installed or the device does not support external

	// switching (i.e. no plugin was found) 

	TRAPD(err, SetExternalDisplaySwitchingL(ETrue));

	err = err; // remove compile warning

	DEBUG_PRINT2(_L("CMediaClientVideoDisplayBody::ConstructL SetExternalDisplaySwitchingL returned with %d"), err);

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::ConstructL ---"));

	}

CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody(TInt aDisplayId, const TSurfaceId& aSurfaceId,

		const TRect& aCropRect, TVideoAspectRatio aAspectRatio) :

	iDisplayId(aDisplayId),

	iSurfaceId(aSurfaceId),

	iCropRect(aCropRect),

	iAspectRatio(aAspectRatio)

	{	

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody +++"));

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody ---"));

	}

CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody(TInt aDisplayId) :

	iDisplayId(aDisplayId)

	{	

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody +++"));

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody ---"));

	}

CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody()

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody +++"));

	RemoveBackgroundSurface(ETrue);

	iWindows.Close();	

	delete iExtDisplayConnectionProvider;

	REComSession::FinalClose();

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody ---"));

	}

void CMediaClientVideoDisplayBody::AddDisplayL(MMMFSurfaceEventHandler& aEventHandler)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::AddDisplayL +++"));

	if (iEventHandler != NULL)

		{

		User::Leave(KErrInUse);

		}

	iEventHandler = &aEventHandler;

	if (IsSurfaceCreated())

		{

		iEventHandler->MmsehSurfaceCreated(iDisplayId, iSurfaceId, iCropRect, iAspectRatio);

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::AddDisplayL ---"));

	}

void CMediaClientVideoDisplayBody::AddDisplayWindowL(const RWindowBase* aWindow, const TRect& aClipRect, const TRect& aCropRegion, const TRect& aVideoExtent, 

															TReal32 aScaleWidth, TReal32 aScaleHeight, TVideoRotation aRotation, 

															TAutoScaleType aAutoScaleType, TInt aHorizPos, TInt aVertPos, RWindow* aWindow2)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::AddDisplayWindowL +++"));

	TInt pos = iWindows.Find(aWindow->WsHandle(), TWindowData::CompareByWsHandle);

	if (pos != KErrNotFound)

		{

		User::Leave(KErrInUse);

		}

	TWindowData winData(aWindow, aClipRect, aVideoExtent, aScaleWidth, aScaleHeight, aRotation, aAutoScaleType, aHorizPos, aVertPos, aWindow2);

	iWindows.AppendL(winData);

	iCropRegion = aCropRegion;

	if (IsSurfaceCreated())

		{

        if(iExtDisplaySwitchingSupported && iClientRequestedExtDisplaySwitching)

            {

            CreateExtDisplayConnProvAndRemoveSurfaceL(EFalse);

            }

        if(!iExtDisplayConnected)

            {

            User::LeaveIfError(SetBackgroundSurface(winData, aCropRegion));

            }

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::AddDisplayWindowL ---"));

	}

void CMediaClientVideoDisplayBody::RemoveDisplay()

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveDisplay +++"));

	iEventHandler = NULL;

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveDisplay ---"));

	}	

TInt CMediaClientVideoDisplayBody::RemoveDisplayWindow(const RWindowBase& aWindow)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveDisplayWindow +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	if (pos >= 0)

		{

		if (IsSurfaceCreated())

			{

			iWindows[pos].iWindow->RemoveBackgroundSurface(ETrue);

			// Make sure all window rendering has completed before proceeding

			RWsSession* ws = iWindows[pos].iWindow->Session();

			if (ws)

				{

				ws->Finish();

				}

			}

		iWindows.Remove(pos);

		if(iWindows.Count() == 0)

		    {

		    RemoveExtDisplayConnProv();

		    }

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveDisplayWindow ---"));

	return pos;

	}

TInt CMediaClientVideoDisplayBody::SurfaceCreated(const TSurfaceId& aSurfaceId, const TRect& aCropRect, TVideoAspectRatio aAspectRatio, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SurfaceCreated +++"));

	TBool emitEvent = EFalse;

	if((iSurfaceId != aSurfaceId) && (!aSurfaceId.IsNull()))

		{

		emitEvent = ETrue;

		}

	iSurfaceId = aSurfaceId;

	iCropRect = aCropRect;

	iAspectRatio = aAspectRatio;

	iCropRegion = aCropRegion;

	if (emitEvent && iEventHandler)

		{

		iEventHandler->MmsehSurfaceCreated(iDisplayId, iSurfaceId, iCropRect, iAspectRatio);

		}

	TInt err = KErrNone;

    if(iExtDisplaySwitchingSupported && iClientRequestedExtDisplaySwitching)

        {

        TRAP(err, CreateExtDisplayConnProvAndRemoveSurfaceL(EFalse));

        }

    if(!iExtDisplayConnected)

        {

        err = RedrawWindows(aCropRegion);

        }

    DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SurfaceCreated ---"));

	return err;

	}

void CMediaClientVideoDisplayBody::RemoveBackgroundSurface(TBool aTriggerRedraw)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveBackgroundSurface +++"));

	if (IsSurfaceCreated())

		{

		TInt count = iWindows.Count();

		RWsSession* ws = NULL;

		for (TInt i = 0; i < count; ++i)

			{

			iWindows[i].iWindow->RemoveBackgroundSurface(aTriggerRedraw);

			// Make sure all window rendering has completed before proceeding

			ws = iWindows[i].iWindow->Session();

			if (ws)

				{

				ws->Finish();

				}

			}

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveBackgroundSurface ---"));

	}

void CMediaClientVideoDisplayBody::RemoveSurface(TBool aControllerEvent)

    {

    DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveSurface +++"));

    if (IsSurfaceCreated())

        {

        if(!iExtDisplayConnected)

            {

            RemoveBackgroundSurface(ETrue);

            }

        if (iEventHandler  && aControllerEvent)

            {

            iEventHandler->MmsehRemoveSurface(iSurfaceId);

            }

        iSurfaceId = TSurfaceId::CreateNullId();

        RemoveExtDisplayConnProv();

        }

    DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RemoveSurface ---"));

    }

TInt CMediaClientVideoDisplayBody::SurfaceParametersChanged(const TSurfaceId& aSurfaceId, const TRect& aCropRect, TVideoAspectRatio aAspectRatio)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SurfaceParametersChanged +++"));

	if (!IsSurfaceCreated())

		{

		return KErrNotSupported;

		}

	if (iSurfaceId != aSurfaceId)

		{

		return KErrInUse;

		}

	iCropRect = aCropRect;

	iAspectRatio = aAspectRatio;

	if (iEventHandler)

		{

		iEventHandler->MmsehSurfaceParametersChanged(iSurfaceId, iCropRect, iAspectRatio);

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SurfaceParametersChanged ---"));

	return KErrNone;

	}

TInt CMediaClientVideoDisplayBody::RedrawWindows(const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RedrawWindows +++"));

	TInt err = KErrNone;	

	iCropRegion = aCropRegion;

	if(IsSurfaceCreated())

		{

		TInt count = iWindows.Count();

		for (TInt i = 0; i < count; ++i)

			{

			err = SetBackgroundSurface(iWindows[i], aCropRegion);

			if (err != KErrNone)

				{

				break;

				}

			}

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RedrawWindows ---"));

	return err;

	}

void CMediaClientVideoDisplayBody::SetAutoScaleL(const RWindowBase& aWindow, TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetAutoScaleL +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	User::LeaveIfError(pos);

	iWindows[pos].iAutoScaleType = aScaleType;

	iWindows[pos].iHorizPos = aHorizPos;

	iWindows[pos].iVertPos = aVertPos;

	iCropRegion = aCropRegion;

	if (IsSurfaceCreated() && !iExtDisplayConnected)

		{

		User::LeaveIfError(SetBackgroundSurface(iWindows[pos], aCropRegion));

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetAutoScaleL ---"));

	}

void CMediaClientVideoDisplayBody::SetRotationL(const RWindowBase& aWindow, TVideoRotation aRotation, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetRotationL +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	User::LeaveIfError(pos);

	iWindows[pos].iRotation = aRotation;

	iCropRegion = aCropRegion;

    if (IsSurfaceCreated() && !iExtDisplayConnected)

		{

		User::LeaveIfError(SetBackgroundSurface(iWindows[pos], aCropRegion));

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetRotationL ---"));

	}

TVideoRotation CMediaClientVideoDisplayBody::RotationL(const RWindowBase& aWindow)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RotationL +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	User::LeaveIfError(pos);

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::RotationL ---"));

	return iWindows[pos].iRotation;

	}

void CMediaClientVideoDisplayBody::SetScaleFactorL(const RWindowBase& aWindow, TReal32 aWidthPercentage, TReal32 aHeightPercentage, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetScaleFactorL +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	User::LeaveIfError(pos);

	if (aWidthPercentage <= 0.0 || aHeightPercentage <= 0.0)

		{

		User::Leave(KErrArgument);

		}

	iWindows[pos].iScaleWidth = aWidthPercentage;

	iWindows[pos].iScaleHeight = aHeightPercentage;

	iWindows[pos].iAutoScaleType = EAutoScaleNone;

	iCropRegion = aCropRegion;

    if (IsSurfaceCreated() && !iExtDisplayConnected)

		{

		User::LeaveIfError(SetBackgroundSurface(iWindows[pos], aCropRegion));

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetScaleFactorL ---"));

	}

void CMediaClientVideoDisplayBody::GetScaleFactorL(const RWindowBase& aWindow, TReal32& aWidthPercentage, TReal32& aHeightPercentage)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::GetScaleFactorL +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	User::LeaveIfError(pos);

	aWidthPercentage = iWindows[pos].iScaleWidth;

	aHeightPercentage = iWindows[pos].iScaleHeight;

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::GetScaleFactorL ---"));

	}

void CMediaClientVideoDisplayBody::SetAutoScaleL(TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetAutoScaleL +++"));

	iCropRegion = aCropRegion;

	TInt count = iWindows.Count();

	for (TInt i = 0; i < count; ++i)

		{

		iWindows[i].iAutoScaleType = aScaleType;

		iWindows[i].iHorizPos = aHorizPos;

		iWindows[i].iVertPos = aVertPos;

	    if (IsSurfaceCreated() && !iExtDisplayConnected)

			{

			User::LeaveIfError(SetBackgroundSurface(iWindows[i], aCropRegion));

			}

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetAutoScaleL ---"));

	}

void CMediaClientVideoDisplayBody::SetRotationL(TVideoRotation aRotation, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetRotationL +++"));

	iCropRegion = aCropRegion;

	TInt count = iWindows.Count();

	for (TInt i = 0; i < count; ++i)

		{

		iWindows[i].iRotation = aRotation;

	    if (IsSurfaceCreated() && !iExtDisplayConnected)

			{

			User::LeaveIfError(SetBackgroundSurface(iWindows[i], aCropRegion));

			}

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetRotationL ---"));

	}

void CMediaClientVideoDisplayBody::SetScaleFactorL(TReal32 aWidthPercentage, TReal32 aHeightPercentage, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetScaleFactorL +++"));

	if (aWidthPercentage <= 0.0 || aHeightPercentage <= 0.0)

		{

		User::Leave(KErrArgument);

		}

	iCropRegion = aCropRegion;

	TInt count = iWindows.Count();

	for (TInt i = 0; i < count; ++i)

		{

		iWindows[i].iScaleWidth = aWidthPercentage;

		iWindows[i].iScaleHeight = aHeightPercentage;

		iWindows[i].iAutoScaleType = EAutoScaleNone;

	    if (IsSurfaceCreated() && !iExtDisplayConnected)

			{

			User::LeaveIfError(SetBackgroundSurface(iWindows[i], aCropRegion));

			}

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetScaleFactorL ---"));

	}

void CMediaClientVideoDisplayBody::SetWindowClipRectL(const RWindowBase& aWindow, const TRect& aWindowClipRect, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetWindowClipRectL +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	User::LeaveIfError(pos);

	iWindows[pos].iClipRect = aWindowClipRect;

	iCropRegion = aCropRegion;

    if (IsSurfaceCreated() && !iExtDisplayConnected)

		{

		User::LeaveIfError(SetBackgroundSurface(iWindows[pos], aCropRegion));

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetWindowClipRectL ---"));

	}

void CMediaClientVideoDisplayBody::SetVideoExtentL(const RWindowBase& aWindow, const TRect& aVideoExtent, const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetVideoExtentL +++"));

	TInt pos = iWindows.Find(aWindow.WsHandle(), TWindowData::CompareByWsHandle);

	User::LeaveIfError(pos);

	iWindows[pos].iVideoExtent = aVideoExtent;

	iCropRegion = aCropRegion;

    if (IsSurfaceCreated() && !iExtDisplayConnected)

		{

		User::LeaveIfError(SetBackgroundSurface(iWindows[pos], aCropRegion));

		}

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetVideoExtentL ---"));

	}

TBool CMediaClientVideoDisplayBody::HasWindows() const

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::HasWindows +++"));

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::HasWindows ---"));

	return (iWindows.Count() > 0);

	}

TInt CMediaClientVideoDisplayBody::SetBackgroundSurface(TWindowData& aWindowData,  

									const TRect& aCropRegion)

	{

	DEBUG_PRINT(_L("CMediaClientVideoDisplayBody::SetBackgroundSurface +++"));

	// required as this private function is called directly from external friend class

	iCropRegion = aCropRegion;

    // viewport is the viewable area of surface

    TRect viewport(iCropRect);

    if (aCropRegion.Width() > 0 || aCropRegion.Height() > 0)

        {

        viewport.Intersection(aCropRegion);

        }

    // Viewport is 0 size, don't show any video

    if (viewport.Width() <= 0 || viewport.Height() <= 0)

        {

        return KErrArgument;

        }

	TRect extent;

	CalculateExtentAndViewport(aWindowData, extent, viewport);

	aWindowData.iSurfaceConfig.SetViewport(viewport);

	aWindowData.iSurfaceConfig.SetExtent(extent);

	aWindowData.iSurfaceConfig.SetOrientation(ConvertRotation(aWindowData.iRotation));

	aWindowData.iSurfaceConfig.SetSurfaceId(iSurfaceId);

	// Get the rectangle that bounds the crop rectangle and the viewport.  This should be

	// the same as the crop rectangle as long as the viewport does not go outside this area.

	TRect rect(iCropRect);

	rect.BoundingRect(viewport);

	TInt err = KErrNone;