/*
* Copyright (c) 2004-2007 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:  Contains the CProtocolsLoader class definition.
*
*/


#include <ecom/ecom.h>

#include "cprotocolsloader.h"
#include "mprotprintingdevice.h"
#include "clog.h"
#include "imageprint.h"

namespace
	{
	const TUid KImagePrintEcomUid = { 0x10208A1E };
	}

CProtocolsLoader* CProtocolsLoader::NewL()
	{		
	LOG("[CProtocolsLoader::NewL]\t Begin");
	CProtocolsLoader* self = new (ELeave) CProtocolsLoader();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	LOG("[CProtocolsLoader::NewL]\t End");
	return self;	
	}


CProtocolsLoader::~CProtocolsLoader()
	{
	LOG("[CProtocolsLoader::~CProtocolsLoader]\t Begin");
	iProtocols.ResetAndDestroy(); 
	LOG("[CProtocolsLoader::~CProtocolsLoader]\t End");
	}


TInt CProtocolsLoader::GetNumberOfProtocolsAvailable() const
	{
	LOG("[CProtocolsLoader::GetNumberOfProtocolsAvailable]\t Begin");	
	LOG1("[CProtocolsLoader::GetNumberOfProtocolsAvailable]\t return: %d", iAvailableProtocols);
	LOG("[CProtocolsLoader::GetNumberOfProtocolsAvailable]\t End");
	return iAvailableProtocols;
	}


MProtPrintingDevice* CProtocolsLoader::GetNextProtocol()
	{
	LOG("[CProtocolsLoader::GetNextProtocol]\t Begin");
	if (iAvailableProtocols <= 0)
		return NULL;

	if (iProtIndex == iAvailableProtocols)
		iProtIndex = 0;

	MProtPrintingDevice* temp = iProtocols[iProtIndex];
	iProtIndex++;
	LOG("[CProtocolsLoader::GetNextProtocol]\t End");
	return temp;
	}


MProtPrintingDevice* CProtocolsLoader::GetProtocolAt(TInt aIndex)
	{
	LOG("[CProtocolsLoader::GetProtocolAt]\t Begin");
	if( iAvailableProtocols <= 0 ) return NULL;

	MProtPrintingDevice* temp = NULL;

	if (aIndex < 0)
		temp = (MProtPrintingDevice*) iProtocols[0];
	else
		if (aIndex >= iAvailableProtocols)
			temp = (MProtPrintingDevice*) iProtocols[iAvailableProtocols - 1];
		else
			temp = (MProtPrintingDevice*) iProtocols[aIndex];

	LOG("[CProtocolsLoader::GetProtocolAt]\t End");
	return temp;
	
	}


void CProtocolsLoader::Reset()
	{
	LOG("[CProtocolsLoader::Reset]\t Begin");
	iProtIndex = 0;
	LOG("[CProtocolsLoader::Reset]\t End");
	}


TInt CProtocolsLoader::GetProtocolIndex() const
	{
	LOG("[CProtocolsLoader::GetProtocolIndex]\t Begin");

	TInt retVal = iProtIndex - 1;
	// The next check is probably unnecessary since GetNextProtocol() should only leave iProtIndex with
	// a value between 1 and iAvailableProtocols
	if (retVal < 0)
	{
		retVal = iProtocols.Count() - 1;
	}
	LOG1("[CProtocolsLoader::GetProtocolIndex] return: %d", retVal);
	LOG("[CProtocolsLoader::GetProtocolIndex]\t End");
	return retVal;
	}


TUint CProtocolsLoader::SupportedProtocols() const
	{
	LOG("[CProtocolsLoader::SupportedProtocols]\t Begin");
	LOG1("[CProtocolsLoader::SupportedProtocols] return: %d", iSupportedProtocols);
	LOG("[CProtocolsLoader::SupportedProtocols]\t End");
	return iSupportedProtocols;
	}


CProtocolsLoader::CProtocolsLoader()
	{
	LOG("[CProtocolsLoader::CProtocolsLoader]\t Begin");
	iAvailableProtocols = 0;
	iProtIndex = 0;
	iSupportedProtocols = 0;
	LOG("[CProtocolsLoader::CProtocolsLoader]\t End");
	}

void CProtocolsLoader::ConstructL()
	{
	LOG("[CProtocolsLoader::ConstructL]\t Begin");
	LoadL();
	LOG("[CProtocolsLoader::ConstructL]\t End");
	}

void CProtocolsLoader::LoadL()
	{
	LOG("[CProtocolsLoader::LoadL]\t Begin");	
	RImplInfoPtrArray infoArray;		
	REComSession::ListImplementationsL( KImagePrintEcomUid, infoArray );	
	CleanupClosePushL( infoArray );		
	MProtPrintingDevice* device = NULL;	
	LOG1("CProtocolsLoader::LoadL infoArray.Count(): %d", infoArray.Count());		
	for( TInt i = 0; i < infoArray.Count(); i++ )
		{		
		LOG1("CProtocolsLoader::LoadL i: %d", i);
		TPtrC8 dataType = infoArray[i]->DataType();
		TEComResolverParams resolverParams;
		resolverParams.SetDataType( dataType );
		resolverParams.SetWildcardMatch( ETrue );		
		TAny* prot = REComSession::CreateImplementationL( KImagePrintEcomUid,
				_FOFF( MProtPrintingDevice, iDtor_ID_Key ), NULL, resolverParams );
		device = static_cast<MProtPrintingDevice*>(prot);						
		TCleanupItem clItem( CleanupProt, device );
        CleanupStack::PushL( clItem );				
		device->ConstructL( KNullDesC );
		LOG1("CProtocolsLoader::LoadL device->SupportedProtocols(): %d", device->SupportedProtocols());			
		iProtocols.AppendL( device );
		iSupportedProtocols |= device->SupportedProtocols();														
		CleanupStack::Pop(); // device
		device = NULL;		
		}

	infoArray.ResetAndDestroy();
	CleanupStack::PopAndDestroy(); // infoArray		
	
	iAvailableProtocols = iProtocols.Count();
	LOG("[CProtocolsLoader::LoadL]\t End");
	}
				
void CProtocolsLoader::CleanupProt( TAny* aData )
    {
    LOG("[CProtocolsLoader::CleanupProt]\t Begin");
    MProtPrintingDevice* prot = (MProtPrintingDevice*)aData;
    delete prot;
    LOG("[CProtocolsLoader::CleanupProt]\t End");
    }	

//  End of File