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

//

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "vwsinternal.h"

#include "vwsdefpartner.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "VWSEVENT.H"

#include "VWSERVER.H"

#include "VWSDEBUG.H"

#include "VWSPRIV.H"

#include "vwspatchdata.h"

#include <u32hal.h>

//

// class CVwsThreadWatcher

//

CVwsThreadWatcher::~CVwsThreadWatcher()

	{

	Cancel();

	iThread.Close();

	}

CVwsThreadWatcher::CVwsThreadWatcher()

	: CActive(EPriorityStandard)

	{

	}

TInt CVwsThreadWatcher::StartWatching(const TThreadId& aThreadId, const TCallBack& aCallBack)

	{

	iCallBack=aCallBack;

	if(aThreadId!=iThread.Id())

		{

		if(IsAdded())

			{

			Deque();

			iThread.Close();

			}

		TInt err=iThread.Open(aThreadId);

		if (err==KErrNone)

			{

			CActiveScheduler::Add(this);

			iThread.Logon(iStatus);

			SetActive();

			}

		return err;

		}

	return KErrNone;

	}

void CVwsThreadWatcher::DoCancel()

	{

	iThread.LogonCancel(iStatus);

	}

void CVwsThreadWatcher::RunL()

	{

	iCallBack.CallBack();

	}

//

// CVwsEventTimer.

//

CVwsEventTimer::~CVwsEventTimer()

	{

	delete iPeriodic;

	}

CVwsEventTimer* CVwsEventTimer::NewLC(const TTimeIntervalMicroSeconds32& aClientRequestTimeOut, const TTimeIntervalMicroSeconds32& aServerEventTimeOut)

	{ // static

	CVwsEventTimer* self = new(ELeave) CVwsEventTimer(aClientRequestTimeOut, aServerEventTimeOut);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CVwsEventTimer::CVwsEventTimer(const TTimeIntervalMicroSeconds32& aClientRequestTimeOut, const TTimeIntervalMicroSeconds32& aServerEventTimeOut)

	: iClientRequestTimeOut(aClientRequestTimeOut),

	  iServerEventTimeOut(aServerEventTimeOut),

	  iTimeOutState(EUndefined),

	  iScreenDeviceChangeEvent(EFalse)

	{}

void CVwsEventTimer::ConstructL()

	{

	iPeriodic=CPeriodic::NewL(0);

	}

void CVwsEventTimer::Start(MVwsEventTimerObserver* aObserver,const TBool& aScreenDeviceChangeEvent)

	{

	iObserver=aObserver;

	if (iPeriodic->IsActive())

		{

		iPeriodic->Cancel();

		}

	TTimeIntervalMicroSeconds32 firstDelay(0);

	iTimeOutState=EUndefined;

	if (iClientRequestTimeOut < iServerEventTimeOut)

		{

		iTimeOutState=EClientRequestTimeOut;

		firstDelay=iClientRequestTimeOut;

		}

	else 

		{

		iTimeOutState=EServerEventTimeOut;

		firstDelay=iServerEventTimeOut;

		}

	TTimeIntervalMicroSeconds32 delay(firstDelay);

	iPeriodic->Start(delay,delay,TCallBack(TimerCallBack,this));	

	iScreenDeviceChangeEvent = aScreenDeviceChangeEvent;

	}

TInt CVwsEventTimer::TimerCallBack(TAny* aSelf)

	{ // static

	REINTERPRET_CAST(CVwsEventTimer*,aSelf)->DoTimerCallBack();

	return 0;

	}

void CVwsEventTimer::DoTimerCallBack()

	{

	if (iPeriodic != NULL && iPeriodic->IsActive())

		{

		iPeriodic->Cancel();

		}

	if (iScreenDeviceChangeEvent && iObserver)

		{

		iObserver->HandleTimeOut(iTimeOutState);

		}

	else

		{

		if (iObserver)

			{

			iObserver->HandleTimeOut(iTimeOutState);

			}

		if (iTimeOutState == EClientRequestTimeOut || iTimeOutState == EIntermediateEventTimeOut) 

			{

			TTimeIntervalMicroSeconds32 delay;

			if (iTimeOutState == EClientRequestTimeOut) 

				{

				//Normal delay is given before considering boosting the priority of an application

				delay = iServerEventTimeOut.Int()-iClientRequestTimeOut.Int();

				iTimeOutState = EIntermediateEventTimeOut;

				}

			else

				{

				//Delay of KTimeoutValueForPreemptedProcess is given after boosting priority of an application

				TUint8 patchableConst = KTimeoutValueForPreemptedProcess;

				#ifdef __WINS__

				// For the emulator allow the constant to be patched via epoc.ini

				UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty,

					(TAny*)"KTimeoutValueForPreemptedProcess", &patchableConst); // read emulator property (if present)

				#endif

				delay = patchableConst;

				iTimeOutState = EServerEventTimeOut;

				}

            iPeriodic->Start(delay,delay,TCallBack(TimerCallBack,this));

			}

		}

	}

//

// CVwsServerEvent.

//

CVwsServerEvent::CVwsServerEvent(CVwsServer& aServer,TType aType,CVwsEventQueue& aQueue)

	:CVwsEvent(aType,aQueue),iServer(aServer)

	{

	}

CVwsServerEvent::~CVwsServerEvent()

	{

	if (iObserved)

		{

		iObserved->NullifyObserver();

		}

	}

void CVwsServerEvent::HandleLastOnQueue()

	{

	iServer.HandleLastServerEventOnQueue();

	}

//

// CVwsServerEvent_Activate.

//

CVwsServerEvent_Activate::CVwsServerEvent_Activate(CVwsServer& aServer,TType aType,CVwsEventQueue& aQueue,const TVwsViewId& aViewIdToActivate,CVwsClientMessage* aClientMessage,const RMessage2& aMessage,const TThreadId& aClientThreadId,TVwsCompleteRequest aCompleteRequest,CVwsThreadWatcher* aThreadWatcher,CVwsEventTimer* aEventTimer,const RThread& aThreadOfClientInitiatingViewSwitch)

	: CVwsServerEvent(aServer,aType,aQueue),

	iViewIdToActivate(aViewIdToActivate),

	iClientMessage(aClientMessage),

	iNewViewClientThreadId(0),

	iCompleteRequest(aCompleteRequest),

	iClientThreadId(aClientThreadId),

	iMessage(aMessage),

	iThreadWatcher(aThreadWatcher),

	iEventTimer(aEventTimer),

	iThreadOfClientInitiatingViewSwitch(aThreadOfClientInitiatingViewSwitch)

	{

	}

CVwsServerEvent_Activate::~CVwsServerEvent_Activate()

	{

	delete iClientMessage;

	delete iThreadWatcher;

	delete iEventTimer;

	iThreadOfClientInitiatingViewSwitch.Close();

	}

void CVwsServerEvent_Activate::HandleTimeOut(CVwsEventTimer::TTimeOut aTimeOut)

	{

	if (aTimeOut==CVwsEventTimer::EServerEventTimeOut && iServer.IsServerEventTimeOutEnabled())

		{

		if (iState==EActivationRequested)

			{

			LOG3(CVwsLog::ENormal,_L("PANIC CLIENT \"%x\" for timing out activation view event - activation request was not completed"),iViewIdToActivate.iAppUid.iUid);

			if (TUint(iNewViewClientThreadId)!=0)

				{

				CVwsSession* newViewSession=iServer.SessionByThreadId(iNewViewClientThreadId);

				if (newViewSession)

					{

					if (iServer.IsPriorityBoostBeforePanicEnabled())

						{

						if (iServer.InitializationFinished())

							{

							newViewSession->PanicClient(EVwsViewActivationEventTimeOut);

							}

						}

					else

						{

						newViewSession->PanicClient(EVwsViewActivationEventTimeOut);

						}

					}

				}

			}

		else if (iState==EDeactivationRequested)

			{

			LOG3(CVwsLog::ENormal,_L("PANIC CLIENT \"%x\" for timing out activation view event - deactivation request was not completed"),iServer.ActiveView().iAppUid.iUid);

			CVwsSession* sessionWithActiveView=iServer.ActiveViewSession();

			if (sessionWithActiveView)

				{

				if (iServer.IsPriorityBoostBeforePanicEnabled())

					{

					if (iServer.InitializationFinished())

						{

						sessionWithActiveView->PanicClient(EVwsViewDeactivationEventTimeOut);

						}

					}

				else

					{

					sessionWithActiveView->PanicClient(EVwsViewDeactivationEventTimeOut);

					}

				}

			}

		else

			{

			LOG4(CVwsLog::EQuiet,_L("Aborting activation of view \"%x,%x\" - server event processing timed-out"),iViewIdToActivate.iAppUid.iUid,iViewIdToActivate.iViewUid.iUid);

			Complete(KErrCancel);

			}

		}

	else if (aTimeOut==CVwsEventTimer::EClientRequestTimeOut)

			{

			LOG2(CVwsLog::ELoud,_L("Activation event timer has passed client request time-out"));

			if (iCompleteRequest==ECompleteRequest && iServer.SessionByThreadId(iClientThreadId)!=NULL)

				{

				LOG2(CVwsLog::ELoud,_L("Client request timed-out - silently completing request"));

				iCompleteRequest=EDoNotCompleteRequest;

				iMessage.Complete(KErrNone);

				}

			}

		else if (aTimeOut==CVwsEventTimer::EIntermediateEventTimeOut) 

           { 

           if (iState==EActivationRequested) 

               { 

               iServer.BoostPriority(iServer.SessionByThreadId(iNewViewClientThreadId)); 

               } 

           else if (iState==EDeactivationRequested) 

               { 

               iServer.BoostPriority(iServer.ActiveViewSession()); 

               } 

           } 

	}

void CVwsServerEvent_Activate::ProcessEventL()

	{

LOG4(CVwsLog::ELoud,_L("Starting to process activation of \"%x,%x\""),iViewIdToActivate.iAppUid.iUid,iViewIdToActivate.iViewUid.iUid);

	RequestActivateNewView();

	}

#ifdef _DEBUG

void CVwsServerEvent_Activate::RequestCompleted(TRequestType aType,TInt aError,const RMessage2&)

#else

void CVwsServerEvent_Activate::RequestCompleted(TRequestType /*aType*/,TInt aError,const RMessage2&)

#endif // _DEBUG

	{

	switch (iState)

		{

		case EPending:

			ASSERT(EFalse);

			break;

		case EActivationRequested:

			ASSERT(aType==MVwsSessionObserver::EActivation);

			LOG5(CVwsLog::ELoud,_L("Session request complete [activation event state: EActivationRequested; view to activate: \"%x,%x\", error: %d]"),iViewIdToActivate.iAppUid.iUid,iViewIdToActivate.iViewUid.iUid,aError);

			if (aError)

				{

				if (aError==KErrViewWrongMode)

					{

					RequestActivateSystemDefaultView();

					}

				else

					{

					Complete(aError);

					}

				}

			else

				{

				TVwsViewId viewToDeactivate(iServer.ActiveView());

				// When an application whose view has to be activated is in background, the currently active view will not be deactivated.

				// Note: Switching between different views of the same application must be followed by deactivation of old view

				if ((iMessage.Int3() && !(iServer.IsAppInForeground())) && (viewToDeactivate.iAppUid != iViewIdToActivate.iAppUid))

					{

					LOG4(CVwsLog::ELoud,_L("\"%x,%x\", is activated at the background, so foreground view will not be deactivated"),iViewIdToActivate.iAppUid.iUid,iViewIdToActivate.iViewUid.iUid);

					Complete(KErrNone);

					}

				else

					{

				RequestDeactivateOldView();

					}

				}

			break;

		case ESystemDefaultActivationRequested:

			ASSERT(aType==MVwsSessionObserver::EActivation);

			if (aError)

				{

				LOG3(CVwsLog::EQuiet,_L("Failed to activate system default view, error: %d"),aError);

				RequestActivateSystemDefaultView();

				}

			else

				{

				RequestDeactivateOldView();

				}

			break;

		case EDeactivationRequested:

			ASSERT(aType==MVwsSessionObserver::EDeactivation);

			LOG5(CVwsLog::ELoud,_L("Session request complete [activation event state: EDeactivationRequested; view to activate: \"%x,%x\", error: %d]"),iViewIdToActivate.iAppUid.iUid,iViewIdToActivate.iViewUid.iUid,aError);

			iServer.HandleDeactivation(iServer.ActiveView(),iViewIdToActivate);

			Complete(KErrNone);

			break;

		default:

		case EAppStartRequested:

			ASSERT(EFalse);

		}

// Disable unused parameter warning under release builds

#pragma warning (disable: 4100) 

	}

#pragma warning (default: 4100)

void CVwsServerEvent_Activate::NowObserving(CVwsSessionEvent* aObserved)

	{

	if(iObserved)

	    {

	    iObserved->NullifyObserver();

	    }

       	iObserved = aObserved;

	}

void CVwsServerEvent_Activate::NullifyObserved()

	{

	iObserved = NULL;	

	}

void CVwsServerEvent_Activate::HandleViewAdded(const TVwsViewId& aViewId, const TThreadId& aNewViewClientThreadId)

	{

	ASSERT(iState==EAppStartRequested);

	if (aViewId.iAppUid==iViewIdToActivate.iAppUid

	  &&aViewId.iAppUid==aViewId.iViewUid)

		{

		iViewIdToActivate = aViewId;

		}

	if (aViewId==iViewIdToActivate)

		{

		iServer.SetViewAdditionObserver(NULL);

		// set iNewViewClientThreadId to indicate that the new view should come from the session specified if possible

		iNewViewClientThreadId = aNewViewClientThreadId;

		RequestActivateNewView();

		}

	}

void CVwsServerEvent_Activate::RequestActivateNewView()

	{

	CVwsSession* sessionWithNewView=iServer.SessionByThreadIdAndAppUid(iClientThreadId,iViewIdToActivate.iAppUid);

	// iNewViewClientThreadId may have been set by the caller to indicate a preference between

	// sessions with the same App Uid

	if (sessionWithNewView==NULL && iNewViewClientThreadId!=TThreadId(0))

		{

		sessionWithNewView=iServer.SessionByThreadIdAndAppUid(iNewViewClientThreadId,iViewIdToActivate.iAppUid);

		}

	if (sessionWithNewView==NULL)

		{

		sessionWithNewView=iServer.SessionByUid(iViewIdToActivate.iAppUid);

		}

	if (sessionWithNewView==NULL || (sessionWithNewView && sessionWithNewView->IsExiting()))

		{

		RequestAppStart();

		}

	else

		{

		iNewViewClientThreadId=sessionWithNewView->ClientThreadId();

		DoRequestActivateNewView(*sessionWithNewView);

		}

	}

void CVwsServerEvent_Activate::RequestActivateSystemDefaultView()

	{

	iServer.GetSystemDefaultView(iViewIdToActivate);

	CVwsSession* sessionWithSystemDefaultView=iServer.SessionByUid(iViewIdToActivate.iAppUid);

	// need an empty client message 

	CVwsClientMessage* emptyClientMessage=CVwsClientMessage::New();

	if (emptyClientMessage==NULL)

		{

		Complete(KErrNoMemory);

		}

	if (sessionWithSystemDefaultView)

		{

		iNewViewClientThreadId=sessionWithSystemDefaultView->ClientThreadId();

		RequestClientActivation(*sessionWithSystemDefaultView,emptyClientMessage,ESystemDefaultActivationRequested);

		}

	else if (iThreadWatcher==NULL)

		{

		// app died

		StopActivationProfile();

		ASSERT(iState!=EAppStartRequested);	// Already asked to start app once.

		StartAppStartProfile();

		iServer.SetViewAdditionObserver(this);

		TThreadId appThreadId;

		iClientMessage = emptyClientMessage;

		TInt err=iServer.StartApp(iViewIdToActivate.iAppUid,appThreadId);

		if (err)

			{

			LOG3(CVwsLog::EQuiet,_L("App start FAILED with %d"),err);

			Complete(err);

			}

		else

			{

			iState=EAppStartRequested;

			}

		}

	else

		{

		delete emptyClientMessage;

		}

	}

void CVwsServerEvent_Activate::RequestAppStart()

	{

	ASSERT(iState!=EAppStartRequested);	// Already asked to start app once.

	StartAppStartProfile();

	iServer.SetViewAdditionObserver(this);

	TThreadId appThreadId;

	TInt err=iServer.StartApp(iViewIdToActivate.iAppUid,appThreadId);

	if (err)

		{

		LOG3(CVwsLog::EQuiet,_L("App start FAILED with %d"),err);

		Complete(err);

		}

	else

		{

		iState=EAppStartRequested;

		err=iThreadWatcher->StartWatching(appThreadId,TCallBack(&AppThreadWatcherCallBack,this));

		if (err)

			{

			LOG3(CVwsLog::EQuiet,_L("App start FAILED with %d"),err);

			Complete(err);

			}

		}

	}

TInt CVwsServerEvent_Activate::AppThreadWatcherCallBack(TAny* aPtr)

	// static

	{

	LOG2(CVwsLog::EQuiet,_L("App start FAILED with app client thread death"));

	REINTERPRET_CAST(CVwsServerEvent_Activate*,aPtr)->Complete(KErrCancel);

	return 0;

	}

TInt CVwsServerEvent_Activate::RequestClientActivation(CVwsSession& aSession,CVwsClientMessage* aClientMessage,TState aNewState)

	{

	TRAPD(error,

			aSession.RequestClientActivationL(*this,iViewIdToActivate,iServer.ActiveView(),aClientMessage,iThreadOfClientInitiatingViewSwitch));

	if (error)

		{

		LOG3(CVwsLog::ELoud,_L("RequestClientActivationL FAILED with %d - unable to activate new view"),error);

		if(aSession.IsLeaveAfterOwnershipTaken())

			{

			aSession.ResetLeaveAfterOwnershipTaken();