// Copyright (c) 2002-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 "mediaclientvideodisplaybody.h"

#include "mediaclientvideotrace.h"

#include "mediaclientpolicyserverclient.h"

#include <surfaceeventhandler.h>

#include <mmf/plugin/mmfmediaclientextdisplayinterface.hrh>

#include <e32cmn.h>

#include <ecom/ecom.h>

#include <centralrepository.h>

const TUid KCRUidTvoutSettings = {0x1020730B};

const TUint32 KSettingsTvAspectRatio = 0x00000001;

#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

// make sure that off screen is bottom right and not top left. This makes it more efficient for GCE backend

// to render

const TInt KHiddenExtentA = 2000; // rect Ax and Ay co-ordinate used to set extent off screen

const TInt KHiddenExtentB = 2001; // rect Bx and By co-ordinate used to set extent off screen

#endif

CMediaClientVideoDisplayBody* CMediaClientVideoDisplayBody::NewL(TInt aDisplayId, TBool aExtDisplaySwitchingControl)

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL +++");

    DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aDisplayId %d", aDisplayId);

    DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aExtDisplaySwitchingControl %d", aExtDisplaySwitchingControl);

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

	CleanupStack::PushL(self);

	self->ConstructL(aExtDisplaySwitchingControl);

	CleanupStack::Pop(self);

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL ---");

	return self;

	}

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

		const TRect& aCropRect, TVideoAspectRatio aAspectRatio, TBool aExtDisplaySwitchingControl)

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL +++");

	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aDisplayId %d", aDisplayId);

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::NewL - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::NewL - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);

    DEBUG_PRINTF3("CMediaClientVideoDisplayBody::NewL - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);

    DEBUG_PRINTF2("CMediaClientVideoDisplayBody::NewL - aExtDisplaySwitchingControl %d", aExtDisplaySwitchingControl);

	if(aSurfaceId.IsNull())

		{

		User::Leave(KErrArgument);

		}

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

	CleanupStack::PushL(self);

	self->ConstructL(aExtDisplaySwitchingControl);

	CleanupStack::Pop();

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::NewL ---");

	return self;

	}

void CMediaClientVideoDisplayBody::ConstructL(TBool aExtDisplaySwitchingControl)

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::ConstructL +++");

	SetWindowArrayPtr2Client();

	// External display switching and wserv events are only possible if there is

	// an active scheduler in client thread

	if(CActiveScheduler::Current())

	    {

        CreateExtDisplayPluginL();

        iWsEventObserver = CMediaClientWsEventObserver::NewL(*this);

        iServerClient = CMediaClientPolicyServerClient::NewL();

        if(iServerClient->Connect() != KErrNone)

            {

            delete iServerClient;

            iServerClient = NULL;

            }

        if(IsSurfaceCreated() && iServerClient)

            {

            iServerClient->SetSurface(iSurfaceId);

            }

        // 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(aExtDisplaySwitchingControl));

        err = err; // remove compile warning

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

	    }

	else

	    {

	    DEBUG_PRINTF("CMediaClientVideoDisplayBody::ConstructL No CActiveScheduler - ext display and focus features disabled ");

	    }

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::ConstructL ---");

	}

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

		const TRect& aCropRect, TVideoAspectRatio aAspectRatio) :

	iDisplayId(aDisplayId),

	iSurfaceId(aSurfaceId),

	iCropRect(aCropRect),

	iAspectRatio(aAspectRatio)

	{	

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody +++");

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody ---");

	}

CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody(TInt aDisplayId) :

	iDisplayId(aDisplayId)

	{	

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody +++");

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::CMediaClientVideoDisplayBody ---");

	}

CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody()

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody +++");

	// remove for whichever array is current

	RemoveBackgroundSurface(ETrue);

#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

    if(iSwitchedToExternalDisplay)

        {

        SetWindowArrayPtr2Client();

        RemoveBackgroundSurface(ETrue);

        }

#endif

	iClientWindows.Close();	

    iExtDisplayWindows.Close(); 

	delete iExtDisplayHandler;

	RemoveExtDisplayPlugin();

	REComSession::FinalClose();

    delete iWsEventObserver;

    delete iServerClient;

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::~CMediaClientVideoDisplayBody ---");

	}

void CMediaClientVideoDisplayBody::AddDisplayL(MMMFSurfaceEventHandler& aEventHandler)

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::AddDisplayL +++");

	if (iEventHandler)

		{

		User::Leave(KErrInUse);

		}

	iEventHandler = &aEventHandler;

	if (IsSurfaceCreated())

		{

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

		}

	DEBUG_PRINTF("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_PRINTF("CMediaClientVideoDisplayBody::AddDisplayWindowL +++");

    DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL - aWindow WsHandle 0x%X", aWindow->WsHandle());

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::AddDisplayWindowL - aClipRect %d,%d - %d,%d", aClipRect.iTl.iX, aClipRect.iTl.iY, aClipRect.iBr.iX, aClipRect.iBr.iY);

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::AddDisplayWindowL - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::AddDisplayWindowL - aVideoExtent %d,%d - %d,%d", aVideoExtent.iTl.iX, aVideoExtent.iTl.iY, aVideoExtent.iBr.iX, aVideoExtent.iBr.iY);

    DEBUG_PRINTF3("CMediaClientVideoDisplayBody::AddDisplayWindowL - aScaleWidth %f, aScaleHeight %f", aScaleWidth, aScaleHeight);

    DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL - aRotation %d", aRotation);

    DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL - aAutoScaleType %d", aAutoScaleType);

    DEBUG_PRINTF3("CMediaClientVideoDisplayBody::AddDisplayWindowL - aHorizPos %d, aVertPos %d", aHorizPos, aVertPos);

	if (!IsRotationValid(aRotation))

		{

		User::Leave(KErrArgument);

		}

	if (!IsAutoScaleTypeValid(aAutoScaleType))

		{

		User::Leave(KErrArgument);

		}

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

	if (pos != KErrNotFound)

		{

		User::Leave(KErrInUse);

		}

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

	iClientWindows.AppendL(winData);

	iCropRegion = aCropRegion;

	TBool prevClientWindowIsInFocus = iClientWindowIsInFocus;

    UpdateFocus();

	if (IsSurfaceCreated())

		{

        // if first window was just added OR the new window has moved us from out of focus to in focus

        if(((iClientWindows.Count() == 1) || !prevClientWindowIsInFocus) && iClientRequestedExtDisplaySwitching &&

                iClientWindowIsInFocus && iExtDisplayConnected)

            {

            TRAPD(err, CreateExtDisplayHandlerL());

            DEBUG_PRINTF2("CMediaClientVideoDisplayBody::AddDisplayWindowL CreateExtDisplayHandlerL error %d", err);

            if(err == KErrNone)

                {

#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

                // attach surface to client window and hide

                // ignore error - no handling required

                SetHiddenBackgroundSurfaceOnClientWindow(winData);

#endif                

                // handle external display

                SetWindowArrayPtr2Ext();

                User::LeaveIfError(RedrawWindows(aCropRegion));

                }

            }

        if(!iSwitchedToExternalDisplay)

            {

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

            }

		}

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::AddDisplayWindowL ---");

	}

void CMediaClientVideoDisplayBody::RemoveDisplay()

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplay +++");

	iEventHandler = NULL;

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplay ---");

	}	

TInt CMediaClientVideoDisplayBody::RemoveDisplayWindow(const RWindowBase& aWindow)

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplayWindow +++");

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

	if (pos >= 0)

	    {

#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

        if(IsSurfaceCreated())

#else

	    if(IsSurfaceCreated() && !iSwitchedToExternalDisplay)

#endif

	        {

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

            // Make sure all window rendering has completed before proceeding

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

            if (ws)

                {

                ws->Finish();

                }

            }

	    iClientWindows.Remove(pos);

	    TBool prevClientWindowIsInFocus = iClientWindowIsInFocus;

        UpdateFocus();

        // if only window was just removed OR removal has moved us from in focus to out of focus

        if((iClientWindows.Count() == 0 || prevClientWindowIsInFocus) && iSwitchedToExternalDisplay &&

                !iClientWindowIsInFocus)

            {

            RemoveBackgroundSurface(ETrue);

            SetWindowArrayPtr2Client();

            RemoveExtDisplayHandler();

            RedrawWindows(iCropRegion);

            }

		}

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveDisplayWindow ---");

	return pos;

	}

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

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceCreated +++");

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);

    DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SurfaceCreated - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRegion %d,%d - %d,%d", aCropRegion.iTl.iX, aCropRegion.iTl.iY, aCropRegion.iBr.iX, aCropRegion.iBr.iY);

    TBool emitEvent = EFalse;

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

		{

		emitEvent = ETrue;

		}

	iSurfaceId = aSurfaceId;

	iCropRect = aCropRect;

	iAspectRatio = aAspectRatio;

	iCropRegion = aCropRegion;

	if(iServerClient)

	    {

        iServerClient->SetSurface(iSurfaceId);

	    }

	if (emitEvent && iEventHandler)

		{

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

		}

	TInt err = KErrNone;

    if((iClientWindows.Count() > 0) && iClientRequestedExtDisplaySwitching && iClientWindowIsInFocus)

        {

        if(iExtDisplayConnected && !iExtDisplayHandler)

            {

            TRAP(err, CreateExtDisplayHandlerL());

            DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SurfaceCreated CreateExtDisplayHandlerL error %d", err);

            if(err == KErrNone)

                {

#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

                SetHiddenBackgroundSurfaceOnAllClientWindows();

#endif          

                SetWindowArrayPtr2Ext();

                }

            }

        }

    err = RedrawWindows(aCropRegion);

    DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SurfaceCreated --- Return error %d", err);

	return err;

	}

void CMediaClientVideoDisplayBody::RemoveBackgroundSurface(TBool aTriggerRedraw)

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveBackgroundSurface +++");

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::RemoveBackgroundSurface - iSurfaceId %08x:%08x:%08x:%08x", iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);

	if (IsSurfaceCreated())

		{

		RWsSession* ws = NULL;

		TInt count = iWindowsArrayPtr->Count();

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

			{

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

            // Make sure all window rendering has completed before proceeding

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

            if (ws)

                {

                ws->Finish();

                }

			}

		}

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveBackgroundSurface ---");

	}

void CMediaClientVideoDisplayBody::RemoveSurface(TBool aControllerEvent)

    {

    DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveSurface +++");

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::RemoveSurface - iSurfaceId %08x:%08x:%08x:%08x", iSurfaceId.iInternal[3], iSurfaceId.iInternal[2], iSurfaceId.iInternal[1], iSurfaceId.iInternal[0]);

    if (IsSurfaceCreated())

        {

        RemoveBackgroundSurface(ETrue);

        if (iEventHandler  && aControllerEvent)

            {

            iEventHandler->MmsehRemoveSurface(iSurfaceId);

            }

        if(iSwitchedToExternalDisplay)

            {

            SetWindowArrayPtr2Client();

#ifdef MEDIA_CLIENT_SURFACE_NOT_REMOVED_FROM_CLIENT_WINDOW

            RemoveBackgroundSurface(ETrue);

#endif

            RemoveExtDisplayHandler();

            }

        iSurfaceId = TSurfaceId::CreateNullId();

        }

    DEBUG_PRINTF("CMediaClientVideoDisplayBody::RemoveSurface ---");

    }

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

	{

	DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged +++");

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aSurfaceId %08x:%08x:%08x:%08x", aSurfaceId.iInternal[3], aSurfaceId.iInternal[2], aSurfaceId.iInternal[1], aSurfaceId.iInternal[0]);

    DEBUG_PRINTF5("CMediaClientVideoDisplayBody::SurfaceCreated - aCropRect %d,%d - %d,%d", aCropRect.iTl.iX, aCropRect.iTl.iY, aCropRect.iBr.iX, aCropRect.iBr.iY);

    DEBUG_PRINTF3("CMediaClientVideoDisplayBody::SurfaceCreated - aAspectRatio %d/%d", aAspectRatio.iNumerator, aAspectRatio.iDenominator);

    if (!IsSurfaceCreated())

		{

		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged --- Return error KErrNotSupproted");

		return KErrNotSupported;

		}

	if (iSurfaceId != aSurfaceId)

		{

		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged --- Return error KErrInUse");

		return KErrInUse;

		}

	if (iEventHandler)

		{

		iEventHandler->MmsehSurfaceParametersChanged(iSurfaceId, aCropRect, aAspectRatio);

		}

	TInt error = KErrNone;

	if (iCropRect != aCropRect || iAspectRatio != aAspectRatio)

		{

		// We only need to redraw if the aspect ratio has changed, or the area of the video to

		// display (i.e the intersection of client crop region and surface crop rectangle) has changed.

		TBool redraw = EFalse;

		if (iAspectRatio != aAspectRatio || SurfaceCropRectChangeRequiresRedraw(iCropRect, aCropRect, iCropRegion))

			{

			redraw = ETrue;

			}

		iCropRect = aCropRect;

		iAspectRatio = aAspectRatio;

		if (redraw)

			{

			error = RedrawWindows(iCropRegion);

			}

		}

	else

		{

		DEBUG_PRINTF("CMediaClientVideoDisplayBody::SurfaceParametersChanged - Surface parameters have not changed");

		}

	DEBUG_PRINTF2("CMediaClientVideoDisplayBody::SurfaceParametersChanged --- Return error %d", error);