// Copyright (c) 2007-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 list retrieval helpers classes

// 

//

/**

 @file 

*/

#include "listretrievalhelpers.h"

#include <mmretrieve.h>

#include <etelmm.h>

//Canceller class definition

CTestCanceller::CTestCanceller(CActive* aRetrieve) :

CAsyncOneShot(EPriorityNormal), iRetrieve(aRetrieve)

	{

	}

CTestCanceller::~CTestCanceller()

	{

	}

void CTestCanceller::ConstructL()

	{

	}

void CTestCanceller::RunL()

	{

	iRetrieve->Cancel();

	CActiveScheduler::Stop();

	};

//CRetrieveListHelperBase class definition

template<class TRetriever, class TList, class TSubSess>

CRetrieveListHelperBase<TRetriever, TList, TSubSess>::~CRetrieveListHelperBase()

	{

	if(iRetrieve)

		{

		iRetrieve->Cancel();

		}

	delete iList;

	delete iRetrieve;

	delete iCanceller;

	delete iScheduler;

	}

template<class TRetriever, class TList, class TSubSess>

CRetrieveListHelperBase<TRetriever, TList, TSubSess>::CRetrieveListHelperBase(TSubSess& aSubSess) :

	CActive(EPriorityNormal), iSubSess(aSubSess)

	{

	}

template<class TRetriever, class TList, class TSubSess>

void CRetrieveListHelperBase<TRetriever, TList, TSubSess>::ConstructL()

	{

	//create scheduler if not already present

	if(!CActiveScheduler::Current())

		{

		iScheduler = new(ELeave) CActiveScheduler;

    	CActiveScheduler::Install(iScheduler);

		}

	CreateEtelRetrieverL();

	iCanceller = new (ELeave) CTestCanceller(this);

	CActiveScheduler::Add(this);

	}

template<class TRetriever, class TList, class TSubSess>

void CRetrieveListHelperBase<TRetriever, TList, TSubSess>::RunL()

	{

    CActiveScheduler::Stop();

	}

template<class TRetriever, class TList, class TSubSess>

void CRetrieveListHelperBase<TRetriever, TList, TSubSess>::DoCancel()

	{

	iRetrieve->Cancel();

	}

//

//Definitions for concrete implementations of CRetrieveListHelper//

//CRetrieveMobilePhoneDetectedNetworksHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneDetectedNetworks, CMobilePhoneNetworkList, RMobilePhone>* CRetrieveMobilePhoneDetectedNetworksHelper::NewL(RMobilePhone& aPhone,TListVersion aListNumber)

	{

	CRetrieveMobilePhoneDetectedNetworksHelper* self = new (ELeave) CRetrieveMobilePhoneDetectedNetworksHelper(aPhone,aListNumber);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneDetectedNetworksHelper::CRetrieveMobilePhoneDetectedNetworksHelper(RMobilePhone& aSess,TListVersion aListNumber)

: CRetrieveListHelperBase<CRetrieveMobilePhoneDetectedNetworks, CMobilePhoneNetworkList, RMobilePhone>(aSess), iListVersionToRetrieve(aListNumber)

	{	

	}

void CRetrieveMobilePhoneDetectedNetworksHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneDetectedNetworks::NewL(iSubSess);

	}

void CRetrieveMobilePhoneDetectedNetworksHelper::StartListRetrieval()

	{

		switch(iListVersionToRetrieve)

		{

			case ERetrieveListV1:

			{

				iRetrieve->Start(iStatus);

				break;		

			}

			case ERetrieveListV2:

			{

				iRetrieve->StartV2(iStatus);

				break;	

			}

			case ERetrieveListV5:

			{

				iRetrieve->StartV5(iStatus);

				break;	

			}

		}

	}

TAny* CRetrieveMobilePhoneDetectedNetworksHelper::GetListL()

	{

		switch(iListVersionToRetrieve)

			{

			case ERetrieveListV1:

				{

				return iRetrieve->RetrieveListL();

				}

			case ERetrieveListV2:

				{

				return iRetrieve->RetrieveListV2L();

				}

			case ERetrieveListV5:

				{

				return iRetrieve->RetrieveListV5L();

				}

			default:

				{

				_LIT(KErrorLitText,"Wrong argument was entered by user");

				User::Panic(KErrorLitText, KErrArgument); // Attempting to retrieve a non-existant version of the list.

				break;

				}

			}

		return NULL;

	}	

//

//CRetrieveMobilePhoneSmsListHelper	

CRetrieveMobilePhoneSmsListExec* CRetrieveMobilePhoneSmsListHelper::NewL(RMobilePhoneStore& aSubSess, TInt aStartIndex, TInt aBatchSize)

	{

	CRetrieveMobilePhoneSmsListHelper* self = new (ELeave) CRetrieveMobilePhoneSmsListHelper(aSubSess, aStartIndex, aBatchSize);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneSmsListHelper::CRetrieveMobilePhoneSmsListHelper(RMobilePhoneStore& aSubSess, TInt aStartIndex, TInt aBatchSize)

: CRetrieveListHelperBase<CRetrieveMobilePhoneSmsList, CMobilePhoneGsmSmsList, RMobilePhoneStore>(aSubSess), iStartIndex(aStartIndex), iBatchSize(aBatchSize)

	{	

	}

void CRetrieveMobilePhoneSmsListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneSmsList::NewL(iSubSess, RMobileSmsStore::KETelMobileGsmSmsEntryV1);

	}

void CRetrieveMobilePhoneSmsListHelper::StartListRetrieval()

	{

	if(iStartIndex == -1 || iBatchSize == -1)

		iRetrieve->Start(iStatus);

	else

		iRetrieve->StartBatch(iStatus, iStartIndex,iBatchSize);

	}

TAny* CRetrieveMobilePhoneSmsListHelper::GetListL()

	{

	return iRetrieve->RetrieveGsmListL();

	}

//

//CRetrieveMobilePhoneCFListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneCFList, CMobilePhoneCFList, RMobilePhone>* CRetrieveMobilePhoneCFListHelper::NewL(RMobilePhone& aPhone, RMobilePhone::TMobilePhoneCFCondition aCondition, RMobilePhone::TMobileService aServiceGroup, RMobilePhone::TMobileInfoLocation aLocation)

	{

	CRetrieveMobilePhoneCFListHelper* self = new (ELeave) CRetrieveMobilePhoneCFListHelper(aPhone, aCondition, aServiceGroup, aLocation);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneCFListHelper::CRetrieveMobilePhoneCFListHelper(RMobilePhone& aSess, RMobilePhone::TMobilePhoneCFCondition aCondition, RMobilePhone::TMobileService aServiceGroup,RMobilePhone::TMobileInfoLocation aLocation)

: CRetrieveListHelperBase<CRetrieveMobilePhoneCFList, CMobilePhoneCFList, RMobilePhone>(aSess), iCondition(aCondition), iServiceGroup(aServiceGroup), iLocation(aLocation)

	{	

	}

void CRetrieveMobilePhoneCFListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneCFList::NewL(iSubSess);

	}

void CRetrieveMobilePhoneCFListHelper::StartListRetrieval()

	{

	iRetrieve->Start(iStatus, iCondition, iServiceGroup, iLocation);

	}

TAny* CRetrieveMobilePhoneCFListHelper::GetListL()

	{

	return iRetrieve->RetrieveListL();

	}

//

//CRetrieveMobilePhoneCBListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneCBList, CMobilePhoneCBList, RMobilePhone>* CRetrieveMobilePhoneCBListHelper::NewL(RMobilePhone& aPhone, RMobilePhone::TMobilePhoneCBCondition aCondition,RMobilePhone::TMobileInfoLocation aLocation)

	{

	CRetrieveMobilePhoneCBListHelper* self = new (ELeave) CRetrieveMobilePhoneCBListHelper(aPhone, aCondition,aLocation);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneCBListHelper::CRetrieveMobilePhoneCBListHelper(RMobilePhone& aSess, RMobilePhone::TMobilePhoneCBCondition aCondition, RMobilePhone::TMobileInfoLocation aLocation)

: CRetrieveListHelperBase<CRetrieveMobilePhoneCBList, CMobilePhoneCBList, RMobilePhone>(aSess), iCondition(aCondition),iLocation(aLocation)

	{	

	}

void CRetrieveMobilePhoneCBListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneCBList::NewL(iSubSess);

	}

void CRetrieveMobilePhoneCBListHelper::StartListRetrieval()

	{

	iRetrieve->Start(iStatus, iCondition, iLocation);

	}

TAny* CRetrieveMobilePhoneCBListHelper::GetListL()

	{

	return iRetrieve->RetrieveListL();

	}

//

//Definitions for concrete implementations of CRetrieveListHelper//

//CRetrieveMobilePhoneCWListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneCWList, CMobilePhoneCWList, RMobilePhone>* CRetrieveMobilePhoneCWListHelper::NewL(RMobilePhone& aPhone)

	{

	CRetrieveMobilePhoneCWListHelper* self = new (ELeave) CRetrieveMobilePhoneCWListHelper(aPhone);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneCWListHelper::CRetrieveMobilePhoneCWListHelper(RMobilePhone& aSess)

: CRetrieveListHelperBase<CRetrieveMobilePhoneCWList, CMobilePhoneCWList, RMobilePhone>(aSess)

	{	

	}

void CRetrieveMobilePhoneCWListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneCWList::NewL(iSubSess);

	}

void CRetrieveMobilePhoneCWListHelper::StartListRetrieval()

	{

	iRetrieve->Start(iStatus);

	}

TAny* CRetrieveMobilePhoneCWListHelper::GetListL()

	{

	return iRetrieve->RetrieveListL();

	}	

//

//Definitions for concrete implementations of CRetrieveListHelper//

//CRetrieveMobilePhoneCcbsListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneCcbsList, CMobilePhoneCcbsList, RMobilePhone>* CRetrieveMobilePhoneCcbsListHelper::NewL(RMobilePhone& aPhone)

	{

	CRetrieveMobilePhoneCcbsListHelper* self = new (ELeave) CRetrieveMobilePhoneCcbsListHelper(aPhone);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneCcbsListHelper::CRetrieveMobilePhoneCcbsListHelper(RMobilePhone& aSess)

: CRetrieveListHelperBase<CRetrieveMobilePhoneCcbsList, CMobilePhoneCcbsList, RMobilePhone>(aSess)

	{	

	}

void CRetrieveMobilePhoneCcbsListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneCcbsList::NewL(iSubSess);

	}

void CRetrieveMobilePhoneCcbsListHelper::StartListRetrieval()

	{

	iRetrieve->Start(iStatus);

	}

TAny* CRetrieveMobilePhoneCcbsListHelper::GetListL()

	{

	return iRetrieve->RetrieveListL();

	}	

//

//Definitions for concrete implementations of CRetrieveListHelper//

//CRetrieveMobilePhoneSmspListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneSmspList, CMobilePhoneSmspList, RMobileSmsMessaging>* CRetrieveMobilePhoneSmspListHelper::NewL(RMobileSmsMessaging& aPhone)

	{

	CRetrieveMobilePhoneSmspListHelper* self = new (ELeave) CRetrieveMobilePhoneSmspListHelper(aPhone);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneSmspListHelper::CRetrieveMobilePhoneSmspListHelper(RMobileSmsMessaging& aSess)

: CRetrieveListHelperBase<CRetrieveMobilePhoneSmspList, CMobilePhoneSmspList, RMobileSmsMessaging>(aSess)

	{	

	}

void CRetrieveMobilePhoneSmspListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneSmspList::NewL(iSubSess);

	}

void CRetrieveMobilePhoneSmspListHelper::StartListRetrieval()

	{

	iRetrieve->Start(iStatus);

	}

TAny* CRetrieveMobilePhoneSmspListHelper::GetListL()

	{

	return iRetrieve->RetrieveListL();

	}	

//

//

//Definitions for concrete implementations of CRetrieveListHelper//

//CRetrieveMobilePhoneBroadcastIdListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneBroadcastIdList, CMobilePhoneBroadcastIdList, RMobileBroadcastMessaging>* CRetrieveMobilePhoneBroadcastIdListHelper::NewL(RMobileBroadcastMessaging& aPhone,RMobileBroadcastMessaging::TMobileBroadcastIdType aIdType)

	{

	CRetrieveMobilePhoneBroadcastIdListHelper* self = new (ELeave) CRetrieveMobilePhoneBroadcastIdListHelper(aPhone, aIdType);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneBroadcastIdListHelper::CRetrieveMobilePhoneBroadcastIdListHelper(RMobileBroadcastMessaging& aSess, RMobileBroadcastMessaging::TMobileBroadcastIdType aIdType)

: CRetrieveListHelperBase<CRetrieveMobilePhoneBroadcastIdList, CMobilePhoneBroadcastIdList, RMobileBroadcastMessaging>(aSess), iIdType(aIdType)

	{	

	}

void CRetrieveMobilePhoneBroadcastIdListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneBroadcastIdList::NewL(iSubSess);

	}

void CRetrieveMobilePhoneBroadcastIdListHelper::StartListRetrieval()

	{

	iRetrieve->Start(iStatus,iIdType);

	}

TAny* CRetrieveMobilePhoneBroadcastIdListHelper::GetListL()

	{

	return iRetrieve->RetrieveListL();

	}	

//

//

//Definitions for concrete implementations of CRetrieveListHelper//

//CRetrieveMobilePhoneNamListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneNamList, CMobilePhoneNamList, RMobilePhoneStore>* CRetrieveMobilePhoneNamListHelper::NewL(RMobilePhoneStore& aPhone,TInt aNamId, TListVersion aNamList)

	{

	CRetrieveMobilePhoneNamListHelper* self = new (ELeave) CRetrieveMobilePhoneNamListHelper(aPhone, aNamId, aNamList);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneNamListHelper::CRetrieveMobilePhoneNamListHelper(RMobilePhoneStore& aSess, TInt aNamId,TListVersion aNamList)

: CRetrieveListHelperBase<CRetrieveMobilePhoneNamList, CMobilePhoneNamList, RMobilePhoneStore>(aSess), iNamId(aNamId), iListVersionToRetrieve(aNamList)

	{	

	}

void CRetrieveMobilePhoneNamListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object

	iRetrieve = CRetrieveMobilePhoneNamList::NewL(iSubSess);

	}

void CRetrieveMobilePhoneNamListHelper::StartListRetrieval()

	{

		switch(iListVersionToRetrieve)

			{

			case ERetrieveListV1:

				{

				iRetrieve->Start(iStatus,iNamId);

				break;		

				}

			case ERetrieveListV4:

				{

				iRetrieve->StartV4(iStatus,iNamId);

				break;	

				}

			}

	}

TAny* CRetrieveMobilePhoneNamListHelper::GetListL()

	{

	switch(iListVersionToRetrieve)

		{

			case ERetrieveListV1:

				{

				return iRetrieve->RetrieveListL();

				}

			case ERetrieveListV4:

				{

				return iRetrieve->RetrieveListV4L();

				}

			default:

				{

				_LIT(KErrorLitText,"Wrong argument was entered by user");

				User::Panic(KErrorLitText, KErrArgument); // Attempting to retrieve a non-existant version of the list.

				break;

				}

		}

	return NULL;

	}	

//

//

//Definitions for concrete implementations of CRetrieveListHelper//

//CRetrieveMobilePhoneONListHelper

CRetrieveListHelperBase<CRetrieveMobilePhoneONList, CMobilePhoneONList, RMobilePhoneStore>* CRetrieveMobilePhoneONListHelper::NewL(RMobilePhoneStore& aPhone)

	{

	CRetrieveMobilePhoneONListHelper* self = new (ELeave) CRetrieveMobilePhoneONListHelper(aPhone);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrieveMobilePhoneONListHelper::CRetrieveMobilePhoneONListHelper(RMobilePhoneStore& aSess)

: CRetrieveListHelperBase<CRetrieveMobilePhoneONList, CMobilePhoneONList, RMobilePhoneStore>(aSess)

	{	

	}

void CRetrieveMobilePhoneONListHelper::CreateEtelRetrieverL()

	{

	//create etelmm list retrieval object