// 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:

// Contains the CEtelSessionMgr class definition.

// 

//

/**

 @file 

 @internalTechnology

*/

#include "cetelsessionmgr.h"

#include "cctsytestlogging.h"

/********************************************************************************************

* PLEASE READ WHEN UPDATING SUBSESSION SUPPORT

*

* Subsessions which provide notificaion support, e.g. RMobileLine::NotifyMobileLineStatusChange

* must be tidied up between tests. This means providing a method to consume any outstanding 

* notifications being held on the server for that subsession, and to cancel the internal repost

* mechanism within the Etel server. The steps are

* 1) Write a method along the lines of the methods in cetelnotifycleanup.cpp, e.g. 

*    CleanupMobileLineNotifyMobileLineStatusChange. The naming convention is 

*	 Cleanup<<subsession>><<api>>.

* 2) Add that function to the method which calls all the related methods for that subsession, in

*    the same file, e.g.CleanupMobileLineNotifiers. Add a new method for a new subsession type.

* 3) If a new subsession has been added, then the Cleanup<<subsession>>Notifiers method should be 

*    called from the appropriate place within the cascade of methods starting at TidyPhoneNotifiers

*    - e.g. TidyPhoneNotifiers calls TidyLineNotifiers for every line on the phone, which calls 

*	TidyCallNotifiers for it's dependent call subsessions and then CleanupLineNotifiers and 

*	CleanupMobileLineNotifiers. The naming convention is that TidyXXX forms part of the hierarchy of

*	subsession objects and Cleanup<<subsession>>Notifiers call the individual notification method 

*	cleanups.

**********************************************************************************************/

/**

 * Factory constructor.

*/

CEtelSessionMgr* CEtelSessionMgr::NewL(TName& aTsyName, TName& aPhoneName, TBool aKeepSessOpen)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::NewL aTsyName=%S aPhoneName=%S aKeepSessOpen=%d "), &aTsyName, &aPhoneName, aKeepSessOpen);

	CEtelSessionMgr* self = new(ELeave) CEtelSessionMgr(aTsyName, aPhoneName, aKeepSessOpen);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

 * Constructor.

*/

CEtelSessionMgr::CEtelSessionMgr(TName& aTsyName, TName& aPhoneName, TBool aKeepSessOpen)

: iTsyName(aTsyName), iPhoneName(aPhoneName), iKeepSessOpen(aKeepSessOpen)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::CEtelSessionMgr aTsyName=%S aPhoneName=%S aKeepSessOpen=%d "), &aTsyName, &aPhoneName, aKeepSessOpen);

	iSmsStoreNames[KMeSmsStore] = &KETelMeSmsStore;

	iSmsStoreNames[KIccSmsStore] = &KETelIccSmsStore; 

	iSmsStoreNames[KCombinedSmsStore] = &KETelCombinedSmsStore;

	iPhoneBookStoreNames[KMeAdnPhoneBook].Copy(KETelMeAdnPhoneBook);

	iPhoneBookStoreNames[KMeDialledPhoneBook].Copy(KETelMeDialledPhoneBook);

	iPhoneBookStoreNames[KMeMissedPhoneBook].Copy(KETelMeMissedPhoneBook);

	iPhoneBookStoreNames[KMeReceivedPhoneBook].Copy(KETelMeReceivedPhoneBook);

	iPhoneBookStoreNames[KCombinedAdnPhoneBook].Copy(KETelCombinedAdnPhoneBook);

	iPhoneBookStoreNames[KTaAdnPhoneBook].Copy(KETelTaAdnPhoneBook);

	iPhoneBookStoreNames[KIccAdnPhoneBook].Copy(KETelIccAdnPhoneBook);

	iPhoneBookStoreNames[KIccFdnPhoneBook].Copy(KETelIccFdnPhoneBook);

	iPhoneBookStoreNames[KIccSdnPhoneBook].Copy(KETelIccSdnPhoneBook);

	iPhoneBookStoreNames[KIccBdnPhoneBook].Copy(KETelIccBdnPhoneBook);

	iPhoneBookStoreNames[KIccLndPhoneBook].Copy(KETelIccLndPhoneBook);

	iPhoneBookStoreNames[KIccVoiceMailBox].Copy(KETelIccVoiceMailBox);

	iPhoneBookStoreNames[KIccMbdnPhoneBook].Copy(KETelIccMbdnPhoneBook);

	}

/**

 * Second phase constructor.

*/

void CEtelSessionMgr::ConstructL()

	{

	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::ConstructL"));

	iThreadExec = CThreadExec::NewL();

	}

/**

 * Destructor.

*/

CEtelSessionMgr::~CEtelSessionMgr()

	{

	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::~CEtelSessionMgr"));

	delete iThreadExec;

	}

/**

* Post constructor open

*/

void CEtelSessionMgr::OpenL(TBool aAutoOpenSess)

	{

	TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::OpenL aAutoOpenSess=%d"), aAutoOpenSess);

	if (iIsOpen || !aAutoOpenSess)

		{

		// Close all sessions if :

		// - the Session Mgr was not closed properly

		// - the caller doesn't want any sessions open

		TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::OpenL closing all sessions"));

		CThreadExec::TFunctorP1<CEtelSessionMgr,TBool> fn(this,&CEtelSessionMgr::DoCloseAllSessL,ETrue);

		iThreadExec->Exec(&fn);

		TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::OpenL done closing all sessions"));

		iAutoSessionOpened = EFalse;

		}

	if (aAutoOpenSess && !iAutoSessionOpened)

		{

		TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::OpenL opening all sessions"));

		// Open auto session if requested and if they are not open yet

		CThreadExec::TFunctor<CEtelSessionMgr> fn(this,&CEtelSessionMgr::DoOpenAutoSessL);

		User::LeaveIfError(iThreadExec->Exec(&fn));

		TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::OpenL done opening all sessions"));

		iAutoSessionOpened = ETrue;

		}

	iIsOpen = ETrue;

	}

/** 

* Close the subsession manager

*/

void CEtelSessionMgr::Close()

	{

	TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::Close iAutoSessionOpened=%d iIsOpen=%d"), iAutoSessionOpened, iIsOpen);

	// Close only manually opened sessions if iKeepSessOpen, all session else

	CThreadExec::TFunctorP1<CEtelSessionMgr,TBool> fn(this,&CEtelSessionMgr::DoCloseAllSessL,!iKeepSessOpen);

	TInt err = iThreadExec->Exec(&fn);

	iAutoSessionOpened = iKeepSessOpen;

	iIsOpen = EFalse;

	}

/**

* Force a close on the session manager including auto opened sessions 

* so that the server is unloaded, then re-open

*/

void CEtelSessionMgr::RestartL()

	{

	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::RestartL"));

	TBool savedKeepFlag = iKeepSessOpen;

	iKeepSessOpen = EFalse;

	Close();

	iKeepSessOpen = savedKeepFlag;

	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::RestartL calling OpenL"));

	OpenL(savedKeepFlag);

	TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::RestartL after OpenL"));

	}

/**

* Get a server subsubsession

*/

RTelServer& CEtelSessionMgr::GetServerL(TServerId aServerId)

	{

	TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::GetServerL aServerId=%d"), aServerId);

	if (iTelServersStatus[aServerId] == ESessClosed)

		{

		TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::GetServerL iTelServersStatus[aServerId] == ESessClosed"));

		CThreadExec::TFunctorP1<CEtelSessionMgr, TServerId> fn(this,&CEtelSessionMgr::DoOpenServerL,aServerId);

		TInt err = iThreadExec->Exec(&fn);

		TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::GetServerL err=%d"), err);

		User::LeaveIfError(err);

		iTelServersStatus[aServerId] = ESessOpenManually;

		}

	return iTelServers[aServerId];

	}

/**

* Get a RMobilePhone subsession

*/

RMobilePhone& CEtelSessionMgr::GetPhoneL(TServerId aServerId, TPhoneId aPhoneId)

	{

	TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::GetPhoneL aServerId=%d aPhoneId=%d"), aServerId, aPhoneId);

	if (iTelServersStatus[aServerId] == ESessClosed)

		GetServerL(aServerId); // open parent session if required

	if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)

		{

		CThreadExec::TFunctorP2<CEtelSessionMgr, TServerId, TPhoneId> fn(this,&CEtelSessionMgr::DoOpenPhoneL,aServerId,aPhoneId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iPhonesStatus[aServerId][aPhoneId] = ESessOpenManually;

		}

	return iPhones[aServerId][aPhoneId];

	}

/**

* Get a RMobileLine subsession

*/

RMobileLine& CEtelSessionMgr::GetLineL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetLineL aServerId=%d aPhoneId=%d aLine=%d"), aServerId, aPhoneId, aLineId);

	if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)

		GetPhoneL(aServerId, aPhoneId); // open parent session if require

	if (iLinesStatus[aServerId][aPhoneId][aLineId] == ESessClosed)

		{

		CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TLineId> fn(this,&CEtelSessionMgr::DoOpenLineL,aServerId,aPhoneId,aLineId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iLinesStatus[aServerId][aPhoneId][aLineId] = ESessOpenManually;

		}

	return iLines[aServerId][aPhoneId][aLineId];

	}

/**

* Get a RMobileCall subsession

*/

RMobileCall& CEtelSessionMgr::GetCallL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId)

	{

	TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::GetCallL aServerId=%d aPhoneId=%d aLine=%d aCallId=%d"), aServerId, aPhoneId, aLineId, aCallId);

	if (iLinesStatus[aServerId][aPhoneId][aLineId] == ESessClosed)

		GetLineL(aServerId, aPhoneId, aLineId); // open parent session if require

	if (iCallsStatus[aServerId][aPhoneId][aLineId][aCallId] == ESessClosed)

		{

		CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TLineId, TCallId> fn(this,&CEtelSessionMgr::DoOpenCallL,aServerId,aPhoneId,aLineId,aCallId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iCallsStatus[aServerId][aPhoneId][aLineId][aCallId] = ESessOpenManually;

		}

	return iCalls[aServerId][aPhoneId][aLineId][aCallId];

	}

/**

* Get a RMobileCall subsession that has been assigned to an incoming call represented by name.

*/

RMobileCall& CEtelSessionMgr::GetIncomingCallL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, const TName& aName, TCallId& aCallId)

	{

	TCallId callId = KCall3;

	while(!(callId==KMaxCalls || (iCallsRefs[aLineId][callId].GetCount()==0 && iCallsStatus[aServerId][aPhoneId][aLineId][callId]==ESessClosed)))

		{

		callId = (TCallId)(callId +1);

		}

	if(callId == KMaxCalls)

		{

		User::Leave(KErrInUse);

		}

	if (iLinesStatus[aServerId][aPhoneId][aLineId] == ESessClosed)

		GetLineL(aServerId, aPhoneId, aLineId); // open parent session if required

	CThreadExec::TFunctorP5 <CEtelSessionMgr, TServerId, TPhoneId, TLineId, TCallId, const TName&> fn(this,&CEtelSessionMgr::DoAssignCallToIncomingL,aServerId,aPhoneId,aLineId,callId,aName);

	TInt err = iThreadExec->Exec(&fn);

	User::LeaveIfError(err);

	iCallsStatus[aServerId][aPhoneId][aLineId][callId] = ESessOpenManually;

	aCallId = callId;

	return iCalls[aServerId][aPhoneId][aLineId][callId];

	}

/**

* Get a RFax subsession

*/

RFax& CEtelSessionMgr::GetFaxL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId, TFaxId aFaxId)

	{

	if (iCallsStatus[aServerId][aPhoneId][aLineId][aCallId] == ESessClosed)

		GetCallL(aServerId, aPhoneId, aLineId, aCallId); // open parent session if require

	if (iFaxesStatus[aServerId][aPhoneId][aLineId][aCallId][aFaxId] == ESessClosed)

		{

		CThreadExec::TFunctorP5<CEtelSessionMgr, TServerId, TPhoneId, TLineId, TCallId, TFaxId> 

						fn(this,&CEtelSessionMgr::DoOpenFaxL,aServerId,aPhoneId,aLineId,aCallId,aFaxId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iFaxesStatus[aServerId][aPhoneId][aLineId][aCallId][aFaxId] = ESessOpenManually;

		}

	return iFaxes[aServerId][aPhoneId][aLineId][aCallId][aFaxId];

	}

/**

* Get a RMobileConferenceCall subsession

*/

RMobileConferenceCall& CEtelSessionMgr::GetConferenceCallL(TServerId aServerId, TPhoneId aPhoneId,

														TConferenceCallId aConferenceCallId)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetConferenceCallL aServerId=%d aPhoneId=%d aConferenceCallId=%d"), aServerId, aPhoneId, aConferenceCallId);

	if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)

		GetPhoneL(aServerId, aPhoneId); // open parent session if required

	if (iConferenceCallsStatus[aServerId][aPhoneId][aConferenceCallId] == ESessClosed)

		{

		CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TConferenceCallId>

								fn(this,&CEtelSessionMgr::DoOpenConferenceCallL,aServerId,aPhoneId,aConferenceCallId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iConferenceCallsStatus[aServerId][aPhoneId][aConferenceCallId] = ESessOpenManually;

		}

	return iConferenceCalls[aServerId][aPhoneId][aConferenceCallId];

	}

/**

* Get a RPacketService subsession

*/

RPacketService& CEtelSessionMgr::GetPacketServiceL(TServerId aServerId, TPhoneId aPhoneId,TPacketServiceId aPacketServiceId)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetPacketServiceL aServerId=%d aPhoneId=%d aPacketServiceId=%d"), aServerId, aPhoneId, aPacketServiceId);

	if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)

		GetPhoneL(aServerId, aPhoneId); // open parent session if required

	if (iPacketServicesStatus[aServerId][aPhoneId][aPacketServiceId] == ESessClosed)

		{

		CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId> fn(this,&CEtelSessionMgr::DoOpenPacketServiceL,aServerId,aPhoneId,aPacketServiceId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iPacketServicesStatus[aServerId][aPhoneId][aPacketServiceId] = ESessOpenManually;

		}

	return iPacketServices[aServerId][aPhoneId][aPacketServiceId];

	}

/**

* Get a primary RPacketContext subsession

*/

RPacketContext& CEtelSessionMgr::GetPrimaryPacketContextL(TServerId aServerId, TPhoneId aPhoneId,

												TPacketServiceId aPacketServiceId, 

												TPrimaryPacketContextId aPrimaryPacketContextId)

	{

	TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::GetPrimaryPacketContextL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);

	if (iPacketServicesStatus[aServerId][aPhoneId][aPacketServiceId] == ESessClosed)

		GetPacketServiceL( aServerId, aPhoneId, aPacketServiceId );

	if (iPrimaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] == ESessClosed)

		{

		CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId, TPrimaryPacketContextId>

							fn(this,&CEtelSessionMgr::DoOpenPrimaryPacketContextL,aServerId,aPhoneId,aPacketServiceId,aPrimaryPacketContextId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iPrimaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] = ESessOpenManually;

		}

	return iPrimaryPacketContexts[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId];

	}

/**

* Get a RPacketQoS subsession for a primary packet context

*/

RPacketQoS& CEtelSessionMgr::GetPrimaryPacketContextQoSL(TServerId aServerId, TPhoneId aPhoneId,

												TPacketServiceId aPacketServiceId, 

												TPrimaryPacketContextId aPrimaryPacketContextId)

	{

	TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::GetPrimaryPacketContextQoSL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);	

	if (iPacketServicesStatus[aServerId][aPhoneId][aPacketServiceId] == ESessClosed)

		GetPacketServiceL( aServerId, aPhoneId, aPacketServiceId );

	if (iPrimaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] == ESessClosed)

		{

		CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId, TPrimaryPacketContextId>

							fn(this,&CEtelSessionMgr::DoOpenPrimaryPacketContextQoSL,aServerId,aPhoneId,aPacketServiceId,aPrimaryPacketContextId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iPrimaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] = ESessOpenManually;

		}

	return iPrimaryPacketContextQoSs[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId];

	}

/**

* Get a secondary RPacketContext subsession

*/

RPacketContext& CEtelSessionMgr::GetSecondaryPacketContextL(TServerId aServerId, TPhoneId aPhoneId,

												TPacketServiceId aPacketServiceId, 

												TPrimaryPacketContextId aPrimaryPacketContextId,

												TSecondaryPacketContextId aSecondaryPacketContextId)

	{

	if (iPrimaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] == ESessClosed)

		GetPrimaryPacketContextL( aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId );

	if (iSecondaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId]

											[aPrimaryPacketContextId][aSecondaryPacketContextId] == ESessClosed)

		{

		CThreadExec::TFunctorP5<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId, 

													TPrimaryPacketContextId,TSecondaryPacketContextId>

							fn(this,&CEtelSessionMgr::DoOpenSecondaryPacketContextL,aServerId,aPhoneId,aPacketServiceId,

																aPrimaryPacketContextId,aSecondaryPacketContextId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iSecondaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId]

						[aPrimaryPacketContextId][aSecondaryPacketContextId] = ESessOpenManually;

		}

	return iSecondaryPacketContexts[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId][aSecondaryPacketContextId];

	}

/**

* Get a RPacketQoS subsession for a secondary packet context

*/

RPacketQoS& CEtelSessionMgr::GetSecondaryPacketContextQoSL(TServerId aServerId, TPhoneId aPhoneId,

												TPacketServiceId aPacketServiceId, 

												TPrimaryPacketContextId aPrimaryPacketContextId,

												TSecondaryPacketContextId aSecondaryPacketContextId)

	{

	if (iSecondaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId]

											[aPrimaryPacketContextId][aSecondaryPacketContextId] == ESessClosed)

		GetSecondaryPacketContextL( aServerId, aPhoneId, aPacketServiceId, 

											aPrimaryPacketContextId,aSecondaryPacketContextId );

	if (iSecondaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId]

											[aPrimaryPacketContextId][aSecondaryPacketContextId] == ESessClosed)

		{

		CThreadExec::TFunctorP5<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId, 

													TPrimaryPacketContextId,TSecondaryPacketContextId>

							fn(this,&CEtelSessionMgr::DoOpenSecondaryPacketContextQoSL,aServerId,aPhoneId,aPacketServiceId,

																aPrimaryPacketContextId,aSecondaryPacketContextId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iSecondaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId]

						[aPrimaryPacketContextId][aSecondaryPacketContextId] = ESessOpenManually;

		}

	return iSecondaryPacketContextQoSs[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId][aSecondaryPacketContextId];

	}

/**

* Get a RMobileONStore subsession

*/

RMobileONStore& CEtelSessionMgr::GetONStoreL(TServerId aServerId, TPhoneId aPhoneId,TONStoreId aONStoreId)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetONStoreL aServerId=%d aPhoneId=%d aONStoreId=%d"), aServerId, aPhoneId, aONStoreId);

	if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)

		GetPhoneL(aServerId, aPhoneId); // open parent session if required

	if (iONStoresStatus[aServerId][aPhoneId][aONStoreId] == ESessClosed)

		{

		CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TONStoreId> 

					fn(this,&CEtelSessionMgr::DoOpenONStoreL,aServerId,aPhoneId,aONStoreId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iONStoresStatus[aServerId][aPhoneId][aONStoreId] = ESessOpenManually;

		}

	return iONStores[aServerId][aPhoneId][aONStoreId];

	}

/**

* Get a RMobileENStore subsession

*/

RMobileENStore& CEtelSessionMgr::GetENStoreL(TServerId aServerId, TPhoneId aPhoneId, TENStoreId aENStoreId)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetENStoreL aServerId=%d aPhoneId=%d aENStoreId=%d"), aServerId, aPhoneId, aENStoreId);

	if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)

		GetPhoneL(aServerId, aPhoneId); // open parent session if required

	if (iENStoresStatus[aServerId][aPhoneId][aENStoreId] == ESessClosed)

		{

		CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TENStoreId> 

					fn(this,&CEtelSessionMgr::DoOpenENStoreL,aServerId,aPhoneId,aENStoreId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iENStoresStatus[aServerId][aPhoneId][aENStoreId] = ESessOpenManually;

		}

	return iENStores[aServerId][aPhoneId][aENStoreId];

	}

/**

* Get a RMobilePhoneBookStore subsession

*/

RMobilePhoneBookStore& CEtelSessionMgr::GetPhoneBookStoreL(TServerId aServerId, TPhoneId aPhoneId,TPhoneBookStoreId aPhoneBookStoreId)

	{

	TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetPhoneBookStoreL aServerId=%d aPhoneId=%d aPhoneBookStoreId=%d"), aServerId, aPhoneId, aPhoneBookStoreId);

	if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)

		GetPhoneL(aServerId, aPhoneId); // open parent session if required

	if (iPhoneBookStoresStatus[aServerId][aPhoneId][aPhoneBookStoreId] == ESessClosed)

		{

		CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TPhoneBookStoreId> 

					fn(this,&CEtelSessionMgr::DoOpenPhoneBookStoreL,aServerId,aPhoneId,aPhoneBookStoreId);

		TInt err = iThreadExec->Exec(&fn);

		User::LeaveIfError(err);

		iPhoneBookStoresStatus[aServerId][aPhoneId][aPhoneBookStoreId] = ESessOpenManually;

		}

	return iPhoneBookStores[aServerId][aPhoneId][aPhoneBookStoreId];

	}

/**

* Get a RMobileSmsStore subsession

*/

RMobileSmsStore& CEtelSessionMgr::GetSmsStoreL(TServerId aServerId, TPhoneId aPhoneId,