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

/**
 @file
*/

#include "wsdisplaychangeao.h"
#include "ScrDev.H"
#include "server.h"

CWsDisplayChangeNotifier::CWsDisplayChangeNotifier(MWsDisplayControl* aNextLevelInterface, CScreen *aOwner)
:CActive(EEventPriority), iNextLevelInterface(aNextLevelInterface), iOwner(aOwner)
	{
	CActiveScheduler::Add(this);
	}

CWsDisplayChangeNotifier* CWsDisplayChangeNotifier::NewL(MWsDisplayControl* aNextLevelInterface, CScreen *aOwner)
	{
	CWsDisplayChangeNotifier* self = new(ELeave) CWsDisplayChangeNotifier(aNextLevelInterface, aOwner);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

void CWsDisplayChangeNotifier::ConstructL()
	{
	iRetry = CEventQueueRetry::NewL();
	}

void CWsDisplayChangeNotifier::IssueNotificationRequest()
	{
	//before submitting request, save the last resolution list
	iLastErr = iNextLevelInterface->GetResolutions(iLastResList);
	if(iLastErr != KErrNone)
		{
		//probabally KErrDisconnect
		iLastResList.Reset();
		}
	iNextLevelInterface->NotifyOnDisplayChange(iStatus);
	SetActive();
	}

void CWsDisplayChangeNotifier::CancelNotificationRequest()
	{
	Cancel();
	}

void CWsDisplayChangeNotifier::RunL()
	{
	if(iStatus == KErrNone)
		{
		//IssueNotificationRequest() will overwrite iLastResList and iLastErr, save a copy first
		TInt lastErr = iLastErr;
		RArray<MWsDisplayControl::TResolution> lastResList;
		CleanupClosePushL(lastResList);
		lastResList.ReserveL(iLastResList.Count());
		for(TInt i = 0; i < iLastResList.Count(); i++)
			{
			lastResList.Append(iLastResList[i]);
			}
		//submit request again, this should be called as early as possible in RunL(). Otherwise display change occurs
		//before submitting the request will be missed.
		IssueNotificationRequest();
		
		RArray<MWsDisplayControl::TResolution> currentResList;
		CleanupClosePushL(currentResList);
		TInt err = iNextLevelInterface->GetResolutions(currentResList);
		if(err != KErrNone)
			{
			//probabally KErrDisconnect
			currentResList.Reset();
			}
		//return code not equal also counts as an event
		if(!IsResListEqual(currentResList, lastResList) || lastErr != err)
			{
			//first thing is to cancel the retry AO if it's running for the last event
			iRetry->CancelRetry();
			
			iOwner->IncreaseDisplaySpinner();
			//put display change event on queue
			RPointerArray<CWsClient> clientArray;
			CleanupClosePushL(clientArray);
			User::LeaveIfError(iOwner->GetNotificationClients(clientArray));
			TBool eventOnAllQueues = ETrue;
			for(TInt i = 0; i < clientArray.Count(); i++)
				{
				if(!TWindowServerEvent::SendDisplayChangedEvents(clientArray[i], iOwner->ScreenNumber(),
						iOwner->ConfigSpinner(), iOwner->DisplaySpinner()))
					{
					eventOnAllQueues = EFalse;
					clientArray[i]->SetRetryFlag(EEventDisplayChanged);
					}
				}
			CleanupStack::PopAndDestroy(&clientArray);
			
			//some event queues are full, kick off retry AO
			if(!eventOnAllQueues)
				{
				iRetry->Init(iOwner);
				iRetry->Retry(KRetryInitialDelay);
				}
						
			//codes below are dealing with detach/attach
			MWsDisplayPolicy* policy = iOwner->DisplayPolicy();
			if((err == KErrDisconnected && lastErr != KErrDisconnected)
					||(currentResList.Count() == 0 && lastResList.Count() != 0))
				{
				//The display is disconnected
				if(policy)
					{
					TInt appMode = policy->SuitableAppMode(MWsDisplayPolicy::EDetach);
					//Last app mode can be resumed when display is connected again from disconnection
					iOwner->DisplayPolicy()->SetLastAppMode(iOwner->ScreenSizeMode());
					//This gonna set the screen mode to smallest app mode
					if(appMode >= 0)
						{
						iOwner->doSetScreenMode(appMode);
						}
					}
				else
					{
					//if policy is not available, do a SetConfiguration set to the same config before disconnect
					//this will update parameters for MDisplayMapping stored in CDisplayPolicy
					TDisplayConfiguration config;
					iNextLevelInterface->GetConfiguration(config);
					iNextLevelInterface->SetConfiguration(config);
					}
				//stop DSA drawing as the above set screen mode is under disconnection and it won't
				//go the normal routine to stop DSA drawing
				iOwner->AbortAllDirectDrawing(RDirectScreenAccess::ETerminateScreenMode);
				}
			
			if(currentResList.Count() > 0 && lastResList.Count() == 0)
				{
				//The display is connected
				if(policy)
					{
					TInt appMode = policy->SuitableAppMode(MWsDisplayPolicy::EAttach);
					//This gonna resume the screen mode to the one before disconnection
					if(appMode >= 0)
						{
						iOwner->doSetScreenMode(appMode);
						}
					}
				else
					{
					//if policy is not available, force a SetConfiguration to trigger a config change notification
					//as the twips size in config is changed on attaching display though resolution may remain 0x0 
					TDisplayConfiguration config;
					config.SetResolution(currentResList[0].iPixelSize);
					iOwner->SetConfiguration(config);
					}
				iOwner->RecalculateModeTwips();
				}
			}
		CleanupStack::PopAndDestroy(2, &lastResList);
		}
	else if(iStatus != KErrCancel && iStatus != KErrNotSupported)
		{
		IssueNotificationRequest();	//This should be ok, not deadlock
		}
		
	}

TBool CWsDisplayChangeNotifier::IsResListEqual(RArray<MWsDisplayControl::TResolution>& aResListA, RArray<MWsDisplayControl::TResolution>& aResListB)
	{
	if (aResListA.Count() != aResListB.Count())
		return EFalse;
	
	for(TInt i = 0; i < aResListA.Count(); i++)
		{
		if(aResListA[i].iPixelSize != aResListB[i].iPixelSize)
			{
			return EFalse;
			}
		if(aResListA[i].iTwipsSize != aResListB[i].iTwipsSize)
			{
			return EFalse;
			}
		if(!(aResListA[i].iFlags == aResListB[i].iFlags))
			{
			return EFalse;
			}
		}
	
	return ETrue;
	}

void CWsDisplayChangeNotifier::DoCancel()
	{}

CWsDisplayChangeNotifier::~CWsDisplayChangeNotifier()
	{
	Cancel();
	iLastResList.Close();
	delete iRetry;
	}

CWsConfigChangeNotifier::CWsConfigChangeNotifier(MWsDisplayControl* aNextLevelInterface, CScreen *aOwner)
:CActive(EEventPriority), iNextLevelInterface(aNextLevelInterface), iOwner(aOwner)
	{
	CActiveScheduler::Add(this);
	}

CWsConfigChangeNotifier* CWsConfigChangeNotifier::NewL(MWsDisplayControl* aNextLevelInterface, CScreen *aOwner)
	{
	CWsConfigChangeNotifier* self = new(ELeave) CWsConfigChangeNotifier(aNextLevelInterface, aOwner);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

void CWsConfigChangeNotifier::ConstructL()
	{
	iRetry = CEventQueueRetry::NewL();
	}

void CWsConfigChangeNotifier::IssueNotificationRequest()
	{
	//Before submitting the request, save last configuration
	iNextLevelInterface->GetConfiguration(iLastConfig);
	iNextLevelInterface->NotifyOnConfigChange(iStatus);
	SetActive();
	}

void CWsConfigChangeNotifier::CancelNotificationRequest()
	{
	Cancel();
	}

void CWsConfigChangeNotifier::UpdateLastSetConfiguration(TDisplayConfiguration& aNewConfig)
    {
    TSize resolution(0,0);
    if (aNewConfig.GetResolution(resolution))
        {
        iLastSetConfig.SetResolution(resolution);
        }
    
    TSize resolutionTwips(0,0);
    if (aNewConfig.GetResolutionTwips(resolutionTwips))
        {
        iLastSetConfig.SetResolutionTwips(resolutionTwips);   
        }
    
    TDisplayConfiguration1::TRotation rotation;
    if (aNewConfig.GetRotation(rotation))
        {
        iLastSetConfig.SetRotation(rotation);
        }
    }

void CWsConfigChangeNotifier::RunL()
	{
	if(iStatus == KErrNone)
		{
		//IssueNotificationRequest() will overwrite iLastConfig, save a copy first
		TDisplayConfiguration lastConfig(iLastConfig);
		IssueNotificationRequest();
		
		TDisplayConfiguration currentConfig;
		iNextLevelInterface->GetConfiguration(currentConfig);
		if(!(currentConfig == lastConfig))
			{
			//first thing is to cancel the retry AO if it's running for the last event
			iRetry->CancelRetry();
			
			iOwner->IncreaseConfigSpinner();
			
            //if the config change comes from a render stage then ensure screen device size 
            //is also updated
            TSize currentRes;
            currentConfig.GetResolution(currentRes);
            TBool disconnected = (currentRes.iHeight == 0 || currentRes.iWidth == 0) ? ETrue : EFalse;
            
            //if the config change is due to CScreen::SetConfiguration() being called then we
            //don't want to update it again. Only update if the configs are different and the
            //display is connected...
            TDisplayConfiguration lastSetConfig(iLastSetConfig);
            if (!((currentConfig == lastSetConfig) || (disconnected)))
                {
                TDisplayConfiguration1::TRotation rotation;
                if (lastSetConfig.GetRotation(rotation))
                    {
                    //use the latest rotation value to ensure we don't get any
                    //inconsistencies with the layer extents
                    currentConfig.SetRotation(rotation);
                    }
                iOwner->UpdateConfiguration(currentConfig);
                }

			//put config change event on queue
			RPointerArray<CWsClient> clientArray;
			CleanupClosePushL(clientArray);
			User::LeaveIfError(iOwner->GetNotificationClients(clientArray));
			TBool eventOnAllQueues = ETrue;
			for(TInt i = 0; i < clientArray.Count(); i++)
				{
				if(!TWindowServerEvent::SendDisplayChangedEvents(clientArray[i], iOwner->ScreenNumber(),
						iOwner->ConfigSpinner(), iOwner->DisplaySpinner()))
					{
					eventOnAllQueues = EFalse;
					clientArray[i]->SetRetryFlag(EEventDisplayChanged);					
					}
				}
			
			CleanupStack::PopAndDestroy(&clientArray);
			//some event queues are full, kick off retry AO
			if(!eventOnAllQueues)
				{
				iRetry->Init(iOwner);
				iRetry->Retry(KRetryInitialDelay);
				}
			}
		iNextLevelInterface->GetConfiguration(iLastSetConfig);
		}
	else if(iStatus != KErrCancel && iStatus != KErrNotSupported)
		{
		IssueNotificationRequest();
		}
	}


void CWsConfigChangeNotifier::DoCancel()
	{}

CWsConfigChangeNotifier::~CWsConfigChangeNotifier()
	{
	Cancel();
	delete iRetry;
	}


