/*
* Copyright (c) 2010 Kanrikogaku Kenkyusho, Ltd.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
* Kanrikogaku Kenkyusho, Ltd. - Initial contribution
*
* Contributors:
*
* Description:  Contains the CDirectPrintProtocolsLoader class definition.
*
*/


#include <ecom/ecom.h>

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

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

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


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


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


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

	if (iProtIndex == iAvailableProtocols)
		iProtIndex = 0;

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


MProtPrintingDevice* CDirectPrintProtocolsLoader::GetProtocolAt(TInt aIndex)
	{
	LOG("[CDirectPrintProtocolsLoader::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("[CDirectPrintProtocolsLoader::GetProtocolAt]\t End");
	return temp;
	
	}


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


TInt CDirectPrintProtocolsLoader::GetProtocolIndex() const
	{
	LOG("[CDirectPrintProtocolsLoader::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("[CDirectPrintProtocolsLoader::GetProtocolIndex] return: %d", retVal);
	LOG("[CDirectPrintProtocolsLoader::GetProtocolIndex]\t End");
	return retVal;
	}


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


TInt CDirectPrintProtocolsLoader::GetProtocolName(TInt aIndex, TDes& aName, TInt& aUid)
	{
	TInt retVal = KErrNone;

	if( iAvailableProtocols <= 0 )
		{
		retVal = KErrNotFound;
		}
	else
		{
		CDirectPrintProtocolInfo* info = NULL;

		if (aIndex < 0)
			{
			info = iProtocolInfos[0];
			}
		else
			{
			if (aIndex >= iAvailableProtocols)
				{
				info = iProtocolInfos[iAvailableProtocols - 1];
				}
			else
				{
				info = iProtocolInfos[aIndex];
				}
			}

		if (info)
			{
			aName.Copy(info->DisplayName());
			aUid = info->ImplementationUid().iUid;
			}
		}

	return retVal;
	}


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

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

void CDirectPrintProtocolsLoader::LoadL()
	{
	LOG("[CDirectPrintProtocolsLoader::LoadL]\t Begin");
	RImplInfoPtrArray infoArray;
	REComSession::ListImplementationsL( KDirectPrintEcomUid, infoArray );
	CleanupClosePushL( infoArray );
	MProtPrintingDevice* device = NULL;
	LOG1("CDirectPrintProtocolsLoader::LoadL infoArray.Count(): %d", infoArray.Count());
	for( TInt i = 0; i < infoArray.Count(); i++ )
		{
		LOG1("CDirectPrintProtocolsLoader::LoadL i: %d", i);
		CImplementationInformation* info = infoArray[i];
		if (info->Version() == 2)
			{
			CDirectPrintProtocolInfo* protocolInfo = CDirectPrintProtocolInfo::NewLC(*info);
			iProtocolInfos.AppendL( protocolInfo );
			CleanupStack::Pop( protocolInfo );

			TPtrC8 dataType = info->DataType();
			TEComResolverParams resolverParams;
			resolverParams.SetDataType( dataType );
			resolverParams.SetWildcardMatch( ETrue );
			TAny* prot = REComSession::CreateImplementationL( KDirectPrintEcomUid,
					_FOFF( MProtPrintingDevice, iDtor_ID_Key ), NULL, resolverParams );
			device = reinterpret_cast<MProtPrintingDevice*>(prot);
			//device->ConstructL( KNullDesC );
			//device = reinterpret_cast<MProtPrintingDevice*>(prot);

			TCleanupItem clItem( CleanupProt, device );
			CleanupStack::PushL( clItem );
			device->ConstructL( KNullDesC );
			LOG1("CDirectPrintProtocolsLoader::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("[CDirectPrintProtocolsLoader::LoadL]\t End");
	}

void CDirectPrintProtocolsLoader::CleanupProt( TAny* aData )
    {
    LOG("[CDirectPrintProtocolsLoader::CleanupProt]\t Begin");
    MProtPrintingDevice* prot = (MProtPrintingDevice*)aData;
    delete prot;
    LOG("[CDirectPrintProtocolsLoader::CleanupProt]\t End");
    }

//  End of File