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

//

#include <e32svr.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "vwsinternal.h"

#include "viewclipartner.h"

#include "vwsdefpartner.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "VIEWCLI.H"

#include "VWSPRIV.H"

#include "VWSAPPST.H"

#include "VWSERVER.H"

//

// Constants.

//

const TUint KDefaultMessageSlots=5;

const TInt KVwsDefaultScreenDeviceMode=0;

const TInt KVwsServerStackSize=KDefaultStackSize;

const TInt KVwsMinHeapSize=0x2000; 

const TInt KVwsMaxHeapSize=0x1000000; 

_LIT(KVwsViewServerThreadName,"ViewServerThread");

_LIT(KVwsViewServerName,"!ViewServer");

//

// Macros.

//

#define CONNECT_AS_REQUIRED	TInt err=CheckCreateViewServerSession();	if (err) {return err;}

//

// Global functions.

//

//

// RVwsSession.

//

RVwsSession::RVwsSession()

	{

	}

TInt RVwsSession::Connect()

	{

	TInt ret=CreateSession(KVwsViewServerName,Version(),KDefaultMessageSlots);

	if (ret == KErrNone)

		SendReceive(EVwsAsynchronousMessageForServerToPanicClientWith,TIpcArgs(), iPanicStatus);

	return ret;

	}

TVersion RVwsSession::Version() const

	{

	return(TVersion(KVwsMajorVersionNumber,KVwsMinorVersionNumber,KVwsBuildVersionNumber));

	}

TInt RVwsSession::Shutdown() const

	{

	return SendReceive(EVwsClose,TIpcArgs());

	}

TInt RVwsSession::AddView(const TVwsViewId& aViewId) const

	{

	const TPckgC<TVwsViewId> viewId(aViewId);

	return SendReceive(EVwsAddView,TIpcArgs(&viewId));

	}

TInt RVwsSession::SetClientRequestTimeOut(TTimeIntervalMicroSeconds32 aDuration) const

	{

	return SendReceive(EVwsSetClientRequestTimeOut,TIpcArgs(aDuration.Int()));

	}

TInt RVwsSession::SetServerEventTimeOut(TTimeIntervalMicroSeconds32 aDuration) const

	{

	return SendReceive(EVwsSetServerEventTimeOut,TIpcArgs(aDuration.Int()));

	}

TInt RVwsSession::EnableServerEventTimeOut(TBool aEnable) const

	{

	return SendReceive(EVwsEnableServerEventTimeOut,TIpcArgs(aEnable));

	}

TInt RVwsSession::SetSystemDefaultView(const TVwsViewId& aViewId,TInt aMode) const

	{

	const TPckgC<TVwsViewId> viewId(aViewId);

	return SendReceive(EVwsSetSystemDefaultView,TIpcArgs(&viewId,aMode));

	}

TInt RVwsSession::GetSystemDefaultView(TVwsViewId& aViewId)

	{

	TPckg<TVwsViewId> viewId(aViewId);

	return SendReceive(EVwsGetSystemDefaultView,TIpcArgs(&viewId));

	}

TInt RVwsSession::RemoveView(const TVwsViewId& aViewId) const

	{

	const TPckgC<TVwsViewId> viewId(aViewId);

	return SendReceive(EVwsRemoveView,TIpcArgs(&viewId));

	}

void RVwsSession::RequestViewEvent(TVwsViewEventBuf& aViewEventBuf,TInt aLastError,TRequestStatus& aStatus) const

	{

	SendReceive(EVwsRequestViewEvent,TIpcArgs(&aViewEventBuf,aLastError,0,0),aStatus);

	}

	void RVwsSession::RequestViewEvent(TVwsViewEventBuf& aViewEventBuf,TInt aLastError,const TVwsViewIdAndMessageBuf& aViewActivationBuf,const TDesC8& aMessage,TRequestStatus& aStatus) const

	{

	SendReceive(EVwsRequestViewEvent,TIpcArgs(&aViewEventBuf,aLastError,&aViewActivationBuf,&aMessage),aStatus);

	}

TInt RVwsSession::RequestViewEventCancel() const

	{

	return SendReceive(EVwsRequestViewEventCancel,TIpcArgs());

	}

void RVwsSession::ActivateView(const TVwsViewId& aViewId,TUid aCustomMessageId,const TDesC8& aCustomMessage,TRequestStatus& aStatus, TInt aCustomControl)

	{

	iActivateViewId=aViewId;

	iCustomMessage.Set(aCustomMessage);

	SendReceive(EVwsActivateView,TIpcArgs(&iActivateViewId,aCustomMessageId.iUid,&iCustomMessage,aCustomControl),aStatus);

	}

TInt RVwsSession::ActivateView(const TVwsViewId& aViewId,TUid aCustomMessageId,const TDesC8& aCustomMessage, TInt aCustomControl)

	{

	const TPckgC<TVwsViewId> viewId(aViewId);

	return SendReceive(EVwsCreateActivateViewEvent,TIpcArgs(&viewId,aCustomMessageId.iUid,&aCustomMessage,aCustomControl));

	}

TInt RVwsSession::RequestCustomMessage(TDes8& aMessageBuf) const

	{

	return SendReceive(EVwsRequestCustomMessage,TIpcArgs(&aMessageBuf));

	}

TInt RVwsSession::StartApp(TUid aAppToStart) const

	{

	return SendReceive(EVwsStartApp,TIpcArgs(aAppToStart.iUid));

	}

void RVwsSession::DeactivateActiveView(TRequestStatus& aStatus) const

	{

	SendReceive(EVwsDeactivateActiveView,TIpcArgs(),aStatus);

	}

TInt RVwsSession::DeactivateActiveView() const

	{

	return SendReceive(EVwsCreateDeactivateViewEvent,TIpcArgs());

	}

void RVwsSession::DeactivateActiveViewIfOwnerMatch(TRequestStatus& aStatus) const

 	{

 	SendReceive(EVwsDeactivateActiveViewIfOwnerMatch,TIpcArgs(), aStatus);

 	}

TInt RVwsSession::DeactivateActiveViewIfOwnerMatch() const

 	{

 	return SendReceive(EVwsDeactivateActiveViewIfOwnerMatch,TIpcArgs());

 	}

TInt RVwsSession::NotifyNextDeactivation(const TVwsViewId& aViewId) const

	{

	const TPckgC<TVwsViewId> viewId(aViewId);

	return SendReceive(EVwsNotifyNextDeactivation,TIpcArgs(&viewId));

	}

TInt RVwsSession::NotifyNextActivation(const TVwsViewId& aViewId) const

	{

	const TPckgC<TVwsViewId> viewId(aViewId);

	return SendReceive(EVwsNotifyNextActivation,TIpcArgs(&viewId));

	}

TInt RVwsSession::GetPriority()	

	{

	TInt eventHandlerPriority = CActive::EPriorityStandard;

	TPckg<TInt> package(eventHandlerPriority);

	TInt err = SendReceive(EVwsPriority,TIpcArgs(&package));

	if (err != KErrNone)

		{

		return CActive::EPriorityStandard;

		}

	return eventHandlerPriority;

	}

TInt RVwsSession::CheckSourceOfViewSwitch(TBool& aResult,const TSecurityPolicy& aSecurityPolicy,const char* aDiagnostic) const

	{

	const TPckgC<TSecurityPolicy> securityPolicy(aSecurityPolicy);

	TBool result;

	TPckg<TBool> resultPckg(result);

	TIpcArgs ipcArgs(&securityPolicy,NULL,&resultPckg);

	if (aDiagnostic == KSuppressPlatSecDiagnosticMagicValue)

    	{

    	ipcArgs.Set(1, reinterpret_cast<TInt>(KSuppressPlatSecDiagnosticMagicValue));

    	}

  	else if (aDiagnostic!=NULL)

	    	{

	    	TPtrC8 diagnostic(TPtrC8(REINTERPRET_CAST(const TUint8*,aDiagnostic)));

	    	ipcArgs.Set(1,&diagnostic);

	    	}

	const TInt ret=SendReceive(EVwsCheckSourceOfViewSwitch,ipcArgs);

	if (ret==KErrNone)

		{

		aResult=result;

		}

	return ret;

	}

TInt RVwsSession::EnableServerBlankScreen(TBool aEnable) const

	{

	return SendReceive(EVwsEnableServerBlankScreen,TIpcArgs(aEnable));

	}

TInt RVwsSession::SetProtected(TBool aEnable) const

	{

	return SendReceive(EVwsSetProtected,TIpcArgs(aEnable));

	}

TInt RVwsSession::SetCrossCheckUid(const TUid& aCrossCheckUid)

	{

	return SendReceive(EVwsSetCrossCheckUid,TIpcArgs(aCrossCheckUid.iUid));

	}

TInt RVwsSession::SetWindowBackgroundColor(const TRgb& aBgColor)

	{

	return SendReceive(EVwsSetWindowBackgroundColor, TIpcArgs(aBgColor.Internal()));

	}

TInt RVwsSession::GetCurrentActiveViewInSystem(TVwsViewId& aActiveViewId)

	{

	TPckg<TVwsViewId> pckgViewId(aActiveViewId);

	return SendReceive(EVwsCurrentActiveViewId, TIpcArgs(&pckgViewId));

	}

//

// CVwsSessionEventHandler.

//

//The priority is read from the resource file

CVwsSessionEventHandler::CVwsSessionEventHandler(MVwsSessionWrapperObserver& aObserver,RVwsSession& aViewServer,TInt aPriority)

	: CActive(aPriority),iObserver(aObserver),iVwsSession(aViewServer)

 	{

	CActiveScheduler::Add(this);

	Queue();

	}

CVwsSessionEventHandler::~CVwsSessionEventHandler()

	{

	Cancel();

	}

void CVwsSessionEventHandler::Queue()

	{

	ASSERT(!IsActive());

	if (iDoActivationNextQueue)

		{

		iDoActivationNextQueue=EFalse;

		iVwsSession.RequestViewEvent(iViewEventBuf,iLastError,iViewActivationBuf,iCustomMessage,iStatus);

		}

	else

		{

		iVwsSession.RequestViewEvent(iViewEventBuf,iLastError,iStatus);

		}

	SetActive();

	}

void CVwsSessionEventHandler::OnNextQueueActivateView(const TVwsViewIdAndMessage& aViewIdAndMessage)

	{

	iViewActivationBuf=aViewIdAndMessage;

	iCustomMessage.Set(aViewIdAndMessage.iCustomMessage);

	iDoActivationNextQueue=ETrue;

	}

void CVwsSessionEventHandler::RunL()

	{

	TRAP(iLastError,iObserver.HandleViewEventL(iViewEventBuf()));

	Queue();

	}

void CVwsSessionEventHandler::DoRunL()

	{

	RunL();

	}

void CVwsSessionEventHandler::DoCancel()

	{

	iVwsSession.RequestViewEventCancel();

	}

//

// CVwsSessionWrapper.

//

EXPORT_C CVwsSessionWrapper* CVwsSessionWrapper::NewL()

/**

Creates a new CVwsSessionWrapper object.

The object returned by this function cannot be used to add new views or request 

notification of view activations or deactivations. To create an instance without these

limitations, an MVwsSessionWrapperObserver must be specified.

@return A pointer to the new CVwsSessionWrapper object.

 */

	{

	CVwsSessionWrapper* self=NewLC();

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CVwsSessionWrapper* CVwsSessionWrapper::NewLC()

/**

Creates a new CVwsSessionWrapper object, leaving it on the cleanup stack

The object returned by this function cannot be used to add new views or request 

notification of view activations or deactivations. To create an instance without these

limitations, an MVwsSessionWrapperObserver must be specified.

@return A pointer to the new CVwsSessionWrapper object.

 */

	{

	CVwsSessionWrapper* self=new(ELeave) CVwsSessionWrapper();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CVwsSessionWrapper* CVwsSessionWrapper::NewL(MVwsSessionWrapperObserver& aObserver)

/**

Creates a new CVwsSessionWrapper object.

@param aObserver An implementation of MVwsSessionWrapperObserver.

                 The session observer should handle server events such as view

                 activation/deactivation requests for views owned by this session

                 and notifications of view activations/deactivations that have been

                 requested.

@return A pointer to the new CVwsSessionWrapper object.

 */

	{

	CVwsSessionWrapper* self=NewLC(aObserver);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CVwsSessionWrapper* CVwsSessionWrapper::NewLC(MVwsSessionWrapperObserver& aObserver)

/**

Creates a new CVwsSessionWrapper object, leaving it on the cleanup stack.

@param aObserver An implementation of MVwsSessionWrapperObserver.

                 The session observer should handle server events such as view

                 activation/deactivation requests for views owned by this session

                 and notifications of view activations/deactivations that have been

                 requested.

@return A pointer to the new CVwsSessionWrapper object.

 */

	{

	CVwsSessionWrapper* self=new(ELeave) CVwsSessionWrapper(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CVwsSessionWrapper::~CVwsSessionWrapper()

	{

	delete iViewEventHandler;

	if (iVwsSession)

		{

		iVwsSession->Close();

		delete iVwsSession;

		}

	}

// static

EXPORT_C TInt CVwsSessionWrapper::StartViewServer(MVwsAppStarter& aAppStarter)

/**

Starts the view server, spawning a new thread in which the server will run.

Takes a reference to the implementation of the MVwsAppStarter interface aAppStarter

which it will share from the heap and which should be for the exclusive use of the view

server only.

@param aAppStarer An implementation of MVwsAppStarter that the server can use for

                  starting applications.

@return A system-wide error code if the server cannot be started or is already running.

 */

	{

	TFindServer findServer(KVwsViewServerName);

	TFullName name;

	if (findServer.Next(name)==KErrNone)

	    {

	    return KErrAlreadyExists;

	    }

	RThread viewServerThread;

	SVwsCommandLine comLine;

	comLine.iAppStarter=&aAppStarter;

    TInt err = viewServerThread.Create(KVwsViewServerThreadName,ViewServerThreadStart,KVwsServerStackSize,KVwsMinHeapSize,KVwsMaxHeapSize,&comLine,EOwnerThread);

	if (err==KErrNone)

        {

		TRequestStatus requestStatus;

		viewServerThread.Rendezvous(requestStatus);

		viewServerThread.Resume();

		User::WaitForRequest(requestStatus);

		err=requestStatus.Int();

		viewServerThread.Close();

		}

	return err;

	}

EXPORT_C TInt CVwsSessionWrapper::ShutdownViewServer()

/**

Shut down the view server. 

Establishes a connection to the view server if necessary.

@return KErrNone if successful, otherwise one of the system-wide error codes.

 */

	{

	CONNECT_AS_REQUIRED

	return iVwsSession->Shutdown();

	}

EXPORT_C TInt CVwsSessionWrapper::AddView(const TVwsViewId& aViewId)

/**

Adds the view to the list maintained by the view server.

Establishes a connection to the view server if necessary.

@param aViewId The view to be added to the view server's list.

@return KErrNone if successful, otherwise one of the system-wide error codes.

 */	

	{

	CONNECT_AS_REQUIRED

	return iVwsSession->AddView(aViewId);

	}

EXPORT_C TInt CVwsSessionWrapper::RemoveView(const TVwsViewId& aViewId) const

/**

Removes a view from the list maintained by the view server.

@param aViewId The view to be removed from the view server's list.

@return KErrNone if successful, otherwise one of the system-wide error codes.

@panic USER 0 if a connection to the view server has not previously been established.

 */		

	{

	ASSERT(iVwsSession);

	return iVwsSession->RemoveView(aViewId);

	}

EXPORT_C TInt CVwsSessionWrapper::SetSystemDefaultView(const TVwsViewId& aViewId,TInt aMode)

/**

Sets the system default view for a specific screen device mode.

The system default view is the view used when an unrecoverable error in view activation occurs

or when an application exits.

Establishes a connection to the view server if necessary.

@param aViewId The view to use as the system default view in the specified

               screen device mode

@param aMode The screen device mode that should use aViewId as the system

             default view. Valid values for aMode are those listed in the Wserv

             initialization file.

@return KErrNone if successful, otherwise one of the system-wide error codes.

 */

	{

	CONNECT_AS_REQUIRED

	return iVwsSession->SetSystemDefaultView(aViewId,aMode);

	}

EXPORT_C TInt CVwsSessionWrapper::SetSystemDefaultView(const TVwsViewId& aViewId)

/**

Sets the system default view for the default screen device mode.

Establishes a connection to the view server if necessary.

@param aViewId The view to use as the system default view in the default screen

               device mode

@return KErrNone if successful, otherwise one of the system-wide error codes.

 */

	{

	return SetSystemDefaultView(aViewId,KVwsDefaultScreenDeviceMode);

	}

EXPORT_C TInt CVwsSessionWrapper::GetSystemDefaultView(TVwsViewId& aViewId)

/**

Gets the system default view for the current screen device mode

@param aViewId The ViewId of the system default view will be returned in this

               paramater.

@return KErrNone if successful, otherwise one of the system-wide error codes.

 */

	{

	return iVwsSession->GetSystemDefaultView(aViewId);