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

 // streammap.cpp: creates and maintaines the association between native stream and a TSurfaceId

 // 

 //

 #include "streammap.h"

 #include <graphics/updateserverprovider.h>

 #include <graphics/surfacemanager.h>

 #include <e32property.h>

 #include <e32std.h>

 #include <e32cmn.h>

 #include "openwfcpanic.h"

 #include "surfacestream.h"

 #include "contentupdateproxy.h"

 static const TInt KOpenWfcInteropCleanupKey = 0x10286FC5;

 COpenWfcStreamMap* COpenWfcStreamMap::pInstance = NULL;

 TUint32 COpenWfcStreamMap::HashFunction(const TSurfaceId& aHashKey)

 	{

 	TPckgC<TSurfaceId> pckg(aHashKey);

 	return DefaultHash::Des8(pckg);

 	}

 EXPORT_C COpenWfcStreamMap& COpenWfcStreamMap::InstanceL()

 	{

 	// would have been nice to try to protect this area with a mutex, however,

 	// the preliminary analyses show we can guarantee the safe creation of the mutex

 	// by invoking InstanceL() from the place the CGce instances are created

 	// If necessary, in future, the code can be expanded by using a named mutex.

 	if (!pInstance)

 		{

 		COpenWfcStreamMap* newInstance = new(ELeave)COpenWfcStreamMap();

 		CleanupStack::PushL(newInstance);

 		newInstance->ConstructL();

 		CleanupStack::Pop(newInstance);

 		pInstance=newInstance;

 		}

 	return *pInstance;

 	}

 CSurfaceStream* COpenWfcStreamMap::Find(const TSurfaceId& aSurfaceId)

 	{

 	Guard g(iMutex);

 	CSurfaceStream** ns = iMap.Find(aSurfaceId);

 	// used if statement to ease debug help

 	if (ns)

 		{

 		(*ns)->AddReference();

 		return *ns;

 		}

 	return NULL;

 	}

 CSurfaceStream* COpenWfcStreamMap::AcquireL(const TSurfaceId& aSurfaceId)

 	{

 	Guard* pGuard = new(ELeave) Guard(iMutex);

 	User::LeaveIfNull(pGuard);

 	CleanupDeletePushL(pGuard);

 	CSurfaceStream** ns = NULL;

 	CSurfaceStream* ret = NULL;

 	ns = iMap.Find(aSurfaceId);

 	if (ns)

 		{

 		WFCI_ASSERT_DEBUG((*ns), EOwfPanicInvalidHasMap);  // should have never happened

 		ret = *ns;

 		}

 	else

 		{

 		ret = CSurfaceStream::NewLC(aSurfaceId);

 		User::LeaveIfError(iMap.Insert(aSurfaceId, ret));

 		CleanupStack::Pop();

 		}

 	ret->AddReference();

 	CleanupStack::PopAndDestroy(pGuard);

 	return ret;

 	}

 EXPORT_C TInt COpenWfcStreamMap::Count()

 	{

 	Guard g(iMutex);

 	TInt count = iMap.Count();

 	return count;

 	}

 EXPORT_C RSurfaceManager& COpenWfcStreamMap::SurfaceManager()

 	{

     WFCI_ASSERT_DEBUG(iSurfaceManager, EOwfPanicInvalidHasMap);

 	return *iSurfaceManager;

 	}

 TInt COpenWfcStreamMap::LockDestroy(CSurfaceStream* aStream)

 	{

 	Guard g(iMutex);

 	TInt ret = KErrNone;

 	if (aStream)

 		{

 		if (aStream->RemainingReference())

 			{

 			const TSurfaceId& surfaceId = aStream->SurfaceId();

 			CSurfaceStream** ns = iMap.Find(surfaceId);

 			// used if statement to ease debug help

 			if (ns && ((*ns) == aStream))

 				{

 				TInt ret = iMap.Remove(surfaceId);

 				delete aStream;

 				}

 			else

 				{

 				ret = KErrNotFound;

 				}

 			}

 		else	// RemainingReference

 			{

 			ret = KErrInUse;

 			}

 		}

 	else	// aStream

 		{

 		ret = KErrArgument;

 		}

 	return ret;

 	}

 COpenWfcStreamMap::COpenWfcStreamMap():

 iMap(THashFunction32<TSurfaceId>(COpenWfcStreamMap::HashFunction), TIdentityRelation<TSurfaceId>()),

 iSurfaceManager(NULL),

 iRegisteredUpdaters()

 	{

 	}

 TInt COpenWfcStreamMap::DeleteSingleton(TAny* aData)

 /**

  * aData    A pointer to the heap registered for this callback

  */

     {

     // Blank the property for this callback

     RThread t;

     RProperty prop;

     TCallBack cb(NULL, NULL);

     TPckgC<TCallBack> cbPckg(cb);

     prop.Set(TUid::Uid(t.SecureId().iId), KOpenWfcInteropCleanupKey, cbPckg);

     prop.Close();

     t.Close();

     if (aData == &User::Heap())

         {

         delete pInstance;

         pInstance = NULL;                

         return ETrue;

         }

     return EFalse;

     }

 COpenWfcStreamMap::~COpenWfcStreamMap()

 	{

 	iMutex.Wait();

         {

         THashMapIter<TSurfaceId, CSurfaceStream*> iter(iMap);

         const TSurfaceId* nextKey = iter.NextKey();

         CSurfaceStream* const* ns = NULL;

         while (nextKey)

             {

             ns = iter.CurrentValue();

             if (ns && *ns)

                 {

                 delete (*ns);

                 }

             nextKey = iter.NextKey();		

             }

         }

 	iMap.Close();

     if (iSurfaceManager)

         {

         iSurfaceManager->Close();

         delete iSurfaceManager;

         iSurfaceManager = NULL;

         }

 	iMutex.Signal();

 	iMutex.Close();

         {

         THashMapIter<TInt32, CExtensionContainer*> iter(iRegisteredUpdaters);

         const TInt32* nextKey = iter.NextKey();

         CExtensionContainer* const* extensionContainer = NULL;

         while (nextKey)

             {

             extensionContainer = iter.CurrentValue();

             if (extensionContainer && *extensionContainer)

                 {

                 delete (*extensionContainer);

                 }

             nextKey = iter.NextKey();       

             }

         }

 	iRegisteredUpdaters.Close();

 	}

 void COpenWfcStreamMap::ConstructL()

 	{

 	User::LeaveIfError(iMutex.CreateLocal());

 	iMap.Reserve(iInitialSize);

 	TSurfaceId surface = TSurfaceId::CreateNullId();

 	User::LeaveIfError(iMap.Insert(surface, NULL));

 	iSurfaceManager = new(ELeave) RSurfaceManager();

 	User::LeaveIfError(iSurfaceManager->Open());

 	RProcess process;

 	TUidType uidType = process.Type();

 	const TInt32 KWservUid = 268450592;

 	const TUid& uid1 = uidType[2];

 	if(uid1.iUid == KWservUid) //only wserv process can start the server

 		{

 		StartSurfaceUpdateServer(iSurfUpdateServ);

 		}

 	// Register the cleanup function in a property defined by WServ

 	RThread t;		

 	TUid category = {t.SecureId().iId};

 	RProperty prop;

 	TCallBack cb(DeleteSingleton, &User::Heap());

     TPckgC<TCallBack> cbPckg(cb);

     // If the property cannot be set the assumption is that the cleanup is not needed

     (void) prop.Set(category, KOpenWfcInteropCleanupKey, cbPckg);

     prop.Close();

 	t.Close();	

 	// StreamMap is constructed from main thread

 	SetMainHeap();

 	}

 COpenWfcStreamMap::Guard::Guard(RFastLock& aLock):

 iLock(aLock)

 	{

 	iLock.Wait();

 	}

 COpenWfcStreamMap::Guard::~Guard()

 	{

 	iLock.Signal();

 	}

 EXPORT_C RHeap* COpenWfcStreamMap::GetMainHeap()

 	{

 	return iMainHeap;

 	}

 void COpenWfcStreamMap::SetMainHeap()

 	{

 	iMainHeap = &User::Heap();

 	}

 TInt COpenWfcStreamMap::RegisterScreenNotifications(TInt aScreenNum, TInt aPriority,TInt aInternalVersion)

 	{

 	COpenWfcStreamMap* pInstance = NULL;

 	TRAPD(err,pInstance = &COpenWfcStreamMap::InstanceL());

 	if (err != KErrNone)

 	    {

 	    return err;

 	    }

 	if (iRegisteredUpdaters.Find(aScreenNum)!= NULL)

 		{

 		return KErrAlreadyExists;

 		}

 	CExtensionContainer* updateProxy = NULL;

 	TRAP(err, updateProxy = CContentUpdateProxy::NewL(aScreenNum, pInstance,aInternalVersion,aPriority));

 	if (err)

 		{

 		return err;

 		}

 	if ((err = iRegisteredUpdaters.Insert(aScreenNum, updateProxy)) != KErrNone)

 	    {

         delete updateProxy;

 	    return err;

 	    }

     if (!pInstance->iSurfUpdateServ)

         {

         return KErrNotReady;    //For testing purposes the backend proxy still exists.

         }

 	err = iSurfUpdateServ->Register(aScreenNum, updateProxy, aPriority);

 	if (err!=KErrNone)

 	    {

         delete updateProxy;

         iRegisteredUpdaters.Remove(aScreenNum);

 	    }

 	return err;

 	}

 CExtensionContainer* COpenWfcStreamMap::RegisteredScreenNotifications(TInt aScreenNum)

     {

     return *iRegisteredUpdaters.Find(aScreenNum);

     }

 TInt COpenWfcStreamMap::UnregisterScreenNotifications(TInt aScreenNum)

 	{

 	TInt err = KErrNone;

 	CExtensionContainer** backend = iRegisteredUpdaters.Find(aScreenNum);

 	if (backend)

 	    {

 	    delete *backend;

 	    iRegisteredUpdaters.Remove(aScreenNum);

         if (iSurfUpdateServ)

             {

             err = iSurfUpdateServ->Register(aScreenNum, NULL, 0);

             }

         else

             {

             err = KErrNotReady;

             }

 	    }

 	else

 	    {

 	    err = KErrNotFound;

 	    }

 	return err;

 	}