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

 	}