// Copyright (c) 1997-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 "EIKNFYSV.H"

#include <barsread.h>

#include <coemain.h>

#include <eikenv.h>

#include <eikmsg.h>

#include <e32uid.h>

#include <e32notif.h>

#include "EIKSRV.PAN"

#include "eiknotapi.h"

#include <bafindf.h>

#include <uiklaf/private/lafenv.h>

#include "EIKDEBUG.H"

#include <uiklaf/private/pluginuid.hrh>

#include "eikscchange.h"

_LIT(KPanicClient_CEikServNotifySession,"Eiksrv Cli(Nfy)");

const TInt KQueued = 1;

const TInt KNullClientId = 0;

const TUid KNonExistentUid = {KNullUidValue}; 

/**

@internalComponent

*/

_LIT8(KEikNotifierPaused,"Eik_Notifier_Paused");

/**

@internalComponent

*/

_LIT8(KEikNotifierResumed,"Eik_Notifier_Resumed");

#include <ecom/publicregistry.h>

#include <uikon.hrh>

static const TUid KUidPluginInterfaceNotifiers = {KUikonUidPluginInterfaceNotifiers};

const TUint KNotifierMessageOpCodeLast = 10;

const TUint KRangeCount = 5;

const TInt KOpCodeRanges[KRangeCount] = 

	{	

	ENotifierNotify,

	ECancelNotifier, 

	EStartNotifierAndGetResponse, 

	EUpdateNotifierAndGetResponse,

	KNotifierMessageOpCodeLast,

	};

const TUint8 KElementsIndex[KRangeCount] =

	{

	CPolicyServer::EAlwaysPass, //Allways passing no capability required      [0-2]

	CPolicyServer::ECustomCheck, //Custom check for the Notifier Client's SID (ECancelNotifier and EUpdateNotifier) [3-4]

	CPolicyServer::EAlwaysPass,	//Allways passing no capability required       [5-8]

	CPolicyServer::ECustomCheck,//Custom check for the Notifier Client's SID  (EUpdateNotifierAndGetResponse)[9-(KNotifierMessageOpCodeLast-1)]

	CPolicyServer::ENotSupported, //Not Supported					 		   [KNotifierMessageOpCodeLast-End]

	};

const CPolicyServer::TPolicy KEikServNotifyServerPolicy =

	{

	CPolicyServer::EAlwaysPass, 

	KRangeCount,

	KOpCodeRanges,

	KElementsIndex, 	

	};

/**

@internalComponent 

*/

NONSHARABLE_CLASS(CDiscoverNewImplementation) : public CActive

	{

public:

	static CDiscoverNewImplementation* NewL(CEikSrvNotifierManager& aManager);

	void Start();

	~CDiscoverNewImplementation();

private:

	CDiscoverNewImplementation(CEikSrvNotifierManager& aManager);

	void ConstructL();

	void RunL();

	void DoCancel();

private:

	CEikSrvNotifierManager& iManager;

	REComSession* iEComSession;

	CActiveScheduler*  iScheduler;

	};

/**

@internalComponent 

*/

NONSHARABLE_CLASS(CPluginTrack) : public CBase

	{

public:

	NONSHARABLE_CLASS(TNotifierInfo)

		{

	public:

		TNotifierInfo(TUid aNotifierPluginUid, TUid aNotifierPluginChannelUid);

	public:

		TUid iNotifierPluginUid;

		TUid iNotifierPluginChannelUid;

		};

public:

	CPluginTrack();

	~CPluginTrack();

public:

	TUid iDllUid;

	TUid iPluginImplementationUid;

	TUid iDtr_key;

	RArray<TNotifierInfo> iNotifierInfo;

	};

//

// class CEikServNotifyServer

//

CEikServNotifyServer::CEikServNotifyServer(TInt aPriority, MEikServNotifyAlert* aAlert)

	: CPolicyServer(aPriority, KEikServNotifyServerPolicy), iAlert(aAlert)

	//

	// private c'tor - initialize using NewL()

	//

	{

	}

EXPORT_C  CEikServNotifyServer::~CEikServNotifyServer()

	{

	SetIsExiting();

	if (iAlert)

		iAlert->Release();

	if (iInfoMsg)

		iInfoMsg->Release();

	iInfoMsgGroupWin.Close();

	delete iManager;

	}

EXPORT_C CEikServNotifyServer* CEikServNotifyServer::NewL(MEikServNotifyAlert* aAlert)

	//

	// static - Create and start the server

	{

	CEikServNotifyServer* server = new (ELeave) CEikServNotifyServer(EActivePriorityIpcEventsHigh, aAlert);

	CleanupStack::PushL(server);

	server->ConstructL();

	CleanupStack::Pop(); // server

	return server;

	}

EXPORT_C void CEikServNotifyServer::StartL()

	{

	CServer2::StartL(__NOTIFIER_NAME);

	}

void CEikServNotifyServer::SetIsExiting()

	{

	iExiting = ETrue;

	}

TBool CEikServNotifyServer::IsExiting() const

	{

	return iExiting;

	}

void CEikServNotifyServer::ConstructL()

	//

	// private second phase construction - initialise using NewL()

	//

	{

	// notifier info print

	CEikonEnv* env = CEikonEnv::Static();

	RWsSession& wsSession = env->WsSession();

	iInfoMsgGroupWin = RWindowGroup(wsSession);

	User::LeaveIfError(iInfoMsgGroupWin.Construct((TUint32)this, EFalse)); // EFalse disables key events

	iInfoMsgGroupWin.SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront-1);

	iInfoMsg = LafEnv::NewInfoMsgWinL(*env, iInfoMsgGroupWin);

	// notifier manager

	iManager = CEikSrvNotifierManager::NewL();

	iManager->RegisterL();

	}

EXPORT_C void CEikServNotifyServer::DisplayNotifier(const TDesC& aTitle,const TDesC& aLabel, const TDesC& aBut1, const TDesC& aBut2, MEikNotifyAlertCompletionObserver* aObserver)

	{

	if(iAlert)

		iAlert->DisplayNotifier(aTitle, aLabel, aBut1, aBut2, aObserver);

	}

EXPORT_C void CEikServNotifyServer::DisplayInfoPrint(const TDesC& aDes)

	{

	if(iInfoMsg)

		iInfoMsg->StartDisplay(aDes, EHRightVTop);

	}

CSession2* CEikServNotifyServer::NewSessionL(const TVersion &aVersion,const RMessage2&) const

	{

	const TVersion version(1,0,0); // !! liaise with RNotify client-side class in E32

	if (!User::QueryVersionSupported(version,aVersion))

		User::Leave(KErrNotSupported);

	return CEikServNotifySession::NewL();

	}

CPolicyServer::TCustomResult CEikServNotifyServer::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)

//aAction is not set because default value to it is already set(CPolicyServer::EFailClient)

//aMissing is not set because it is not needed as we aren't overriding CheckFailedL

	{

	const TSecureId clientSid = aMsg.SecureId();

	const TInt count = iAsyncSecureInfoQueue.Count();

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

		{

		if(iAsyncSecureInfoQueue[i].iSecureId == clientSid)

			return CPolicyServer::EPass;

		}

	return CPolicyServer::EFail;

	}

//

// class TNotifierMessageInfo

//

TNotifierMessageInfo::TNotifierMessageInfo(const RMessage2& aMessage, CEikServNotifySession& aEikServNotifySession)

 : iMessage(aMessage), iEikServNotifySession(aEikServNotifySession)

	{

	}

//

// class CEikServNotifySession

//

CEikServNotifySession* CEikServNotifySession::NewL()

	{

	CEikServNotifySession* const notifySession = new(ELeave) CEikServNotifySession;

	CleanupStack::PushL(notifySession);

	notifySession->ConstructL();

	CleanupStack::Pop(notifySession);

	return notifySession;

	}

CEikServNotifySession::~CEikServNotifySession()

	{

	const CEikServNotifyServer& server = Server();

	if (!server.IsExiting())

		server.Manager()->HandleClientExit(iClientId);

	iServer = NULL;

	delete iEikSrvPendingAlert;

	delete iBuffer;

	}

CEikServNotifySession::CEikServNotifySession() : iClientId(reinterpret_cast<TInt>(this))

	{

	}

void CEikServNotifySession::ConstructL()

	{

	iEikSrvPendingAlert = new(ELeave) CEikSrvPendingAlert(*this);

	}

void CEikServNotifySession::ServiceL(const RMessage2 &aMessage)

	//

	// Service requests

	//

	{

	DEBUGPRINT3(_L("CEikServNotifySession::ServiceL(), UID: 0x%X op:%D"),aMessage.Int0(),aMessage.Function());

	TBool completeMessage = ETrue;

	switch (aMessage.Function())

		{

	case ENotifierNotify:

		DisplayAlert(aMessage);

		completeMessage = EFalse; // Completed in HandleAlertCompletion

		break;

	case ENotifierInfoPrint:

		DisplayInfoMsg(aMessage);

		break;

	case EStartNotifier:

		StartNotifierL(aMessage);

		break;

	case ECancelNotifier:

		{

		TInt result = NotifierCancel(aMessage);

		if(result == KErrNone)

			{

			result = Server().Manager()->NotifierCancel(TUid::Uid(aMessage.Int0()));

			}

		aMessage.Complete(result);

		completeMessage = EFalse;

		}

		break;

	case EUpdateNotifier:

		{

		UpdateNotifierL(aMessage);

		completeMessage = EFalse; // Completed in UpdateNotifierL

		}

		break;

	case EStartNotifierAndGetResponse:

		{

		TBool cleanupComplete = ETrue;

		StartNotifierAndGetResponseL(aMessage, cleanupComplete);

		completeMessage = EFalse; // the plug-in has responsibility for completing the message (either synchronously or asynchronously)

		}

		break;

	case EUpdateNotifierAndGetResponse:

		UpdateNotifierAndGetResponseL(aMessage);

		completeMessage = EFalse;

		break;

	default:

		aMessage.Complete(KErrNotSupported);

		break;

		}

	if (completeMessage && !aMessage.IsNull())

		aMessage.Complete(KErrNone);

	DEBUGPRINT3(_L("CEikServNotifySession::ServiceL() finished, UID: 0x%X Message completed: %U"),aMessage.Int0(),completeMessage);

	}

void CEikServNotifySession::DisplayAlert(const RMessage2& aMessage)

	//

	// Display an alert

	//

	{

	iLengthOfCombinedBuffer = aMessage.GetDesLength(1);

	if (iLengthOfCombinedBuffer < 0)

		return;

	iLengthOfFirstLineOfMessage = (static_cast<TUint>(aMessage.Int2())>>16);

	iLengthOfSecondLineOfMessage = (aMessage.Int2()&KMaxTUint16);

	iLengthOfFirstButtonOfMessage = (static_cast<TUint>(aMessage.Int3())>>16);

	iLengthOfSecondButtonOfMessage = (aMessage.Int3()&KMaxTUint16);

	if (iLengthOfCombinedBuffer != iLengthOfFirstLineOfMessage + iLengthOfSecondLineOfMessage + 

									iLengthOfFirstButtonOfMessage + iLengthOfSecondButtonOfMessage)

		{

		aMessage.Panic(KPanicClient_CEikServNotifySession,EEikSrvClientPanicInconsistentMessageParameters);

		return;

		}

	HBufC* const combinedBuffer = HBufC::New(iLengthOfCombinedBuffer);

	if(!combinedBuffer)

		return;

	TPtr combinedBuffer_asWritable(combinedBuffer->Des());

	const TInt error = aMessage.Read(1, combinedBuffer_asWritable);

	if (error)

		{

		delete combinedBuffer;

		return;

		}

	__ASSERT_DEBUG(iBuffer == NULL, User::Invariant());	

	iBuffer = combinedBuffer;

	RNotifierMessageInfoQueue& queue = Server().AsyncMessageQueue();

	const TInt err = queue.Append(TNotifierMessageInfo(aMessage,*this));

	if (!err && queue.Count() == 1) // if the only thing in the queue is what we've just put in it...

		PrepareDisplayAlert();

	}

void CEikServNotifySession::PrepareDisplayAlert()

	{

	const RNotifierMessageInfoQueue& queue = Server().AsyncMessageQueue();

	//Getting the first element from the queue

	ASSERT(queue.Count());

	const TNotifierMessageInfo& firstInQueue = queue[0];

	//Getting the parameters for the notifier message to display	

	const TInt lengthOfFirstLine = firstInQueue.iEikServNotifySession.iLengthOfFirstLineOfMessage;

	const TInt lengthOfSecondLine = firstInQueue.iEikServNotifySession.iLengthOfSecondLineOfMessage;

	const TInt lengthOfFirstButton = firstInQueue.iEikServNotifySession.iLengthOfFirstButtonOfMessage;

	const TInt lengthOfSecondButton = firstInQueue.iEikServNotifySession.iLengthOfSecondButtonOfMessage;

	const TPtrC firstLineOfMessage(firstInQueue.iEikServNotifySession.iBuffer->Left(lengthOfFirstLine));

	const TPtrC secondLineOfMessage(firstInQueue.iEikServNotifySession.iBuffer->Mid(lengthOfFirstLine,lengthOfSecondLine));

	const TPtrC firstButtonOfMessage(firstInQueue.iEikServNotifySession.iBuffer->Mid(lengthOfFirstLine+lengthOfSecondLine,lengthOfFirstButton));

	const TPtrC secondButtonOfMessage(firstInQueue.iEikServNotifySession.iBuffer->Mid(lengthOfFirstLine+lengthOfSecondLine+lengthOfFirstButton,lengthOfSecondButton));

	// after this line we can guarantee that HandleAlertCompletion will be called (assuming that the call to MEikServNotifyAlert's virtual function DisplayNotifier (which is called inside the DisplayNotifier call below) is well-behaved)

	Server().DisplayNotifier(firstLineOfMessage, secondLineOfMessage, firstButtonOfMessage, secondButtonOfMessage, &firstInQueue.iEikServNotifySession);

	}

void CEikServNotifySession::HandleAlertCompletion(const TInt aButtonVal)

	{

	RNotifierMessageInfoQueue& queue = Server().AsyncMessageQueue();

	__ASSERT_ALWAYS(queue.Count() > 0,Panic(EEikServPanicNotifyAlertQueueEmpty));

	const TNotifierMessageInfo& firstInQueue = queue[0];

	firstInQueue.iMessage.Complete(firstInQueue.iMessage.Write(0, TPckgC<TInt>(aButtonVal == EEikBidCancel ? 0 : 1)));

	if (firstInQueue.iEikServNotifySession.iBuffer)

		{

		delete firstInQueue.iEikServNotifySession.iBuffer;

		firstInQueue.iEikServNotifySession.iBuffer = NULL;

		}

	queue.Remove(0);

	if (queue.Count())

		iEikSrvPendingAlert->TriggerNext();

	}

void CEikServNotifySession::DisplayNextPendingAlert()

	{

	if (Server().AsyncMessageQueue().Count() >= 1)

		PrepareDisplayAlert();

 	}

void CEikServNotifySession::DisplayInfoMsg(const RMessage2& aMessage)

	//

	// Display an info message

	//

	{

	TBuf<400> msg;

	const TInt err = aMessage.Read(0, msg);

	aMessage.Complete(err);

	if(!err)

		Server().DisplayInfoPrint(msg);

	}

HBufC8* CEikServNotifySession::GetRemoteInputBufferLC(const RMessage2& aMessage, TInt aSlot)

	{

	HBufC8* const inputBuffer = HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLength(aSlot)));

	TPtr8 input(inputBuffer->Des());

	aMessage.ReadL(aSlot, input);

	return inputBuffer;

	}

void CEikServNotifySession::StartNotifierL(const RMessage2& aMessage)

	{

	HBufC8* const inputBuffer = GetRemoteInputBufferLC(aMessage, 1);

	const TUid notifierUid = TUid::Uid(aMessage.Int0());

	const TSecureId secureId = aMessage.SecureId();

	RNotifierSecureInfoQueue& secureInfoQueue = Server().AsyncSecureInfoQueue();

	TInt queueTotal = secureInfoQueue.Count();

    TBool needsNewEntry = ETrue;

    TInt indexOfInfo=0;

    for(indexOfInfo = 0; indexOfInfo < queueTotal; indexOfInfo++)

        {

        if (secureInfoQueue[indexOfInfo].iNotifierUid == notifierUid && secureInfoQueue[indexOfInfo].iSecureId == secureId)

            {

            secureInfoQueue[indexOfInfo].iCount++;

            needsNewEntry = EFalse;

            break;

            }

        }

    if (needsNewEntry)

        {

        secureInfoQueue.AppendL(TNotifierSecureInfo(notifierUid, secureId));

        }

	if (!aMessage.Int2()) // if the third parameter is null

		{

        TRAPD(err, Server().Manager()->NotifierStartL(TUid::Uid(aMessage.Int0()),*inputBuffer,NULL,iClientId));

        if(err)

            {

            if (needsNewEntry)

                {

                secureInfoQueue.Remove(queueTotal);

                }

            else

                {

                secureInfoQueue[indexOfInfo].iCount--;

                }

            User::Leave(err);

            }

		}

	else

		{

		HBufC8* const responseBuffer = HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesMaxLength(2)));

		TPtr8 response(responseBuffer->Des());

		TRAPD(err, Server().Manager()->NotifierStartL(TUid::Uid(aMessage.Int0()), *inputBuffer, &response, iClientId));	

	    if(err)

	        {

	        if (needsNewEntry)

	            {

	            secureInfoQueue.Remove(queueTotal);

	            }

	        else

	            {

	            secureInfoQueue[indexOfInfo].iCount--;

	            }

	        User::Leave(err);

	        }

        aMessage.WriteL(2,response);

        CleanupStack::PopAndDestroy(responseBuffer);

	    }

	CleanupStack::PopAndDestroy(inputBuffer);

	}

void CEikServNotifySession::UpdateNotifierL(const RMessage2& aMessage)

	{

	const RNotifierSecureInfoQueue& secureInfoQueue=Server().AsyncSecureInfoQueue();

	const TUid notifierUid = TUid::Uid(aMessage.Int0());

	const TInt queueTotal = secureInfoQueue.Count();

	TBool completeMessage = EFalse;

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

		{

		if(secureInfoQueue[i].iNotifierUid == notifierUid && secureInfoQueue[i].iSecureId == aMessage.SecureId())

			{

			HBufC8* const inputBuffer = GetRemoteInputBufferLC(aMessage, 1);

			if (!aMessage.Int2()) // if the third parameter is null

				{

				TRAPD(err, Server().Manager()->NotifierUpdateL(TUid::Uid(aMessage.Int0()), *inputBuffer, NULL, iClientId));

				aMessage.Complete(err);

				}

			else

				{

				HBufC8* const outputBuffer = HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesMaxLength(2)));

				TPtr8 output(outputBuffer->Des());

				TRAPD(err, Server().Manager()->NotifierUpdateL(notifierUid, *inputBuffer, &output, iClientId));

				if(!err)