// NotifierProxy.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/common.mmh>

#include <e32notif.h>

#include <e32ver.h>

#if !defined(FSHELL_WSERV_SUPPORT) || !defined(FSHELL_MEMORY_ACCESS_SUPPORT)

EXPORT_C TInt StartNotifierProxyThreadFunction(TAny*)

	{

	return KErrNotSupported;

	}

EXPORT_C TInt ShutdownProxyNotifier()

	{

	return KErrNotSupported;

	}

EXPORT_C TBool NotifierProxyIsRunning()

	{

	return EFalse;

	}

#else

#include "NotifierProxy.h"

#include <fshell/clogger.h>

#include "utils.h"

_LIT(KRealNotifierServerName,   "RealNtfyr");

_LIT8(KRealNotifierServerName8, "RealNtfyr");

#define LeaveIfErr(_err, _args...) \

	do \

		{ \

		if (_err < 0) \

			{ \

			RClogger::Slog(_args); \

			User::Leave(_err); \

			} \

		} \

		while (0)

const TInt KShutdownProxy = 1000;

const TInt KPingProxy = 1001;

const TInt KInfoPrintTime = 2000000; // 2 seconds

TInt RRealNotifier::Connect()

	{

	return CreateSession(KRealNotifierServerName, TVersion(KNotifierMajorVersionNumber,KNotifierMinorVersionNumber,KNotifierBuildVersionNumber),-1);

	}

CNotifierProxyServer::CNotifierProxyServer()

	: CServer2(0, ESharableSessions)

	{

	}

void CNotifierProxyServer::ConstructL()

	{

	//__DEBUGGER();

	SetupWindowL();

	TFontSpec spec(_L("Roman"), 12);

	LeaveIfErr(iScreenDevice->GetNearestFontInPixels(iFont, spec), _L("Couldn't find a suitable font"));

	iPeriodic = CPeriodic::NewL(CActive::EPriorityStandard);

	iText.ReserveL(8);

	iUndertaker = new(ELeave) CPanicDialogWatcher(*this);

	iUndertaker->ConstructL();

	StartL(KRealNotifierServerName); // We start with the name of what we're going to rename the real notifier to, this way we ensure that the following code can only be run by one thread at once

	RMemoryAccess::LoadDriver();

	LeaveIfErr(iMemAccess.Open(), _L("Couldn't open mem access"));

	TServerKernelInfoBuf buf;

	TInt err = iMemAccess.GetObjectInfo(EServer, _L("!Notifier"), buf);

	User::LeaveIfError(err);

	TUint8* realServer = buf().iAddressOfKernelObject;

	err = iMemAccess.GetObjectInfo(EServer, KRealNotifierServerName, buf);

	User::LeaveIfError(err);

	TUint8* myServer = buf().iAddressOfKernelObject;

	// Should really have some kind of swap operation here...

	iMemAccess.InPlaceObjectRename(EServer, realServer, KRealNotifierServerName8);

	iMemAccess.InPlaceObjectRename(EServer, myServer, _L8("!Notifier"));

	iProxying = ETrue;

	}

CNotifierProxyServer::~CNotifierProxyServer()

	{

	delete iRedrawer;

	//delete iAnimationTimer;

	//delete iBitmap;

	//delete iDsa;

	delete iScreenDevice;

	delete iGc;

	iWin.Close();

	iWg.Close();

	iWs.Close();

	delete iPeriodic;

	iText.ResetAndDestroy();

	delete iUndertaker;

	if (iProxying)

		{

		TServerKernelInfoBuf buf;

		TInt err = iMemAccess.GetObjectInfo(EServer, KRealNotifierServerName, buf);

		if (!err)

			{

			TUint8* realServer = buf().iAddressOfKernelObject;

			iMemAccess.InPlaceObjectRename(EServer, realServer, _L8("!Notifier"));

			// Temporarily both us and the real server will have name !Notifier. When we finish destructing, we'll clean up and the system should be back in the state it was

			}

		}

	iMemAccess.Close();

	RMemoryAccess::CloseDriver();

	}

CSession2* CNotifierProxyServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

	{

	CNotifierProxySession* res = new(ELeave) CNotifierProxySession();

	CleanupStack::PushL(res);

	res->ConstructL();

	CleanupStack::Pop(res);

	return res;

	}

void CNotifierProxySession::ConstructL()

	{

	User::LeaveIfError(iRealNotifier.Connect());

	}

CNotifierProxyServer& CNotifierProxySession::Server()

	{

	return *const_cast<CNotifierProxyServer*>(static_cast<const CNotifierProxyServer*>(CSession2::Server()));

	}

const CNotifierProxyServer& CNotifierProxySession::Server() const

	{

	return *static_cast<const CNotifierProxyServer*>(CSession2::Server());

	}

void CNotifierProxySession::ServiceL(const RMessage2 &aMessage)

	{

	switch (aMessage.Function())

		{

		case ENotifierInfoPrint:

			{

			//__DEBUGGER();

			RBuf buf;

			CleanupClosePushL(buf);

			buf.CreateL(aMessage.GetDesLengthL(0));

			aMessage.ReadL(0, buf);

			RThread client;

			TInt err = aMessage.Client(client);

			TUint clientId = 0;

			if (!err) clientId = client.Id();

			client.Close();

			Server().InfoPrint(buf, clientId);

			CleanupStack::PopAndDestroy(&buf);

			aMessage.Complete(KErrNone);

			break;

			}

		case EStartNotifier:

			{

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

			RBuf8 buf, responseBuf;

			CleanupClosePushL(buf);

			buf.CreateL(aMessage.GetDesLengthL(1));

			aMessage.ReadL(1, buf);

			TInt res = KErrNone;

			if (aMessage.Ptr2())

				{

				CleanupClosePushL(responseBuf);

				responseBuf.CreateL(aMessage.GetDesMaxLengthL(2));

				res = iRealNotifier.StartNotifier(notifierUid, buf, responseBuf);

				if (res == KErrNone || responseBuf.Length())

					{

					aMessage.WriteL(2, responseBuf);

					}

				CleanupStack::PopAndDestroy(&responseBuf);

				}

			else

				{

				res = iRealNotifier.StartNotifier(notifierUid, buf);

				}

			CleanupStack::PopAndDestroy(&buf);

			aMessage.Complete(res);

			break;

			}

		case EStartNotifierFromSpecifiedDll:

		case EStartNotifierFromSpecifiedDllAndGetResponse:

			aMessage.Complete(KErrNotSupported); // This is what the docs say - god knows why the client bothers to pass it through

			break;

		case ECancelNotifier:

			{

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

			TInt res = iRealNotifier.CancelNotifier(notifierUid);

			aMessage.Complete(res);

			break;

			}

		case EUpdateNotifier:

			{

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

			RBuf8 buf, responseBuf;

			CleanupClosePushL(buf);

			buf.CreateL(aMessage.GetDesLengthL(1));

			aMessage.ReadL(1, buf);

			CleanupClosePushL(responseBuf);

			responseBuf.CreateL(aMessage.GetDesMaxLengthL(2));

			TInt res = iRealNotifier.UpdateNotifier(notifierUid, buf, responseBuf);

			if (res == KErrNone || responseBuf.Length())

				{

				aMessage.WriteL(2, responseBuf);

				}

			CleanupStack::PopAndDestroy(&responseBuf);

			CleanupStack::PopAndDestroy(&buf);

			aMessage.Complete(res);

			break;

			}

		case EUpdateNotifierAndGetResponse:

		case EStartNotifierAndGetResponse:

		case ENotifierNotify:

			{

			CAsyncWaiter* waiter = new(ELeave) CAsyncWaiter(iRealNotifier, aMessage);

			waiter->ForwardMessageL();

			break;

			}

		case ENotifierNotifyCancel:

			iRealNotifier.NotifyCancel();

			aMessage.Complete(KErrNone);

			break;

		case KShutdownProxy:

			CActiveScheduler::Stop();

			break;

		case KPingProxy:

			aMessage.Complete(KErrNone);

			break;

		default:

			__DEBUGGER();

			aMessage.Complete(KErrNotSupported);

		}

	}

void CNotifierProxySession::Disconnect(const RMessage2 &aMessage)

	{

	iRealNotifier.Close();

	//TODO Need to wait for any CAsyncWaiters to be completed? If so, do it here and defer the super call until that time

	CSession2::Disconnect(aMessage);

	}

CAsyncWaiter::CAsyncWaiter(RRealNotifier& aRealNotifier, const RMessage2& aMessage)

	: CActive(CActive::EPriorityStandard), iRealNotifier(aRealNotifier), iMsg(aMessage)

	{

	CActiveScheduler::Add(this);

	}

CAsyncWaiter::~CAsyncWaiter()

	{

	iBuf.Close();

	iWideBuf.Close();

	iResponseBuf.Close();

	}

void CAsyncWaiter::ForwardMessageL()

	{

	switch (iMsg.Function())

		{

		case EUpdateNotifierAndGetResponse:

			{

			TUid notifierUid = TUid::Uid(iMsg.Int0());

			iBuf.CreateL(iMsg.GetDesLengthL(1));

			iMsg.ReadL(1, iBuf);

			iResponseBuf.CreateL(iMsg.GetDesMaxLengthL(2));

			iRealNotifier.UpdateNotifierAndGetResponse(iStatus, notifierUid, iBuf, iResponseBuf);

			SetActive();

			break;

			}

		case EStartNotifierAndGetResponse:

			{

			TUid notifierUid = TUid::Uid(iMsg.Int0());

			iBuf.CreateL(iMsg.GetDesLengthL(1));

			iMsg.ReadL(1, iBuf);

			iResponseBuf.CreateL(iMsg.GetDesMaxLengthL(2));

			iRealNotifier.StartNotifierAndGetResponse(iStatus, notifierUid, iBuf, iResponseBuf);

			SetActive();

			break;

			}

		case ENotifierNotify:

			{

			// iWideBuf is the combined buffer

			iWideBuf.CreateL(iMsg.GetDesLengthL(1));

			iMsg.ReadL(1, iWideBuf);

			// iResponseBuf is the button val

			iResponseBuf.CreateMaxL(sizeof(TInt));

			TInt comboLineLen = iMsg.Int2();

			TInt comboButLen = iMsg.Int3();

			const TUint16* ptr = iWideBuf.Ptr();

			iTempPtrs[0].Set(ptr, comboLineLen >> 16);

			ptr += iTempPtrs[0].Length();

			iTempPtrs[1].Set(ptr, comboLineLen & 0xFFFF);

			ptr += iTempPtrs[1].Length();

			iTempPtrs[2].Set(ptr, comboButLen >> 16);

			ptr += iTempPtrs[2].Length();

			iTempPtrs[3].Set(ptr, comboButLen & 0xFFFF);

			iRealNotifier.Notify(iTempPtrs[0], iTempPtrs[1], iTempPtrs[2], iTempPtrs[3], *(TInt*)iResponseBuf.Ptr(), iStatus);

			SetActive();

			break;

			}

		default:

			__DEBUGGER();

		}

	}

void CAsyncWaiter::RunL()

	{

	TInt res = iStatus.Int();

	switch (iMsg.Function())

		{

		case EUpdateNotifierAndGetResponse:

		case EStartNotifierAndGetResponse:

			if (res == KErrNone || iResponseBuf.Length())

				{

				TInt err = iMsg.Write(2, iResponseBuf);

				if (err)

					{

					res = err;

					}

				}

			iMsg.Complete(res);

			break;

		case ENotifierNotify:

			{

			TInt err = iMsg.Write(0, iResponseBuf);

			if (err) res = err;

			iMsg.Complete(res);

			break;

			}

		default:

			__DEBUGGER();

			User::Leave(KErrNotSupported);

		}

	delete this; // Our work here is done

	}

void CAsyncWaiter::DoCancel()

	{

	// We never call Cancel on our waiters

	}

void MainL()

	{

	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	CNotifierProxyServer* server = new(ELeave) CNotifierProxyServer;

	CleanupStack::PushL(server);

	server->ConstructL();

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2, scheduler); // server, scheduler

	}

EXPORT_C TInt StartNotifierProxyThreadFunction(TAny*)

	{

	TInt err = KErrNoMemory;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if (cleanup)

		{

		TRAP(err, MainL());

		delete cleanup;

		}

	return err;

	}

class RDebugNotifier : public RNotifier

	{

public:

	TInt ShutdownProxy()

		{

		return SendReceive(KShutdownProxy, TIpcArgs());

		}

	TInt PingProxy()

		{

		return SendReceive(KPingProxy, TIpcArgs());

		}

	};

EXPORT_C TInt ShutdownProxyNotifier()

	{

	RDebugNotifier notifier;

	TInt err = notifier.Connect();

	if (err == KErrNotFound)

		{

		// Oh dear, !Notifier isn't running. Meaning we renamed it then crashed, probably. Try renaming the real one

		RMemoryAccess::LoadDriver();

		RMemoryAccess mem;

		err = mem.Open();

		if (err) return err;

		TServerKernelInfoBuf buf;

		TInt err = mem.GetObjectInfo(EServer, KRealNotifierServerName, buf);

		if (!err)

			{

			TUint8* realServer = buf().iAddressOfKernelObject;

			mem.InPlaceObjectRename(EServer, realServer, _L8("!Notifier"));

			}

		mem.Close();

		return err;

		}

	err = notifier.ShutdownProxy();

	if (err == KErrServerTerminated) err = KErrNone; // It's expected to get KErrServerTerminated, because we deliberately don't complete the message. This way the client is more likely to get the completion once the server has actually gone, and not slightly before

	notifier.Close();

	return err;

	}

EXPORT_C TBool NotifierProxyIsRunning()

	{

	RDebugNotifier notifier;

	TInt err = notifier.Connect();

	if (err) return EFalse; // Not even original notifier is running?!

	err = notifier.PingProxy();

	notifier.Close();

	return err == KErrNone; // The real proxy will return KErrNotSupported in this scenario

	}

void CNotifierProxyServer::SetupWindowL()

	{

	//__DEBUGGER();

	LeaveIfErr(iWs.Connect(), _L("Couldn't connect to windowserver"));

	//iWs.SetAutoFlush(ETrue);

	iRedrawer = new(ELeave) CRedrawer(*this);

	iRedrawer->Go();

	iScreenDevice = new(ELeave) CWsScreenDevice(iWs);

	LeaveIfErr(iScreenDevice->Construct(), _L("Couldn't construct screen device")); // User default screen number

	LeaveIfErr(iScreenDevice->CreateContext(iGc), _L("Couldn't create gc"));

	iWg = RWindowGroup(iWs);

	LeaveIfErr(iWg.Construct(2, EFalse), _L("Couldn't construct windowgroup"));

	iWin = RWindow(iWs);

	LeaveIfErr(iWin.Construct(iWg, (TUint32)this), _L("Couldn't construct window"));

	iWin.SetBackgroundColor(KRgbBlack);

	iWg.SetOrdinalPosition(0, 1000); // 1000 is ECoeWinPriorityAlwaysAtFront, but I don't want the dependancy on a cone header

	TRect rect(TPoint(), TSize(iScreenDevice->SizeInPixels().iWidth, 50));

	iWin.SetExtent(rect.iTl, rect.Size());

	iWin.SetVisible(EFalse);

	iWin.Activate();

	iWs.Flush();

	//iBitmap = new(ELeave) CFbsBitmap;

	//LeaveIfErr(iBitmap->Create(iScreenDevice->SizeInPixels(), EColor16MU), _L("Couldn't create bitmap"));

	//iDsa = CDirectScreenAccess::NewL(iWs, *iScreenDevice, iWin, *this);

	}

void CNotifierProxyServer::DoWservInitiatedRedraw(const TRect& /*aRect*/)

	{

	//__DEBUGGER();

	// This code based on CCoeControl::HandleRedrawEvent

	//iWin.BeginRedraw(aRect);

	iWin.BeginRedraw(TRect(TPoint(), iWin.Size()));

	iGc->Activate(iWin);

	iGc->UseFont(iFont);

	iGc->SetPenColor(KRgbGreen);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->SetBrushColor(KRgbBlack);

	for (TInt i = 0; i < iText.Count(); i++)

		{

		TPoint drawPoint(0, iFont->FontMaxAscent() + i * iFont->FontLineGap());

		if (drawPoint.iY > iWin.Size().iHeight)

			{

			// We've more to draw than we have room. Bail.

			break;

			}

		//iGc->DrawText(iText[i]->iText, drawPoint);

		iGc->DrawText(iText[i]->iText, BoxForLine(i), iFont->FontMaxAscent());

		}

	iGc->DiscardFont();

	iGc->Deactivate();

	iWin.EndRedraw();

	}

TRect CNotifierProxyServer::BoxForLine(TInt aLineIndex)

	{

	TRect textBox = TRect(0, aLineIndex * iFont->FontLineGap(), iWin.Size().iWidth, (aLineIndex+1) * iFont->FontLineGap());

	return textBox;

	}

RWsSession& CNotifierProxyServer::WsSession()

	{

	return iWs;

	}

void CNotifierProxyServer::InfoPrint(const TDesC& aText, TUint aClientId)

	{

	TPtrC text(aText);

	TInt newline = aText.Locate('\n');

	if (newline != KErrNotFound)

		{

		// UIQ supported 2-line infoprints so some code puts a newline in - if so split it up and treat as two calls

		TPtrC first = aText.Left(newline);

		TPtrC second = aText.Mid(newline+1);

		InfoPrint(first, aClientId);

		//InfoPrint(second, aClientId);

		text.Set(second); // Drop through at this point - prevents recursing if there are many newlines (also stops more than one newline from being recognised)

		}

	CLine* line = new CLine(text, aClientId);

	if (!line) return; // OOM

	// Check if client should be getting frequent flyer miles, if so limit it

	for (TInt i = iText.Count() - 1; i >= 0; i--)

		{

		CLine* line = iText[i];

		if (aClientId && aClientId == line->iClientId && text.Left(6) == line->iText.Left(6))

			{

			iText.Remove(i);