// Copyright (c) 2005-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:
// Implementation of API for querying support for features on a device, and
// receiving notification if features are added or removed.
// 
//

#include <e32property.h>
#include <e32cmn.h>
#include <e32uid.h>
#include "featreg.h"
#include "featregpan.h"
#include "featregcmn.h"

/**
 * Run setup exe, wait for completion: ends only once property defined, or failed
 * @internalComponent
 * @return KErrNone on success, or system-wide error code
 */
static TInt RunFeaturePropertySetupExe()
	{
	const TUidType setupExeUidType(KExecutableImageUid, TUid::Null(), KFeaturePropCat);
	RProcess setupProc;
	TInt result = setupProc.Create(KFeatRegSetupExe, KNullDesC, setupExeUidType);
	if (result != KErrNone)
		{
		return result;
		}
	TRequestStatus setupStatus;
	// request Rendezvous before Resume() to avoid race condition.
	// Also note if request to rendezvous fails (OOM etc.) then setup exe may
	// complete after query code, with feature property possibly undefined
	setupProc.Rendezvous(setupStatus);
	setupProc.Resume();
	setupProc.Close();
	User::WaitForRequest(setupStatus);
	return setupStatus.Int();
	}

/**
 * Dummy feature registry implementation object - never instantiated.
 * @internalComponent
 */
class RFeatureRegistry::TImpl
	{
	TUint32 iDummy;
	};

/**
 * Opens connection to the Feature Registry for making non-static queries.
 * Note all non-static queries return state at the time Open() was called;
 * Feature Registry changes are not observed until instance closed and re-opened.
 *
 * @return KErrNone if successful, negative system-wide error code if fails
 * @publishedPartner
 * @deprecated
 */
EXPORT_C TInt RFeatureRegistry::Open()
	{
	RProperty featureProperty;
	TInt result = featureProperty.Attach(KFeaturePropCat, KFeaturePropKey);
	if (result != KErrNone)
		{
		return result;
		}

	// read feature property header
	TInt propertySize = 0;
	TFeatureHeader header;
	TPckg<TFeatureHeader> headerPckg(header);
	TBool ranSetup = EFalse;
	TInt setupResult = KErrNone;
	while (ETrue)
		{
		result = featureProperty.Get(headerPckg);
		if ((result == KErrOverflow)
			|| ((result == KErrNone) && (headerPckg.Size() >= sizeof(TFeatureHeader))))
			{
			if (header.IsInvalid())
				{
				result = KErrCorrupt;
				}
			else
				{
				propertySize = header.PredictedPropertySize();
				result = KErrOverflow;	// indicates successful outcome from this phase
				}
			break;
			}
		if (ranSetup)
			{
			if (setupResult == KErrNoMemory)
				{
				result = KErrNoMemory;
				}
			else if (setupResult == KErrCorrupt)
				{
				result = KErrCorrupt;
				}
			else
				{
				// must force an error return - other than KErrOverflow
				result = KErrUnknown;
				}
			break;
			}
		setupResult = RunFeaturePropertySetupExe();
		ranSetup = ETrue;
		}

	// allocate and read property. Iterate while overflow reported
	// in case property is republished while reading it
	while (result == KErrOverflow)
		{
		// the feature property data consists of only 32-bit values
		// allocate in TUint32 blocks to cover any alignment issues
		TUint32 size32 = (propertySize + sizeof(TUint32) - 1) / sizeof(TUint32);
		TUint32* propertyBuf32 = new TUint32[size32];
		TUint8* propertyBuf = reinterpret_cast<TUint8*>(propertyBuf32);
		if (propertyBuf == NULL)
			{
			result = KErrNoMemory;
			break;
			}
		TPtr8 propertyDes(propertyBuf, 0, propertySize);
		result = featureProperty.Get(propertyDes);
		if (propertyDes.Size() >= sizeof(TFeatureHeader))
			{
			const TFeatureHeader& headerRef = *(reinterpret_cast<const TFeatureHeader*>(propertyBuf));
			// overflow checking for the following is already done by setup exe
			if ((result == KErrNone) && (!headerRef.IsInvalidOrBadSize(propertyDes.Size())))
				{
				// success
				iImpl = reinterpret_cast<TImpl*>(propertyBuf);
				break;
				}
			// if it's not a valid overflow (where predicted size is indeed larger than maxsize), it's corrupt
			if ((result != KErrOverflow) || (headerRef.PredictedPropertySize() < propertyDes.MaxSize()))
				{
				result = KErrCorrupt;
				}
			}
		else
			{
			result = KErrCorrupt;
			}
		delete[] propertyBuf;
		if (result != KErrOverflow)
			{
			result = KErrCorrupt;
			break;
			}
		}

	featureProperty.Close();
	// panic in debug mode to alert system integrators that the setup exe
	// is absent/inaccessible or the config data is invalid in this OS
	// configuration: a serious problem
	__ASSERT_DEBUG(result != KErrCorrupt, Panic(EFeatRegBadConfig));
	return result;
	}

/**
 * Queries support for feature on the device.
 * Non-static version requiring open instance of class.
 * Recommended when making multiple queries.
 * Note: returns support for feature from the time Open() was called.
 *
 * @param aFeatureUid Unique identifier of feature being queried
 * @return positive value if feature is supported, zero if feature is not supported,
 *     or negative system-wide error code if could not be determined.
 * @pre this registry instance is open
 * @panic FeatReg EFeatRegInvalidUse if this registry instance is not open
 * @publishedPartner
 * @deprecated
 */
EXPORT_C TInt RFeatureRegistry::QuerySupport(TUid aFeatureUid)
	{
	TUint32 dummyInfo;
	return QuerySupport(aFeatureUid, dummyInfo);
	}

/**
 * Queries support for feature on the device.
 * Non-static version requiring open instance of class.
 * Recommended when making multiple queries.
 * Note: returns support for feature from the time Open() was called.
 *
 * @param aFeatureUid Unique identifier of feature being queried
 * @param aInfo addition status information about feature
 * @return positive value if feature is supported, zero if feature is not supported,
 *     or negative system-wide error code if could not be determined.
 * @pre this registry instance is open
 * @panic FeatReg EFeatRegInvalidUse if this registry instance is not open
 * @publishedPartner
 * @deprecated
 */
EXPORT_C TInt RFeatureRegistry::QuerySupport(TUid aFeatureUid, TUint32& aInfo)
	{
	__ASSERT_ALWAYS(iImpl != NULL, Panic(EFeatRegInvalidUse));

	TFeatureHeader* header = reinterpret_cast<TFeatureHeader*>(iImpl);
	TUint32 featureUid = aFeatureUid.iUid;

	// try to find in feature entries first
	TFeatureEntry* entry = reinterpret_cast<TFeatureEntry*>(header + 1);
	if (header->iFeatureEntryCount > 0)
		{
		RArray<TFeatureEntry> entryArray(sizeof(TFeatureEntry), entry, header->iFeatureEntryCount);	
		TFeatureEntry searchEntry = { featureUid , 0 };
		TInt index = entryArray.FindInUnsignedKeyOrder(searchEntry);
		if (index >= 0)
			{
			aInfo = entryArray[index].iInfo;
			return aInfo & EStatusSupportBit;
			}
		}

	// fall back to default ranges - first range to match wins
	TFeatureRange* range = reinterpret_cast<TFeatureRange*>(entry + header->iFeatureEntryCount);
	for (TInt i = header->iFeatureRangeCount; i > 0; --i, ++range)
		{
		if ((featureUid >= range->iLowUid) && (featureUid <= range->iHighUid))
			{
			aInfo = EStatusSupportBit;
			return EStatusSupportBit;
			}
		}
	
	// final default: feature not supported
	aInfo = 0;
	return 0;
	}

/**
 * Closes this registry instance.
 * @publishedPartner
 * @deprecated
 */
EXPORT_C void RFeatureRegistry::Close()
	{
	TUint8* propertyBuf = reinterpret_cast<TUint8*>(iImpl);
	delete[] propertyBuf;
	iImpl = NULL;
	}

/**
 * Queries support for feature on the device.
 * Static version recommended for single queries.
 *
 * @param aFeatureUid Unique identifier of feature being queried
 * @return positive value if feature is supported, zero if feature is not supported,
 *     or negative system-wide error code if could not be determined.
 * @publishedPartner
 * @deprecated
 */
EXPORT_C TInt RFeatureRegistry::QuerySupportS(TUid aFeatureUid)
	{
	TUint32 dummyInfo;
	return QuerySupportS(aFeatureUid, dummyInfo);
	}

/**
 * Queries support for feature on the device.
 * Static version recommended for single queries.
 *
 * @param aFeatureUid Unique identifier of feature being queried
 * @param aInfo addition status information about feature
 * @return positive value if feature is supported, zero if feature is not supported,
 *     or negative system-wide error code if could not be determined.
 * @publishedPartner
 * @deprecated
 */
EXPORT_C TInt RFeatureRegistry::QuerySupportS(TUid aFeatureUid, TUint32& aInfo)
	{
	RFeatureRegistry featReg;
	TInt result = featReg.Open();
	if (result == KErrNone)
		{
		result = featReg.QuerySupport(aFeatureUid, aInfo);
		featReg.Close();
		}
	return result;
	}

/**
 * Implementation class allocated when RFeatureRegistryNotify is opened.
 *
 * @internalComponent
 */
class RFeatureRegistryNotify::TImpl
	{
public:
	RProperty iNotifyProperty;

	TImpl()
		: iNotifyProperty()
		{
		}
	};

/**
 * Open instance of notify object so it can be subscribed to.
 *
 * @return KErrNone if successful, negative system-wide error code if not
 * @internalComponent
 */
EXPORT_C TInt RFeatureRegistryNotify::Open()
	{
	iImpl = new TImpl;
	if (iImpl == NULL)
		{
		return KErrNoMemory;
		}
	TInt result = iImpl->iNotifyProperty.Attach(KFeaturePropCat, KFeaturePropKey);
	if (result != KErrNone)
		{
		// must clean up memory allocated above
		delete iImpl;
		iImpl = NULL;
		return result;
		}
	// feature property and notify property are same in current implementation
	// hence must ensure feature property is already published to avoid false
	// notification when it is first published (just-in-time by the next query)
	TFeatureHeader header;
	TPckg<TFeatureHeader> headerPckg(header);
	result = iImpl->iNotifyProperty.Get(headerPckg);
	if (!((result == KErrOverflow)
		|| ((result == KErrNone) && (headerPckg.Size() >= sizeof(TFeatureHeader)))))
		{
		RunFeaturePropertySetupExe();
		}
	// return fact that Attach() succeeded
	return KErrNone;
	}

/**
 * Issues an asynchronous request to be notified the next time the support
 * status of any features change.
 *
 * To ensure that changes are not missed, always re-subscribe before
 * querying the feature registry.
 *
 * If an outstanding request is cancelled through a call to Cancel(), then it
 * completes with KErrCancel.
 *
 * @pre this instance of notify object must be Open and not already Subscribed to.
 * @param aNotifyStatus The request status object to be signalled on update.
 * @panic FeatReg EFeatRegInvalidUse if this registry notify instance is not open
 * @internalComponent
 */
EXPORT_C void RFeatureRegistryNotify::Subscribe(TRequestStatus &aNotifyStatus)
	{
	__ASSERT_ALWAYS(iImpl != NULL, Panic(EFeatRegInvalidUse));
	iImpl->iNotifyProperty.Subscribe(aNotifyStatus);
	}

/**
 * Cancels an outstanding subscription request for notification of feature registry changes.
 *
 * If the request has not already completed, then it completes with KErrCancel.
 *
 * @pre this instance of notify object must be Open
 * @panic FeatReg EFeatRegInvalidUse if this registry notify instance is not open
 * @internalComponent
 */
EXPORT_C void RFeatureRegistryNotify::Cancel()
	{
	__ASSERT_ALWAYS(iImpl != NULL, Panic(EFeatRegInvalidUse));
	iImpl->iNotifyProperty.Cancel();
	}

/**
 * Closes the registry notify instance.
 *
 * Note: automatically cancels any outstanding notify subscription.
 *
 * @internalComponent
 */
EXPORT_C void RFeatureRegistryNotify::Close()
	{
	if (iImpl)
		{
		// Have checked RProperty::Close() cancels the outstanding subscription
		iImpl->iNotifyProperty.Close();
		}
	delete iImpl;
	iImpl = NULL;
	}