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