// 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;

 	}