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

 // This file contains the implementation of

 // the CImplementationInformation class.

 // 

 //

 #include <ecom/ecom.h>

 #include <ecom/ecomerrorcodes.h>

 #include <ecom/ecomresolverparams.h>

 #include <ecom/implementationinformation.h>

 #include "RegistryData.h"

 #include "ParseImplementationData.h"

 #include "EComDebug.h"

 #include "ecompanics.h"

 // Constant for no extended interface exist in the implementation information.

 // This is used in externalisation of the object.

 const TInt KNoneExtendedInterface = -1;

 /**

 Intended Usage: This method determines the order of two extended interface.

 */

 static TInt CompareUid(const TUid& aUid1, const TUid& aUid2)

 	{

 	return CompareTUidValues(aUid1.iUid,aUid2.iUid);

 	}

 /** 

 Function for clean up RExtendedInterfaceArray when leave occurs

 */

 void CloseAndDeleteArray(TAny* aPtr)

 	{

 	if (aPtr!=NULL)

 		{

 		(static_cast<RExtendedInterfacesArray*>(aPtr))->Close();

 		delete aPtr;

 		}

 	}		

 // ___________________________________________________________________________

 //

 /**

 Intended Usage	:	Standardised two phase constructor which leaves the

 					CImplementationInformation pointer upon the cleanup stack.

 @leave  		KErrNoMemory

 @since			7.0

 @param			aClientSide a boolean indicating whether the streaming is to performed in client/server side

 @param			aStream The stream to internalize this object from

 @return			A pointer to a fully constructed CImplementationInformation

 @post			Object is fully constructed and initialised

 */

 CImplementationInformation* CImplementationInformation::NewLC(TBool aClientSide,RReadStream& aStream)

 	{

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

 	CleanupStack::PushL(self);

 	self->InternalizeL(aClientSide,aStream);

 	return self;

 	}

 /**

 Intended Usage	:	Standardised two phase construction which leaves nothing

 					on the cleanup stack.  

 @leave  		KErrNoMemory

 @since			7.0

 @param			aUid The unique Id of this implementation

 @param			aVersion The version number of this implementation

 @param			aName The display name of this implementation. This object takes ownership of aName.

 @param			aDataType The data type supported by this implementation. This object takes ownership of aDataType.

 @param			aOpaqueData Data for this implementation which is not used by the ECom framework.

 				This object takes ownership of aOpaqueData.

 @param			aDrive The drive that this implementation is on

 @param			aRomOnly The flag recording whether this implementation may be loaded from ROM only

 @param			aRomBased The flag recording whether this implementation is on ROM or is a later version of one on ROM

 @return			A pointer to a fully constructed CImplementationInformation

 @post			Object is fully constructed and initialised

 */

 CImplementationInformation* CImplementationInformation::NewL(TUid aUid, 

 															 TInt aVersion, 

 															 HBufC*  aName,

 															 HBufC8* aDataType,

 															 HBufC8* aOpaqueData,

 															 TDriveUnit aDrive,

 															 TBool aRomOnly,

 															 TBool aRomBased)

 	{

 	return new(ELeave) CImplementationInformation(aUid, 

 												  aVersion, 

 												  aName,

 												  aDataType,

 												  aOpaqueData,

 												  aDrive,

 												  aRomOnly,

 												  aRomBased);

 	}

 /**

 Standardised two phase construction which leaves nothing on the cleanup stack.  

 @leave  		KErrNoMemory

 @param			aUid The unique Id of this implementation

 @param			aVersion The version number of this implementation

 @param			aName The display name of this implementation. This object takes ownership of aName.

 @param			aDataType The data type supported by this implementation. This object takes ownership of aDataType.

 @param			aOpaqueData Data for this implementation which is not used by the ECom framework.

 				This object takes ownership of aOpaqueData.

 @param			aDrive The drive that this implementation is on

 @param			aRomOnly The flag recording whether this implementation may be loaded from ROM only

 @param			aRomBased The flag recording whether this implementation is on ROM or is a later version of one on ROM

 @param			aExtendedInterfaces The pointer to the array recording the extended interfaces supported by this implementation.

 				This object takes ownership of aExtendedInterfaces. NULL is available for PLUGIN without extended interfaces support.

 @return			A pointer to a fully constructed CImplementationInformation

 @post			Object is fully constructed and initialised

 */	

 CImplementationInformation* CImplementationInformation::NewL(TUid aUid, 

 															 TInt aVersion, 

 															 HBufC*  aName,

 															 HBufC8* aDataType,

 															 HBufC8* aOpaqueData,

 															 TDriveUnit aDrive,

 															 TBool aRomOnly,

 															 TBool aRomBased,

 															 RExtendedInterfacesArray* aExtendedInterfaces)

 	{

 	return new(ELeave) CImplementationInformation(aUid, 

 												  aVersion, 

 												  aName,

 												  aDataType,

 												  aOpaqueData,

 												  aDrive,

 												  aRomOnly,

 												  aRomBased,

 												  aExtendedInterfaces);

 	}	

 /**

 Intended Usage	: D'tor	

 @since			7.0

 @pre 			CImplementationInformation is fully constructed.

 @post			CImplementationInformation is completely destroyed.

 */

 CImplementationInformation::~CImplementationInformation()

 	{

 	// d'tor 

 	if (iDisplayName!=NULL)

 		{

 		delete iDisplayName;

 		}

 	if (iData!=NULL)

 		{

 		delete iData;

 		}

 	if (iOpaqueData!=NULL)

 		{

 		delete iOpaqueData;

 		}

 	if (iExtendedInterfaceList!=NULL)

 		{

 		iExtendedInterfaceList->Close();

 		delete iExtendedInterfaceList;

 		}

 	}

 /**

 Intended Usage	: Default c'tor

 @since			7.0

 @pre 			None

 @post			CImplementationInformation is fully constructed.

 */

 CImplementationInformation::CImplementationInformation() : CBase()

 	{

 	// Do nothing here

 	}

 /**

 Intended Usage	:	Constructor with parameters.  This object takes ownership of

 					aName, aDataType and aOpaqueData.

 @param			aUid The unique Id of this implementation

 @param			aVersion The version number of this implementation

 @param			aName The display name of this implementation

 @param			aDataType The data type supported by this implementation

 @param			aOpaqueData Data for this implementation which is not used by the ECom framework

 @param			aDrive The drive which this implementation is on

 @param			aRomOnly The flag recording whether this implementation may be loaded from ROM only

 @param			aRomBased The flag recording whether this implementation is on ROM or is a later version of one on ROM

 @since			7.0

 @pre 			None

 @post			CImplementationInformation is fully constructed.

 */

 CImplementationInformation::CImplementationInformation(TUid aUid, 

 													   TInt aVersion, 

 													   HBufC*  aName,

 													   HBufC8* aDataType,

 													   HBufC8* aOpaqueData,

 													   TDriveUnit aDrive,

 													   TBool aRomOnly,

 													   TBool aRomBased)

 : CBase(),

 iImplementationUid(aUid),

 iVersion(aVersion),

 iDisplayName(aName),

 iData(aDataType),

 iOpaqueData(aOpaqueData),

 iDrive(aDrive),

 iRomOnly(aRomOnly),

 iRomBased(aRomBased)

 	{

 	// Do nothing here

 	}

 /**

 Constructor with parameters.  This object takes ownership of aName, aDataType, aOpaqueData and aExtendedInterfaces.

 @param			aUid The unique Id of this implementation

 @param			aVersion The version number of this implementation

 @param			aName The display name of this implementation

 @param			aDataType The data type supported by this implementation

 @param			aOpaqueData Data for this implementation which is not used by the ECom framework

 @param			aDrive The drive which this implementation is on

 @param			aRomOnly The flag recording whether this implementation may be loaded from ROM only

 @param			aRomBased The flag recording whether this implementation is on ROM or is a later version of one on ROM

 @param			aExtendedInterfaces The array recording the extended interfaces supported by this implementation.

 				NULL is available for PLUGIN without extended interfaces support.

 @pre 			None

 @post			CImplementationInformation is fully constructed.

 */

 CImplementationInformation::CImplementationInformation(TUid aUid, 

 													   TInt aVersion, 

 													   HBufC*  aName,

 													   HBufC8* aDataType,

 													   HBufC8* aOpaqueData,

 													   TDriveUnit aDrive,

 													   TBool aRomOnly,

 													   TBool aRomBased,

 													   RExtendedInterfacesArray* aExtendedInterfaces)

 : CBase(),

 iImplementationUid(aUid),

 iVersion(aVersion),

 iDisplayName(aName),

 iData(aDataType),

 iOpaqueData(aOpaqueData),

 iDrive(aDrive),

 iRomOnly(aRomOnly),

 iRomBased(aRomBased),

 iExtendedInterfaceList(aExtendedInterfaces)

 	{

 	// Do nothing here

 	}

 /**

 Intended Usage	: Stream out the internal state to aStream.	

 Error Condition	: Leave with the error code.

 @leave  		KErrNoMemory.

 @leave  		@see RWriteStream.

 @since			7.0

 @param			aClientSide a boolean indicating whether the streaming is to performed in client/server side

 @param			aStream The stream to store the data in.

 @pre 			CImplementationInformation is fully constructed and initialized

 */

 void CImplementationInformation::ExternalizeL(TBool aClientSide,RWriteStream& aStream) const

 	{

 	aStream.WriteInt32L(iImplementationUid.iUid);

 	aStream.WriteInt32L(iVersion);

 	if(iDisplayName)

 		{

 		TPtr outputBuf = iDisplayName->Des();

 		aStream.WriteInt32L(outputBuf.Length());

 		aStream.WriteL(outputBuf);

 		}

 	else

 		{

 		aStream.WriteInt32L(0);

 		}

 	if(iData)

 		{

 		TPtr8 outputBuf = iData->Des();

 		aStream.WriteInt32L(outputBuf.Length());

 		aStream.WriteL(outputBuf);

 		}

 	else

 		{

 		aStream.WriteInt32L(0);

 		}

 	if(iOpaqueData)

 		{

 		TPtr8 outputBuf = iOpaqueData->Des();

 		aStream.WriteInt32L(outputBuf.Length());

 		aStream.WriteL(outputBuf);

 		}

 	else

 		{

 		aStream.WriteInt32L(0);

 		}

 	if (aClientSide)

 		{

 		aStream.WriteInt32L(iDrive);		

 		aStream.WriteInt32L(iVid.iId);		

 		}

 	TInt additionalImplInfo=iRomOnly;

 	additionalImplInfo|=iRomBased<<1;

 	additionalImplInfo|=iDisabled<<2;

 	aStream.WriteInt8L(additionalImplInfo);

 	if (iExtendedInterfaceList != NULL)

 		{

 		TInt count = iExtendedInterfaceList->Count();

 		aStream.WriteInt32L(count);

 		for(TInt i = 0; i < count; ++i)

 			{

 	   		aStream.WriteInt32L((*iExtendedInterfaceList)[i].iUid);

 			}

 		}

 	else

 		{

 		aStream.WriteInt32L(KNoneExtendedInterface);

 		}

 	}

 /**

 Intended Usage	: Restore the internal state from aStream.	

 Error Condition	: Leave with the error code.

 @leave  		KErrNoMemory.

 @leave  		@see RReadStream.

 @since			7.0

 @param			aClientSide a boolean indicating whether the streaming is to performed in client/server side

 @param			aStream The stream to read the data from.

 @pre 			CImplementationInformation is fully constructed.

 @post			CImplementationInformation is restored to the state specified by

 				the contents of aStream.

 */

 void CImplementationInformation::InternalizeL(TBool aClientSide,RReadStream& aStream)

 	{

 	delete iDisplayName;

 	iDisplayName = NULL;

 	delete iData;

 	iData = NULL;

 	delete iOpaqueData;

 	iOpaqueData = NULL;

 	iImplementationUid.iUid = aStream.ReadInt32L();

 	iVersion = aStream.ReadInt32L();

 	TInt inputLength = aStream.ReadInt32L();

 	if(inputLength > 0)

   		{

   		// read in the iName string

   		iDisplayName = HBufC::NewL(inputLength);

   		TPtr inputBuf = iDisplayName->Des();

   		aStream.ReadL(inputBuf,inputLength);

   		}

   	inputLength = aStream.ReadInt32L();

 	if(inputLength > 0) 

   		{

   		// read in the iData string

   		iData = HBufC8::NewL(inputLength);

   		TPtr8 inputBuf = iData->Des();

   		aStream.ReadL(inputBuf,inputLength);

   		}

 	inputLength = aStream.ReadInt32L();

 	if(inputLength > 0)

   		{

   		// read in the iOpaqueData string

   		iOpaqueData = HBufC8::NewL(inputLength);

  		TPtr8 inputBuf = iOpaqueData->Des();

   		aStream.ReadL(inputBuf,inputLength);

   		}

 	if (aClientSide)

 		{

 		TUint checkDrive = aStream.ReadInt32L();

 		if (checkDrive > (TUint) KMaxDrives)

 			User::Leave(KErrCorrupt);

 		iDrive = checkDrive;	

 		iVid.iId = aStream.ReadInt32L();		

 		}

 	TInt8 additionalImplInfo=aStream.ReadInt8L();

 	iRomOnly=additionalImplInfo&1;

 	iRomBased=(additionalImplInfo&2)>>1;

 	iDisabled=(additionalImplInfo&4)>>2;

 	TInt count = aStream.ReadInt32L();

 	if (count != KNoneExtendedInterface)

 		{

 		for(TInt i = 0; i < count; i++)

 	   		{

 	   		AddExtendedInterfaceL(TUid::Uid(aStream.ReadInt32L()));

 			}

 		}

 	}

 /**

 Intended Usage	: Set whether this implementation is on ROM or is

 				  a later version of one on ROM

 @pre 			CImplementationInformation is fully constructed

 */

 void CImplementationInformation::SetRomBased(TBool aRomBased)

 	{

 	iRomBased = aRomBased;

 	}

 void CImplementationInformation::SetDrive(TDriveUnit aDrive)

 	{

 	iDrive=aDrive;

 	}

 /**

 Intended Usage	: Add extended interface to list of extended interfaces

 @pre 			CImplementationInformation is fully constructed

 */

 void CImplementationInformation::AddExtendedInterfaceL(const TUid& aExtendedInterface)

 	{

 	// Allocates extended interfaces list in case it is NULL

 	if (iExtendedInterfaceList == NULL)

 		{

 		iExtendedInterfaceList = new(ELeave) RExtendedInterfacesArray(KExtendedInterfaceGranularity);

 		}

 	// Ensure no duplicate extended interface is added.

 	// if there is duplicate extended interface, ignore this extended interface and panic in debug mode.

 	TLinearOrder<TUid> uidComparator(CompareUid);		

 	TInt error = iExtendedInterfaceList->InsertInOrder(aExtendedInterface,uidComparator);

 	if (error == KErrAlreadyExists)

 		{

         __ECOM_TRACE1("ECOM: PANIC in CImplementationInformation::AddExtendedInterfaceL(), duplicate extended interface %x", aExtendedInterface.iUid);

 		__ASSERT_DEBUG(EFalse, User::Panic(KEComServerPanicCategory,EEComPanic_CImlpementationInfromation_DuplicateExIf));		

 		}

 	else

 		{

 		User::LeaveIfError(error);

 		}

 	}	

 /**

 Intended Usage	: Get extended interface list.

 @pre 			CImplementationInformation is fully constructed

 */

 RExtendedInterfacesArray* CImplementationInformation::GetExtendedInterfaceList()

 	{

 	return iExtendedInterfaceList;

 	}

 /**

 Intended Usage	: Get extended interface list.

 @pre 	CImplementationInformation is fully constructed

 @param 	aList The array of the extended interfaces which are supported by this implementation.  

 @publishedPartner

 @released

 */

 EXPORT_C void CImplementationInformation::GetExtendedInterfaceListL(RExtendedInterfacesArray& aList)

 	{

 	aList.Reset();

 	if (iExtendedInterfaceList != NULL)

 		{

 		for (TInt i = 0;i < iExtendedInterfaceList->Count(); i++)

 			{

 			aList.AppendL((*iExtendedInterfaceList)[i]);		

 			}

 		}

 	}