/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

* Implements the UPS database handle manager.	See class and function

* definitions for more information.

*

*/

/**

 @file

*/

#include <f32file.h>

#include "upscommon.h"

#include "policycache.h"

#include "upspolicycachehandle.h"

namespace UserPromptService

{

NONSHARABLE_CLASS(CPolicyCacheContainer) : public CBase

	{

public:

	static CPolicyCacheContainer *NewL(RFs &aFs);

	void IncrementReferenceCount();

	void DecrementReferenceCount();

	inline CPolicyCache *PolicyCache();

	TInt ReferenceCount() const;

	void NotifyOnRef1(TRequestStatus &aStatus);

	void CancelNotifyOnRef1();

private:

	void ConstructL(RFs &aFs);

	~CPolicyCacheContainer();

	TInt iReferenceCount;

	CPolicyCache *iPolicyCache;

	TRequestStatus *iClientRequest;

	};

inline CPolicyCache *CPolicyCacheContainer::PolicyCache()

	{

	ASSERT(iPolicyCache != 0);

	return iPolicyCache;

	}

inline TInt CPolicyCacheContainer::ReferenceCount() const

	{

	return iReferenceCount;

	}

RPolicyCacheCountedHandle::RPolicyCacheCountedHandle(RFs &aFs)

	: iFs(aFs), iContainer(0)

	{

	}

RPolicyCacheCountedHandle::RPolicyCacheCountedHandle(RPolicyCacheCountedHandle &aPolicyCacheManager)

	: iFs(aPolicyCacheManager.iFs), iContainer(0)

	{

	*this = aPolicyCacheManager;

	}

RPolicyCacheCountedHandle &RPolicyCacheCountedHandle::operator=(const RPolicyCacheCountedHandle &aRhs)

	{

	if(this == &aRhs) return *this;

	Release();

	if(aRhs.iContainer)

		{

		iContainer = aRhs.iContainer;

		iContainer->IncrementReferenceCount();

		}

	return *this;

	}

RPolicyCacheCountedHandle::~RPolicyCacheCountedHandle()

/**

	Destructor - make sure cache container is released.

*/

	{

	Release();

	}

void RPolicyCacheCountedHandle::OpenL()

/**

	Create/Open a new policy cache. If this manager is already opened then the existing cache is

	released first (see Release()).

*/

	{

	// First release any existing container/policy cache.

	Release();

	// Now create a new one

	iContainer = CPolicyCacheContainer::NewL(iFs);

	}

void RPolicyCacheCountedHandle::Release()

/**

	Release the current policy cache container. If this decreases its reference count to 0, it will be

	deleted.

*/

	{

	if(iContainer)

		{

		iContainer->DecrementReferenceCount();

		iContainer = 0;

		}

	}

TBool RPolicyCacheCountedHandle::IsOpen() const

	{

	return iContainer != 0;

	}

CPolicyCache *RPolicyCacheCountedHandle::operator->()

/**

	Returns the CPolicyCache ptr so -> can be used to call policy cache functions.

	If the class is not already open, then we will attempt to open ourself using OpenL().

	Note that this operator can leave...

*/

	{

	if(iContainer == 0)

		{

		OpenL();

		ASSERT(iContainer);

		}

	return iContainer->PolicyCache();

	}

void RPolicyCacheCountedHandle::NotifyOnRef1(TRequestStatus &aStatus)

/**

	Register for notifcation when the underlying CPolicyCacheContainer reference

	count reaches 1, presumably when the client holds the only reference.

	Only one client is allowed to register against a single CPolicyCacheContainer.

*/

	{

	if((iContainer == 0) || (iContainer->ReferenceCount() <= 1))

		{

		// No container or ref count is 1, so complete now.

		TRequestStatus *rs = &aStatus;

		*rs = KRequestPending;

		User::RequestComplete(rs, KErrNone);

		return;

		}

	iContainer->NotifyOnRef1(aStatus);

	}

void RPolicyCacheCountedHandle::CancelNotifyOnRef1()

/**

	Cancel the call to NotifyOnRef1. The request will be completed immediately.

*/

	{

	if(!iContainer)

		{

		return;

		}

	iContainer->CancelNotifyOnRef1();

	}

CPolicyCacheContainer *CPolicyCacheContainer::NewL(RFs &aFs)

/**

	Create a CPolicyCacheContainer containing a CPolicyCache with a reference count of 1.

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aFs);

	CleanupStack::Pop(self);

	return self;

	}

void CPolicyCacheContainer::IncrementReferenceCount()

/**

	Increment the reference count.

*/

	{

	ASSERT(iReferenceCount > 0);

	++iReferenceCount;

	}

void CPolicyCacheContainer::DecrementReferenceCount()

/**

	Decrement the reference count and delete self if it reaches 0.

*/

	{

	--iReferenceCount;

	if(iReferenceCount <= 1)

		{

		if(iClientRequest && iClientRequest->Int() == KRequestPending)

			{

			User::RequestComplete(iClientRequest, KErrNone);

			}

		}

	if(iReferenceCount <= 0)

		{

		delete this;

		}

	}

void CPolicyCacheContainer::NotifyOnRef1(TRequestStatus &aStatus)

/**

	Register for notifcation when the reference count reduces to 1, presumably 

	when the client holds the only reference.

	Only one client is allowed to register against a single CPolicyCacheContainer.

*/

	{

	BULLSEYE_OFF

	if(iClientRequest != 0)

		{

		TRequestStatus *rs = &aStatus;

		*rs = KRequestPending;

		User::RequestComplete(rs, KErrServerBusy);

		return;

		}

	BULLSEYE_RESTORE

	// Initialise client request

	iClientRequest = &aStatus;

	*iClientRequest = KRequestPending;

	// Are we already at ref 1?

	if(iReferenceCount <= 1)

		{

		User::RequestComplete(iClientRequest, KErrNone);

		}

	}

void CPolicyCacheContainer::CancelNotifyOnRef1()

/**

	Cancel the previous call to NotifyOnRef1.

*/

	{

	if((iClientRequest != 0) && (iClientRequest->Int() == KRequestPending))

		{

		User::RequestComplete(iClientRequest, KErrCancel);

		return;

		}

	}	

void CPolicyCacheContainer::ConstructL(RFs &aFs)

	{

	_LIT(KPolicyDir,"\\private\\10283558\\policies\\");

	iPolicyCache = CPolicyCache::NewL(aFs, KPolicyDir());

	iReferenceCount = 1;

	}

CPolicyCacheContainer::~CPolicyCacheContainer()

	{

	delete iPolicyCache;

	iPolicyCache = 0;

	if(iClientRequest && iClientRequest->Int() == KRequestPending)

		{

		User::RequestComplete(iClientRequest, KErrNone);

		iClientRequest = 0;

		}

	}

} // End of UserPromptService namespace

// End of file