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

			}

		}

	}