--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/integration/src/cetelsessionmgr.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1801 @@
+// 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,
+ TSmsMessagingId aSmsMessagingId, TSmsStoreId aSmsStoreId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::GetSmsStoreL aServerId=%d aPhoneId=%d aSmsMessagingId=%d aSmsStoreId=%d"), aServerId, aPhoneId, aSmsMessagingId, aSmsStoreId);
+
+ if (iSmsMessagingsStatus[aServerId][aPhoneId][aSmsMessagingId] == ESessClosed)
+ GetSmsMessagingL(aServerId, aPhoneId,aSmsMessagingId ); // open parent session if required
+
+ if (iSmsStoresStatus[aServerId][aPhoneId][aSmsMessagingId][aSmsStoreId] == ESessClosed)
+ {
+ CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TSmsMessagingId, TSmsStoreId>
+ fn(this,&CEtelSessionMgr::DoOpenSmsStoreL,aServerId,aPhoneId,aSmsMessagingId,aSmsStoreId);
+ TInt err = iThreadExec->Exec(&fn);
+ User::LeaveIfError(err);
+ iSmsStoresStatus[aServerId][aPhoneId][aSmsMessagingId][aSmsStoreId] = ESessOpenManually;
+ }
+
+ return iSmsStores[aServerId][aPhoneId][aSmsMessagingId][aSmsStoreId];
+ }
+
+/**
+* Get a RMobileSmsMessaging subsession
+*/
+RMobileSmsMessaging& CEtelSessionMgr::GetSmsMessagingL(TServerId aServerId, TPhoneId aPhoneId,TSmsMessagingId aSmsMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetSmsStoreL aServerId=%d aPhoneId=%d aSmsMessagingId=%d"), aServerId, aPhoneId, aSmsMessagingId);
+
+ if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)
+ GetPhoneL(aServerId, aPhoneId); // open parent session if required
+
+ if (iSmsMessagingsStatus[aServerId][aPhoneId][aSmsMessagingId] == ESessClosed)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TSmsMessagingId>
+ fn(this,&CEtelSessionMgr::DoOpenSmsMessagingL,aServerId,aPhoneId,aSmsMessagingId);
+ TInt err = iThreadExec->Exec(&fn);
+ User::LeaveIfError(err);
+ iSmsMessagingsStatus[aServerId][aPhoneId][aSmsMessagingId] = ESessOpenManually;
+ }
+
+ return iSmsMessagings[aServerId][aPhoneId][aSmsMessagingId];
+ }
+
+/**
+* Get a RMobileBroadcastMessaging subsession
+*/
+RMobileBroadcastMessaging& CEtelSessionMgr::GetBroadcastMessagingL(TServerId aServerId, TPhoneId aPhoneId,TBroadcastMessagingId aBroadcastMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetBroadcastMessagingL aServerId=%d aPhoneId=%d aBroadcastMessagingId=%d"), aServerId, aPhoneId, aBroadcastMessagingId);
+
+ if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)
+ GetPhoneL(aServerId, aPhoneId); // open parent session if required
+
+ if (iBroadcastMessagingsStatus[aServerId][aPhoneId][aBroadcastMessagingId] == ESessClosed)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TBroadcastMessagingId>
+ fn(this,&CEtelSessionMgr::DoOpenBroadcastMessagingL,aServerId,aPhoneId,aBroadcastMessagingId);
+ TInt err = iThreadExec->Exec(&fn);
+ User::LeaveIfError(err);
+ iBroadcastMessagingsStatus[aServerId][aPhoneId][aBroadcastMessagingId] = ESessOpenManually;
+ }
+
+ return iBroadcastMessagings[aServerId][aPhoneId][aBroadcastMessagingId];
+ }
+
+/**
+* Get a RMobileUssdMessaging subsession
+*/
+RMobileUssdMessaging& CEtelSessionMgr::GetUssdMessagingL(TServerId aServerId, TPhoneId aPhoneId,TUssdMessagingId aUssdMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetUssdMessagingL aServerId=%d aPhoneId=%d aUssdMessagingId=%d"), aServerId, aPhoneId, aUssdMessagingId);
+
+ if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)
+ GetPhoneL(aServerId, aPhoneId); // open parent session if required
+
+ if (iUssdMessagingsStatus[aServerId][aPhoneId][aUssdMessagingId] == ESessClosed)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TUssdMessagingId>
+ fn(this,&CEtelSessionMgr::DoOpenUssdMessagingL,aServerId,aPhoneId,aUssdMessagingId);
+ TInt err = iThreadExec->Exec(&fn);
+ User::LeaveIfError(err);
+ iUssdMessagingsStatus[aServerId][aPhoneId][aUssdMessagingId] = ESessOpenManually;
+ }
+
+ return iUssdMessagings[aServerId][aPhoneId][aUssdMessagingId];
+ }
+
+/**
+* Get a RMmCustomAPI subsession
+*/
+RMmCustomAPI& CEtelSessionMgr::GetCustomApiL(TServerId aServerId, TPhoneId aPhoneId, TCustomApiId aCustomApiId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::GetCustomApiL aServerId=%d aPhoneId=%d aCustomIpcId=%d"), aServerId, aPhoneId, aCustomApiId);
+
+ if (iPhonesStatus[aServerId][aPhoneId] == ESessClosed)
+ GetPhoneL(aServerId, aPhoneId); // open parent session if required
+
+ if (iCustomApisStatus[aServerId][aPhoneId][aCustomApiId] == ESessClosed)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TCustomApiId>
+ fn(this,&CEtelSessionMgr::DoOpenCustomApiL,aServerId,aPhoneId,aCustomApiId);
+ TInt err = iThreadExec->Exec(&fn);
+ User::LeaveIfError(err);
+ iCustomApisStatus[aServerId][aPhoneId][aCustomApiId] = ESessOpenManually;
+ }
+
+ return iCustomApis[aServerId][aPhoneId][aCustomApiId];
+ }
+
+/**
+* Release a server object
+*/
+void CEtelSessionMgr::ReleaseServer(TServerId aServerId)
+ {
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::ReleaseServer aServerId=%d"), aServerId);
+ if (iTelServersStatus[aServerId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP1<CEtelSessionMgr, TServerId> fn(this,&CEtelSessionMgr::DoCloseServerL,aServerId);
+ TInt err = iThreadExec->Exec(&fn);
+ iTelServersStatus[aServerId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a phone object
+*/
+void CEtelSessionMgr::ReleasePhone(TServerId aServerId, TPhoneId aPhoneId)
+ {
+ TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::ReleasePhone aServerId=%d aPhoneId=%d"), aServerId, aPhoneId);
+ if (iPhonesStatus[aServerId][aPhoneId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP2<CEtelSessionMgr, TServerId, TPhoneId> fn(this,&CEtelSessionMgr::DoClosePhoneL,aServerId,aPhoneId);
+ TInt err = iThreadExec->Exec(&fn);
+ iPhonesStatus[aServerId][aPhoneId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a line object
+*/
+void CEtelSessionMgr::ReleaseLine(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseLine aServerId=%d aPhoneId=%d aLineId=%d"), aServerId, aPhoneId, aLineId);
+ if (iLinesStatus[aServerId][aPhoneId][aLineId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TLineId> fn(this,&CEtelSessionMgr::DoCloseLineL,aServerId,aPhoneId,aLineId);
+ TInt err = iThreadExec->Exec(&fn);
+ iLinesStatus[aServerId][aPhoneId][aLineId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a call object
+*/
+void CEtelSessionMgr::ReleaseCall(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::ReleaseCall aServerId=%d aPhoneId=%d aLineId=%d"), aServerId, aPhoneId, aLineId, aCallId);
+ if (iCallsStatus[aServerId][aPhoneId][aLineId][aCallId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TLineId, TCallId> fn(this,&CEtelSessionMgr::DoCloseCallL,aServerId,aPhoneId,aLineId,aCallId);
+ TInt err = iThreadExec->Exec(&fn);
+ iCallsStatus[aServerId][aPhoneId][aLineId][aCallId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a conference call object
+*/
+
+void CEtelSessionMgr::ReleaseConferenceCall( TServerId aServerId, TPhoneId aPhoneId,TConferenceCallId aConferenceCallId )
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseConferenceCall aServerId=%d aPhoneId=%d aConferenceCallId=%d"), aServerId, aPhoneId, aConferenceCallId);
+ if (iConferenceCallsStatus[aServerId][aPhoneId][aConferenceCallId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TConferenceCallId>
+ fn(this,&CEtelSessionMgr::DoCloseConferenceCallL,aServerId,aPhoneId,aConferenceCallId);
+ TInt err = iThreadExec->Exec(&fn);
+ iConferenceCallsStatus[aServerId][aPhoneId][aConferenceCallId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a Fax object
+*/
+void CEtelSessionMgr::ReleaseFaxL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId, TFaxId aFaxId)
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::ReleaseFax aServerId=%d aPhoneId=%d aLineId=%d aCallId=%d aFaxId=%d"), aServerId, aPhoneId, aLineId, aCallId, aFaxId);
+ if (iFaxesStatus[aServerId][aPhoneId][aLineId][aCallId][aFaxId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP5<CEtelSessionMgr, TServerId, TPhoneId, TLineId, TCallId, TFaxId>
+ fn(this,&CEtelSessionMgr::DoCloseFaxL,aServerId,aPhoneId,aLineId,aCallId,aFaxId);
+ TInt err = iThreadExec->Exec(&fn);
+ User::LeaveIfError(err);
+ iFaxesStatus[aServerId][aPhoneId][aLineId][aCallId][aFaxId] = ESessClosed;
+ }
+
+ }
+
+/**
+* Release the a service object
+*/
+void CEtelSessionMgr::ReleasePacketServiceL(TServerId aServerId, TPhoneId aPhoneId, TPacketServiceId aPacketServiceId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleasePacketService aServerId=%d aPhoneId=%d aPacketServiceId=%d"), aServerId, aPhoneId, aPacketServiceId);
+ if (iPacketServicesStatus[aServerId][aPhoneId][aPacketServiceId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId> fn(this,&CEtelSessionMgr::DoClosePacketServiceL,aServerId,aPhoneId,aPacketServiceId);
+ TInt err = iThreadExec->Exec(&fn);
+ iPacketServicesStatus[aServerId][aPhoneId][aPacketServiceId] = ESessClosed;
+ }
+ }
+
+
+/**
+* Release a primary packet context object
+*/
+void CEtelSessionMgr::ReleasePrimaryPacketContext(TServerId aServerId,
+ TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::ReleasePrimaryPacketContext aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);
+ if (iPrimaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId, TPrimaryPacketContextId>
+ fn(this,&CEtelSessionMgr::DoClosePrimaryPacketContextL,aServerId,aPhoneId,aPacketServiceId, aPrimaryPacketContextId);
+ TInt err = iThreadExec->Exec(&fn);
+ iPrimaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] = ESessClosed;
+ }
+ }
+
+/**
+* Release the PacketContextQoS object for a primary packet context
+*/
+void CEtelSessionMgr::ReleasePrimaryPacketContextQoS(TServerId aServerId,
+ TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::ReleasePrimaryPacketContextQoS aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);
+ if (iPrimaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId, TPrimaryPacketContextId>
+ fn(this,&CEtelSessionMgr::DoClosePrimaryPacketContextQoSL,aServerId,aPhoneId,aPacketServiceId, aPrimaryPacketContextId);
+ TInt err = iThreadExec->Exec(&fn);
+ iPrimaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId] = ESessClosed;
+ }
+ }
+
+
+/**
+* Release a secondary packet context object
+*/
+void CEtelSessionMgr::ReleaseSecondaryPacketContext(TServerId aServerId,
+ TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId,
+ TSecondaryPacketContextId aSecondaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::ReleaseSecondaryPacketContext aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d aSecondaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId, aSecondaryPacketContextId);
+ if (iSecondaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP5<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId,
+ TPrimaryPacketContextId,TSecondaryPacketContextId>
+ fn(this,&CEtelSessionMgr::DoCloseSecondaryPacketContextL,aServerId,aPhoneId,aPacketServiceId,
+ aPrimaryPacketContextId,aSecondaryPacketContextId);
+ TInt err = iThreadExec->Exec(&fn);
+ iSecondaryPacketContextsStatus[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId] = ESessClosed;
+ }
+ }
+
+/**
+* Release the PacketContextQoS object for a primary packet context
+*/
+void CEtelSessionMgr::ReleaseSecondaryPacketContextQoS(TServerId aServerId,
+ TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId,
+ TSecondaryPacketContextId aSecondaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::ReleaseSecondaryPacketContextQoS aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d aSecondaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId, aSecondaryPacketContextId);
+ if (iSecondaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP5<CEtelSessionMgr, TServerId, TPhoneId, TPacketServiceId,
+ TPrimaryPacketContextId,TSecondaryPacketContextId>
+ fn(this,&CEtelSessionMgr::DoCloseSecondaryPacketContextQoSL,aServerId,aPhoneId,aPacketServiceId,
+ aPrimaryPacketContextId,aSecondaryPacketContextId);
+ TInt err = iThreadExec->Exec(&fn);
+ iSecondaryPacketContextQoSsStatus[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId] = ESessClosed;
+ }
+ }
+
+
+/**
+* Release an ONStore object
+*/
+void CEtelSessionMgr::ReleaseONStore(TServerId aServerId, TPhoneId aPhoneId, TONStoreId aONStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseONStore aServerId=%d aPhoneId=%d aONStoreId=%d"), aServerId, aPhoneId, aONStoreId);
+ if (iONStoresStatus[aServerId][aPhoneId][aONStoreId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TONStoreId> fn(this,&CEtelSessionMgr::DoCloseONStoreL,aServerId,aPhoneId,aONStoreId);
+ TInt err = iThreadExec->Exec(&fn);
+ iONStoresStatus[aServerId][aPhoneId][aONStoreId] = ESessClosed;
+ }
+ }
+
+/**
+* Release an ENStore object
+*/
+void CEtelSessionMgr::ReleaseENStore(TServerId aServerId, TPhoneId aPhoneId, TENStoreId aENStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseENStore aServerId=%d aPhoneId=%d aENStoreId=%d"), aServerId, aPhoneId, aENStoreId);
+ if (iENStoresStatus[aServerId][aPhoneId][aENStoreId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TENStoreId> fn(this,&CEtelSessionMgr::DoCloseENStoreL,aServerId,aPhoneId,aENStoreId);
+ TInt err = iThreadExec->Exec(&fn);
+ iENStoresStatus[aServerId][aPhoneId][aENStoreId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a PhoneBookStore object
+*/
+void CEtelSessionMgr::ReleasePhoneBookStore(TServerId aServerId, TPhoneId aPhoneId, TPhoneBookStoreId aPhoneBookStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleasePhoneBookStore aServerId=%d aPhoneId=%d aPhoneBookStoreId=%d"), aServerId, aPhoneId, aPhoneBookStoreId);
+ if (iPhoneBookStoresStatus[aServerId][aPhoneId][aPhoneBookStoreId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TPhoneBookStoreId> fn(this,&CEtelSessionMgr::DoClosePhoneBookStoreL,aServerId,aPhoneId,aPhoneBookStoreId);
+ TInt err = iThreadExec->Exec(&fn);
+ iPhoneBookStoresStatus[aServerId][aPhoneId][aPhoneBookStoreId] = ESessClosed;
+ }
+ }
+
+/**
+* Release an SMS Store object
+*/
+void CEtelSessionMgr::ReleaseSmsStore(TServerId aServerId, TPhoneId aPhoneId,
+ TSmsMessagingId aSmsMessagingId, TSmsStoreId aSmsStoreId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::ReleaseSmsStore aServerId=%d aPhoneId=%d aSmsMessagingId=%d aSmsStoreId=%d"), aServerId, aPhoneId, aSmsMessagingId, aSmsStoreId);
+ if (iSmsStoresStatus[aServerId][aPhoneId][aSmsMessagingId][aSmsStoreId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP4<CEtelSessionMgr, TServerId, TPhoneId, TSmsMessagingId, TSmsStoreId>
+ fn(this,&CEtelSessionMgr::DoCloseSmsStoreL,aServerId,aPhoneId,aSmsMessagingId,aSmsStoreId);
+ TInt err = iThreadExec->Exec(&fn);
+ iSmsStoresStatus[aServerId][aPhoneId][aSmsMessagingId][aSmsStoreId] = ESessClosed;
+ }
+ }
+
+/**
+* Release an SMS Messaging object
+*/
+void CEtelSessionMgr::ReleaseSmsMessaging(TServerId aServerId, TPhoneId aPhoneId, TSmsMessagingId aSmsMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseSmsMessaging aServerId=%d aPhoneId=%d aSmsMessagingId=%d"), aServerId, aPhoneId, aSmsMessagingId);
+ if (iSmsMessagingsStatus[aServerId][aPhoneId][aSmsMessagingId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TSmsMessagingId> fn(this,&CEtelSessionMgr::DoCloseSmsMessagingL,aServerId,aPhoneId,aSmsMessagingId);
+ TInt err = iThreadExec->Exec(&fn);
+ iSmsMessagingsStatus[aServerId][aPhoneId][aSmsMessagingId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a broadcast messaging object
+*/
+void CEtelSessionMgr::ReleaseBroadcastMessaging(TServerId aServerId, TPhoneId aPhoneId, TBroadcastMessagingId aBroadcastMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseBroadcastMessaging aServerId=%d aPhoneId=%d aBroadcastMessagingId=%d"), aServerId, aPhoneId, aBroadcastMessagingId);
+ if (iBroadcastMessagingsStatus[aServerId][aPhoneId][aBroadcastMessagingId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TBroadcastMessagingId> fn(this,&CEtelSessionMgr::DoCloseBroadcastMessagingL,aServerId,aPhoneId,aBroadcastMessagingId);
+ TInt err = iThreadExec->Exec(&fn);
+ iBroadcastMessagingsStatus[aServerId][aPhoneId][aBroadcastMessagingId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a UssdMessaging object
+*/
+void CEtelSessionMgr::ReleaseUssdMessaging(TServerId aServerId, TPhoneId aPhoneId, TUssdMessagingId aUssdMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseUssdMessaging aServerId=%d aPhoneId=%d aUssdMessagingId=%d"), aServerId, aPhoneId, aUssdMessagingId);
+ if (iUssdMessagingsStatus[aServerId][aPhoneId][aUssdMessagingId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TUssdMessagingId> fn(this,&CEtelSessionMgr::DoCloseUssdMessagingL,aServerId,aPhoneId,aUssdMessagingId);
+ TInt err = iThreadExec->Exec(&fn);
+ iUssdMessagingsStatus[aServerId][aPhoneId][aUssdMessagingId] = ESessClosed;
+ }
+ }
+
+/**
+* Release a RMmCustomAPI object
+*/
+void CEtelSessionMgr::ReleaseCustomApi(TServerId aServerId, TPhoneId aPhoneId, TCustomApiId aCustomApiId)
+{
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::ReleaseCustomApi aServerId=%d aPhoneId=%d aCustomApiId=%d"), aServerId, aPhoneId, aCustomApiId);
+ if (iCustomApisStatus[aServerId][aPhoneId][aCustomApiId] == ESessOpenManually)
+ {
+ CThreadExec::TFunctorP3<CEtelSessionMgr, TServerId, TPhoneId, TCustomApiId> fn(this,&CEtelSessionMgr::DoCloseCustomApiL,aServerId,aPhoneId,aCustomApiId);
+ TInt err = iThreadExec->Exec(&fn);
+ iCustomApisStatus[aServerId][aPhoneId][aCustomApiId] = ESessClosed;
+ }
+ }
+
+
+//
+// The following DoXXXMethods are called on the test suite server thread not on
+// the test client thread
+//
+
+/**
+* Called when OpenL is called to open the main subsessions
+*/
+void CEtelSessionMgr::DoOpenAutoSessL()
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoOpenAutoSessL"));
+ // only open the main sessions
+ DoOpenServerL(KMainServer);
+ iTelServersStatus[KMainServer] = ESessOpenAutomatically;
+ DoOpenPhoneL(KMainServer,KMainPhone);
+ iPhonesStatus[KMainServer][KMainPhone] = ESessOpenAutomatically;
+ // open all existings lines
+ for (TLineId lineId = KVoiceLine; lineId < KMaxLines; lineId = TLineId(lineId+1))
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoOpenAutoSessL open existing lines"));
+ if (iLinesName[lineId].Length() >0)
+ {
+ DoOpenLineL(KMainServer,KMainPhone,lineId) ;
+ iLinesStatus[KMainServer][KMainPhone][lineId] = ESessOpenAutomatically;
+ }
+ }
+ // open 2 calls on the main voice line (assume there is always a voice line)
+ DoOpenCallL(KMainServer,KMainPhone,KVoiceLine,KCall1);
+ iCallsStatus[KMainServer][KMainPhone][KVoiceLine][KCall1] = ESessOpenAutomatically;
+ DoOpenCallL(KMainServer,KMainPhone,KVoiceLine,KCall2);
+ iCallsStatus[KMainServer][KMainPhone][KVoiceLine][KCall2] = ESessOpenAutomatically;
+ }
+
+/**
+* Close all subsessions post test and prior to re-opening
+*/
+void CEtelSessionMgr::DoCloseAllSessL(TBool aIncludeAutoOpenedSess)
+ {
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::DoCloseAllSessL aIncludeAutoOpenedSess=%d"), aIncludeAutoOpenedSess);
+ // if aIncludeAutoOpenedSess, close sessions with staus ESessOpenAutomatically and ESessOpenManually
+ // else close only sessions with status ESessOpenManually
+
+ // comparison made is if( status >= iStatusCloseThresh)
+ iStatusCloseThresh = aIncludeAutoOpenedSess ? ESessOpenAutomatically : ESessOpenManually;
+
+ // do some cleanup before closing sessions
+ DoCleanup();
+
+ for (TServerId serverId = KMainServer; serverId < KMaxServers; serverId = TServerId(serverId+1))
+ {
+ for (TPhoneId phoneId = KMainPhone; phoneId < KMaxPhones; phoneId = TPhoneId(phoneId+1))
+ {
+ ClosePhoneSessL( serverId, phoneId );
+ }
+
+ // close servers
+ if (iTelServersStatus[serverId] >= iStatusCloseThresh)
+ {
+ DoCloseServerL(serverId);
+ iTelServersStatus[serverId] = ESessClosed;
+ }
+ }
+ }
+
+
+//
+// The following DoXXXMethods are called on the test suite server thread not on
+// the test client thread
+//
+
+
+/**
+* Cleanup all sessions and bring them back to the default configuration
+* ** default configuration to be defined***
+*/
+void CEtelSessionMgr::DoCleanup()
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoCleanup"));
+ CleanupPacketService();
+ CleanupPhoneService();
+ }
+
+/**
+* Cleanup phone service
+*/
+void CEtelSessionMgr::CleanupPhoneService()
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPhoneService"));
+
+ // Phone cleanup
+ RMobilePhone* phone = NULL;
+
+ TServerId serverId = KMainServer;
+ while (serverId < KMaxServers && phone == NULL)
+ {
+ TPhoneId phoneId = KMainPhone;
+ while (phoneId < KMaxPhones && phone == NULL)
+ {
+ if( iPhonesStatus[serverId][phoneId] != ESessClosed )
+ {
+ phone = &iPhones[serverId][phoneId];
+
+ TidyPhoneNotifiers( serverId, phoneId );
+
+ }
+ phoneId = TPhoneId(phoneId+1);
+ }
+ serverId = TServerId(serverId+1);
+ }
+
+ // a phone session is open
+ if (phone)
+ {
+ TRequestStatus reqStatus;
+ // terminate all calls
+ phone->TerminateAllCalls(reqStatus);
+ User::WaitForRequest(reqStatus);
+
+ }
+ }
+
+/**
+* Cleanup packet service
+*/
+void CEtelSessionMgr::CleanupPacketService()
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::CleanupPacketService"));
+
+ RPacketService* packetService = NULL;
+
+ TServerId serverId = KMainServer;
+ while (serverId < KMaxServers && packetService == NULL)
+ {
+ TPhoneId phoneId = KMainPhone;
+ while (phoneId < KMaxPhones && packetService == NULL)
+ {
+ TPacketServiceId packetServiceId = KMainPacketService;
+ while (packetServiceId < KMaxPacketService && packetService == NULL)
+ {
+ if (iPacketServicesStatus[serverId][phoneId][packetServiceId] != ESessClosed)
+ {
+ packetService = &iPacketServices[serverId][phoneId][packetServiceId];
+ }
+ packetServiceId = TPacketServiceId(packetServiceId+1);
+ }
+ phoneId = TPhoneId(phoneId+1);
+ }
+ serverId = TServerId(serverId+1);
+ }
+
+ if (packetService)
+ {
+ RPacketService::TStatus packetServiceStatus;
+ TInt err = packetService->GetStatus(packetServiceStatus);
+ if (packetServiceStatus != RPacketService::EStatusUnattached)
+ {
+ TRequestStatus status;
+ packetService->Detach(status);
+ User::WaitForRequest(status);
+ }
+ }
+ }
+
+
+
+//
+// The following DoOpenXXXMethods are called on the test suite server thread not on
+// the test client thread
+//
+
+/**
+* Open the server subsession
+*/
+void CEtelSessionMgr::DoOpenServerL(TServerId aServerId)
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoOpenServerL"));
+ User::LeaveIfError(iTelServers[aServerId].Connect());
+ CleanupClosePushL(iTelServers[aServerId]);
+ iTelServers[aServerId].ShareAuto();
+ User::LeaveIfError(iTelServers[aServerId].SetExtendedErrorGranularity(RTelServer::EErrorExtended));
+ CleanupStack::Pop(&iTelServers[aServerId]);
+ User::LeaveIfError(iTelServers[aServerId].LoadPhoneModule(iTsyName));
+ }
+
+/**
+* Close the server
+*/
+void CEtelSessionMgr::DoCloseServerL(TServerId aServerId)
+ {
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::DoCloseServerL aServerId=%d"), aServerId);
+ iTelServers[aServerId].UnloadPhoneModule(iTsyName);
+ iTelServers[aServerId].Close();
+ }
+
+/**
+* Open a phone subsession
+*/
+void CEtelSessionMgr::DoOpenPhoneL(TServerId aServerId, TPhoneId aPhoneId)
+ {
+ TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::DoOpenPhoneL aServerId=%d aPhoneId=%d"), aServerId, aPhoneId);
+ TInt err = iPhones[aServerId][aPhoneId].Open(iTelServers[aServerId], iPhoneName);
+ TEST_FRAMEWORK_LOG2(_L("iPhones[][].Open err=%d"), err);
+ User::LeaveIfError(err);
+ if (!iHaveLineNames)
+ DoGetLineNamesL(iPhones[aServerId][aPhoneId]);
+ }
+
+/**
+* Close a phone subsession
+*/
+void CEtelSessionMgr::DoClosePhoneL(TServerId aServerId, TPhoneId aPhoneId)
+ {
+ TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::DoClosePhoneL aServerId=%d aPhoneId=%d"), aServerId, aPhoneId);
+ iPhones[aServerId][aPhoneId].Close();
+ }
+
+/**
+* Open a line subsession
+*/
+void CEtelSessionMgr::DoOpenLineL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId)
+ {
+ TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::DoOpenLineL aServerId=%d aPhoneId=%d"), aServerId, aPhoneId);
+ User::LeaveIfError(iLines[aServerId][aPhoneId][aLineId].Open(iPhones[aServerId][aPhoneId], iLinesName[aLineId]));
+ }
+
+/**
+* Close a line subsession
+*/
+void CEtelSessionMgr::DoCloseLineL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseLineL aServerId=%d aPhoneId=%d aLineId=%d"), aServerId, aPhoneId, aLineId);
+ iLines[aServerId][aPhoneId][aLineId].Close();
+ }
+
+/**
+* Open a call subsession
+*/
+void CEtelSessionMgr::DoOpenCallL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoOpenCallL aServerId=%d aPhoneId=%d aLineId=%d aCallId=%d"), aServerId, aPhoneId, aLineId, aCallId);
+
+ RMobileCall& call = iCalls[aServerId][aPhoneId][aLineId][aCallId];
+ RMobileLine& line = iLines[aServerId][aPhoneId][aLineId];
+ TRefCountItem& refCount = iCallsRefs[aLineId][aCallId];
+
+ TName callName;
+ if( refCount.GetCount() )
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoOpenCallL calling RCall::OpenExistingCall"));
+ callName = refCount.GetName();
+ User::LeaveIfError( call.OpenExistingCall( line, callName) );
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoOpenCallL called RCall::OpenExistingCall"));
+ }
+ else
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoOpenCallL calling RCall::OpenNewCall"));
+ User::LeaveIfError(call.OpenNewCall(line, callName));
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoOpenCallL called RCall::OpenNewCall"));
+ }
+ refCount.AddRef( callName );
+ }
+
+
+/**
+* Assign a RMobilCall to be the incoming call.
+*/
+void CEtelSessionMgr::DoAssignCallToIncomingL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId, const TName& aIncomingCallName)
+ {
+ RMobileCall& call = iCalls[aServerId][aPhoneId][aLineId][aCallId];
+ TRefCountItem& refCount = iCallsRefs[aLineId][aCallId];
+ RMobileLine& line = iLines[aServerId][aPhoneId][aLineId];
+ User::LeaveIfError(call.OpenExistingCall(line, aIncomingCallName));
+
+ // Check callname
+ RCall::TCallInfo callInfo;
+ User::LeaveIfError(call.GetInfo(callInfo));
+ if(callInfo.iCallName != aIncomingCallName)
+ {
+ User::Leave(KErrGeneral);
+ }
+ refCount.AddRef( const_cast<TName&>(aIncomingCallName));
+ }
+
+
+/**
+* Close a call subsession
+*/
+void CEtelSessionMgr::DoCloseCallL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoCloseCallL aServerId=%d aPhoneId=%d aLineId=%d aCallId=%d"), aServerId, aPhoneId, aLineId, aCallId);
+ RMobileCall& call = iCalls[aServerId][aPhoneId][aLineId][aCallId];
+ RCall::TStatus callStatus = RCall::EStatusIdle;
+ call.GetStatus(callStatus); // ignore error
+ if (callStatus != RCall::EStatusIdle)
+ {
+ call.HangUp();
+ }
+ call.Close();
+ TRefCountItem& refCount = iCallsRefs[aLineId][aCallId];
+ refCount.ReleaseL();
+ }
+
+
+/**
+* Open a conference call subsession
+*/
+ void CEtelSessionMgr::DoOpenConferenceCallL(TServerId aServerId, TPhoneId aPhoneId, TConferenceCallId aConferenceCallId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenConferenceCallL aServerId=%d aPhoneId=%d aConferenceCallId=%d"), aServerId, aPhoneId, aConferenceCallId);
+ RMobileConferenceCall& confCall = iConferenceCalls[aServerId][aPhoneId][aConferenceCallId];
+ User::LeaveIfError(iConferenceCalls[aServerId][aPhoneId][aConferenceCallId].Open(iPhones[aServerId][aPhoneId]));
+ }
+
+
+/**
+* Close a conference call subsession
+*/
+ void CEtelSessionMgr::DoCloseConferenceCallL(TServerId aServerId, TPhoneId aPhoneId, TConferenceCallId aConferenceCallId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseConferenceCallL aServerId=%d aPhoneId=%d aConferenceCallId=%d"), aServerId, aPhoneId, aConferenceCallId);
+ iConferenceCalls[aServerId][aPhoneId][aConferenceCallId].Close();
+ }
+
+
+/**
+* Open a RFax subsession
+*/
+void CEtelSessionMgr::DoOpenFaxL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId, TFaxId aFaxId)
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::DoOpenFaxL aServerId=%d aPhoneId=%d aLineId=%d aCallId=%d aFaxId=%d"), aServerId, aPhoneId, aLineId, aCallId, aFaxId);
+ RFax &fax = iFaxes[aServerId][aPhoneId][aLineId][aCallId][aFaxId];
+ User::LeaveIfError(fax.Open(iCalls[aServerId][aPhoneId][aLineId][aCallId]));
+ }
+
+/**
+* Close a RFax subsession
+*/
+void CEtelSessionMgr::DoCloseFaxL(TServerId aServerId, TPhoneId aPhoneId, TLineId aLineId, TCallId aCallId, TFaxId aFaxId)
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::DoCloseFaxL aServerId=%d aPhoneId=%d aLineId=%d aCallId=%d aFaxId=%d"), aServerId, aPhoneId, aLineId, aCallId, aFaxId);
+ iFaxes[aServerId][aPhoneId][aLineId][aCallId][aFaxId].Close();
+ }
+
+
+/**
+* Open a packet service subsession
+*/
+void CEtelSessionMgr::DoOpenPacketServiceL(TServerId aServerId, TPhoneId aPhoneId, TPacketServiceId aPacketServiceId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenPacketServiceL aServerId=%d aPhoneId=%d aPacketServiceId=%d"), aServerId, aPhoneId, aPacketServiceId);
+ RPacketService& packetService = iPacketServices[aServerId][aPhoneId][aPacketServiceId];
+ User::LeaveIfError(packetService.Open(iPhones[aServerId][aPhoneId]));
+ }
+
+/**
+* Close a packet service subsession
+*/
+void CEtelSessionMgr::DoClosePacketServiceL(TServerId aServerId, TPhoneId aPhoneId, TPacketServiceId aPacketServiceId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoClosePacketServiceL aServerId=%d aPhoneId=%d aPacketServiceId=%d"), aServerId, aPhoneId, aPacketServiceId);
+ iPacketServices[aServerId][aPhoneId][aPacketServiceId].Close();
+ }
+
+
+/**
+* Open a primary packet context subsession
+*/
+void CEtelSessionMgr::DoOpenPrimaryPacketContextL(TServerId aServerId,
+ TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoOpenPrimaryPacketContextL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);
+ RPacketService& packetService = iPacketServices[aServerId][aPhoneId][aPacketServiceId];
+ RPacketContext& context = iPrimaryPacketContexts[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId];
+ TRefCountItem& refCount = iPrimaryPacketContextRefs[aPrimaryPacketContextId];
+
+ TName contextName;
+ if( refCount.GetCount() )
+ {
+ contextName = refCount.GetName();
+ User::LeaveIfError( context.OpenExistingContext( packetService, contextName) );
+ }
+ else
+ {
+ User::LeaveIfError( context.OpenNewContext( packetService, contextName) );
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::DoOpenPrimaryPacketContextL context name = %S"), &contextName);
+
+ // Open channel
+ TUint channelNumber;
+ TLex lex(contextName);
+ while (!lex.Eos())
+ {
+ TInt err = lex.Val(channelNumber);
+ TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::DoOpenPrimaryPacketContextL err = %d, channel number = %d"), err, channelNumber);
+ lex.Inc();
+ };
+
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::DoOpenPrimaryPacketContextL channel number = %d"), channelNumber);
+ TRequestStatus status;
+ RPacketContext::TDataChannelV2 dataChannel;
+ TPckg<RPacketContext::TDataChannelV2> dataChannelPckg(dataChannel);
+ context.InitialiseContext(status,dataChannelPckg);
+ User::WaitForRequest(status);
+
+ if (status.Int() != KErrNone)
+ {
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::DoOpenPrimaryPacketContextL Failed to Initialise Context error = %d"), status.Int());
+ User::Leave(status.Int());
+ }
+ }
+ refCount.AddRef( contextName );
+ }
+
+
+/**
+* Close a primary packet context subsession
+*/
+void CEtelSessionMgr::DoClosePrimaryPacketContextL(TServerId aServerId, TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId, TPrimaryPacketContextId aPrimaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoClosePrimaryPacketContextL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);
+ RPacketContext& context = iPrimaryPacketContexts[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId];
+ TRefCountItem& refCount = iPrimaryPacketContextRefs[aPrimaryPacketContextId];
+
+ context.Close();
+ refCount.ReleaseL();
+
+ }
+
+
+/**
+* Open the RPacketQos for a primary packet context
+*/
+void CEtelSessionMgr::DoOpenPrimaryPacketContextQoSL(TServerId aServerId,
+ TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoOpenPrimaryPacketContextQoSL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);
+ RPacketContext& context = iPrimaryPacketContexts[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId];
+ RPacketQoS& qos = iPrimaryPacketContextQoSs[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId];
+ TRefCountItem& refCount = iPrimaryPacketContextQoSRefs[aPrimaryPacketContextId];
+
+ TName serviceName;
+ if( refCount.GetCount() )
+ {
+ serviceName = refCount.GetName();
+ User::LeaveIfError( qos.OpenExistingQoS( context, serviceName) );
+ }
+ else
+ {
+ User::LeaveIfError( qos.OpenNewQoS( context, serviceName) );
+ }
+ refCount.AddRef( serviceName );
+ }
+
+
+/**
+* Close the RPacketQos for a primary packet context
+*/
+void CEtelSessionMgr::DoClosePrimaryPacketContextQoSL(TServerId aServerId, TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId, TPrimaryPacketContextId aPrimaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoClosePrimaryPacketContextQoSL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId);
+ RPacketQoS& qos = iPrimaryPacketContextQoSs[aServerId][aPhoneId][aPacketServiceId][aPrimaryPacketContextId];
+ TRefCountItem& refCount = iPrimaryPacketContextQoSRefs[aPrimaryPacketContextId];
+
+ qos.Close();
+ refCount.ReleaseL();
+ }
+
+/**
+* Open a secondary packet context subsession
+*/
+void CEtelSessionMgr::DoOpenSecondaryPacketContextL(TServerId aServerId, TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId,
+ TSecondaryPacketContextId aSecondaryPacketContextId )
+
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::DoOpenSecondaryPacketContextL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d aSecondaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId, aSecondaryPacketContextId);
+ RPacketService &packetService = iPacketServices[aServerId][aPhoneId][aPacketServiceId];
+ RPacketContext& secContext = iSecondaryPacketContexts[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ TRefCountItem& secRefCount = iSecondaryPacketContextRefs[aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ TName serviceName;
+ if( secRefCount.GetCount() )
+
+ {
+ serviceName = secRefCount.GetName();
+ User::LeaveIfError( secContext.OpenExistingContext( packetService, serviceName) );
+ }
+ else
+ {
+ // Get the related primary context name
+ TRefCountItem& priRefCount = iPrimaryPacketContextRefs[aPrimaryPacketContextId];
+
+ if( !priRefCount.GetCount() )
+ {
+ User::Leave( KErrGeneral );
+ }
+
+ User::LeaveIfError( secContext.OpenNewSecondaryContext( packetService, priRefCount.GetName(), serviceName) );
+
+ // Open channel
+ TUint channelNumber;
+ TLex lex(serviceName);
+ while (!lex.Eos())
+ {
+ TInt err = lex.Val(channelNumber);
+ TEST_FRAMEWORK_LOG3(_L("CEtelSessionMgr::DoOpenSecondaryPacketContextL err = %d, channel number = %d"), err, channelNumber);
+ lex.Inc();
+ };
+
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::DoOpenSecondaryPacketContextL channel number = %d"), channelNumber);
+ TRequestStatus status;
+
+ RPacketContext::TDataChannelV2 dataChannel;
+ TPckg<RPacketContext::TDataChannelV2> dataChannelPckg(dataChannel);
+ secContext.InitialiseContext(status,dataChannelPckg);
+ User::WaitForRequest(status);
+
+ if (status.Int() != KErrNone)
+ {
+ TEST_FRAMEWORK_LOG2(_L("CEtelSessionMgr::DoOpenSecondaryPacketContextL Failed to Initialise Context error = %d"), status.Int());
+ User::Leave(status.Int());
+ }
+
+ }
+
+ secRefCount.AddRef( serviceName );
+ }
+
+
+/**
+* Close a secondary packet context subsession
+*/
+void CEtelSessionMgr::DoCloseSecondaryPacketContextL(TServerId aServerId, TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId,
+ TSecondaryPacketContextId aSecondaryPacketContextId )
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::DoCloseSecondaryPacketContextL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d aSecondaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId, aSecondaryPacketContextId);
+ RPacketContext& secContext = iSecondaryPacketContexts[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ TRefCountItem& secRefCount = iSecondaryPacketContextRefs[aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ secContext.Close();
+ secRefCount.ReleaseL();
+ }
+
+/**
+* Open the RPacketQos for a secondary packet context
+*/
+void CEtelSessionMgr::DoOpenSecondaryPacketContextQoSL(TServerId aServerId,
+ TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId,
+ TSecondaryPacketContextId aSecondaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::DoOpenSecondaryPacketContextQoSL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d aSecondaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId, aSecondaryPacketContextId);
+ RPacketContext& context = iSecondaryPacketContexts[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId];
+ RPacketQoS& qos = iSecondaryPacketContextQoSs[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ TRefCountItem& refCount = iSecondaryPacketContextQoSRefs[aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ TName serviceName;
+ if( refCount.GetCount() )
+ {
+ serviceName = refCount.GetName();
+ User::LeaveIfError( qos.OpenExistingQoS( context, serviceName) );
+ }
+ else
+ {
+ User::LeaveIfError( qos.OpenNewQoS( context, serviceName) );
+ }
+ refCount.AddRef( serviceName );
+ }
+
+
+/**
+* Close the RPacketQos for a secondary packet context
+*/
+void CEtelSessionMgr::DoCloseSecondaryPacketContextQoSL(TServerId aServerId, TPhoneId aPhoneId,
+ TPacketServiceId aPacketServiceId,
+ TPrimaryPacketContextId aPrimaryPacketContextId,
+ TSecondaryPacketContextId aSecondaryPacketContextId)
+ {
+ TEST_FRAMEWORK_LOG6(_L("CEtelSessionMgr::DoCloseSecondaryPacketContextQoSL aServerId=%d aPhoneId=%d aPacketServiceId=%d aPrimaryPacketContextId=%d aSecondaryPacketContextId=%d"), aServerId, aPhoneId, aPacketServiceId, aPrimaryPacketContextId, aSecondaryPacketContextId);
+ RPacketQoS& qos = iSecondaryPacketContextQoSs[aServerId][aPhoneId][aPacketServiceId]
+ [aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ TRefCountItem& refCount = iSecondaryPacketContextQoSRefs[aPrimaryPacketContextId][aSecondaryPacketContextId];
+
+ qos.Close();
+ refCount.ReleaseL();
+ }
+
+/**
+* Open a RMobileONStore subsession
+*/
+void CEtelSessionMgr::DoOpenONStoreL(TServerId aServerId, TPhoneId aPhoneId, TONStoreId aONStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenONStoreL aServerId=%d aPhoneId=%d aONStoreId=%d"), aServerId, aPhoneId, aONStoreId);
+ RMobileONStore& ONStore = iONStores[aServerId][aPhoneId][aONStoreId];
+ User::LeaveIfError(ONStore.Open(iPhones[aServerId][aPhoneId]));
+ }
+
+/**
+* Close a RMobileONStore subsession
+*/
+void CEtelSessionMgr::DoCloseONStoreL(TServerId aServerId, TPhoneId aPhoneId, TONStoreId aONStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseONStoreL aServerId=%d aPhoneId=%d aONStoreId=%d"), aServerId, aPhoneId, aONStoreId);
+ iONStores[aServerId][aPhoneId][aONStoreId].Close();
+ }
+
+/**
+* Open a RMobileENStore subsession
+*/
+void CEtelSessionMgr::DoOpenENStoreL(TServerId aServerId, TPhoneId aPhoneId, TENStoreId aENStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenENStoreL aServerId=%d aPhoneId=%d aENStoreId=%d"), aServerId, aPhoneId, aENStoreId);
+ RMobileENStore& ENStore = iENStores[aServerId][aPhoneId][aENStoreId];
+ User::LeaveIfError(ENStore.Open(iPhones[aServerId][aPhoneId]));
+ }
+
+/**
+* Close a RMobileENStore subsession
+*/
+void CEtelSessionMgr::DoCloseENStoreL(TServerId aServerId, TPhoneId aPhoneId, TENStoreId aENStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseENStoreL aServerId=%d aPhoneId=%d aENStoreId=%d"), aServerId, aPhoneId, aENStoreId);
+ iENStores[aServerId][aPhoneId][aENStoreId].Close();
+ }
+
+/**
+* Open a RMobilePhoneBookStore subsession
+*/
+void CEtelSessionMgr::DoOpenPhoneBookStoreL(TServerId aServerId, TPhoneId aPhoneId, TPhoneBookStoreId aPhoneBookStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenPhoneBookStoreL aServerId=%d aPhoneId=%d aPhoneBookStoreId=%d"), aServerId, aPhoneId, aPhoneBookStoreId);
+ RMobilePhoneBookStore& PhoneBookStore = iPhoneBookStores[aServerId][aPhoneId][aPhoneBookStoreId];
+ User::LeaveIfError(PhoneBookStore.Open(iPhones[aServerId][aPhoneId],iPhoneBookStoreNames[aPhoneBookStoreId]));
+ }
+
+/**
+* Close a RMobilePhoneBookStore subsession
+*/
+void CEtelSessionMgr::DoClosePhoneBookStoreL(TServerId aServerId, TPhoneId aPhoneId, TPhoneBookStoreId aPhoneBookStoreId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoClosePhoneBookStoreL aServerId=%d aPhoneId=%d aPhoneBookStoreId=%d"), aServerId, aPhoneId, aPhoneBookStoreId);
+ iPhoneBookStores[aServerId][aPhoneId][aPhoneBookStoreId].Close();
+ }
+
+/**
+* Open a RMobileSmsStore subsession
+*/
+void CEtelSessionMgr::DoOpenSmsStoreL(TServerId aServerId, TPhoneId aPhoneId,
+ TSmsMessagingId aSmsMessagingId, TSmsStoreId aSmsStoreId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoOpenSmsStoreL aServerId=%d aPhoneId=%d aSmsMessagingId=%d aSmsStoreId=%d"), aServerId, aPhoneId, aSmsMessagingId, aSmsStoreId);
+ RMobileSmsStore& SmsStore = iSmsStores[aServerId][aPhoneId][aSmsMessagingId][aSmsStoreId];
+ User::LeaveIfError(SmsStore.Open(iSmsMessagings[aServerId][aPhoneId][aSmsMessagingId],*iSmsStoreNames[aSmsStoreId]));
+ }
+
+/**
+* Close a RMobileSmsStore subsession
+*/
+void CEtelSessionMgr::DoCloseSmsStoreL(TServerId aServerId, TPhoneId aPhoneId,
+ TSmsMessagingId aSmsMessagingId, TSmsStoreId aSmsStoreId)
+ {
+ TEST_FRAMEWORK_LOG5(_L("CEtelSessionMgr::DoCloseSmsStoreL aServerId=%d aPhoneId=%d aSmsMessagingId=%d aSmsStoreId=%d"), aServerId, aPhoneId, aSmsMessagingId, aSmsStoreId);
+ iSmsStores[aServerId][aPhoneId][aSmsMessagingId][aSmsStoreId].Close();
+ }
+
+/**
+* Open a RMobileSmsMessaging subsession
+*/
+void CEtelSessionMgr::DoOpenSmsMessagingL(TServerId aServerId, TPhoneId aPhoneId, TSmsMessagingId aSmsMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenSmsMessagingL aServerId=%d aPhoneId=%d aSmsMessagingId=%d"), aServerId, aPhoneId, aSmsMessagingId);
+ RMobileSmsMessaging& SmsMessaging = iSmsMessagings[aServerId][aPhoneId][aSmsMessagingId];
+ User::LeaveIfError(SmsMessaging.Open(iPhones[aServerId][aPhoneId]));
+ }
+
+/**
+* Close a RMobileSmsMessaging subsession
+*/
+void CEtelSessionMgr::DoCloseSmsMessagingL(TServerId aServerId, TPhoneId aPhoneId, TSmsMessagingId aSmsMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseSmsMessagingL aServerId=%d aPhoneId=%d aSmsMessagingId=%d"), aServerId, aPhoneId, aSmsMessagingId);
+ iSmsMessagings[aServerId][aPhoneId][aSmsMessagingId].Close();
+ }
+
+/**
+* Open a RMobileBroadcastMessaging subsession
+*/
+void CEtelSessionMgr::DoOpenBroadcastMessagingL(TServerId aServerId, TPhoneId aPhoneId, TBroadcastMessagingId aBroadcastMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenBroadcastMessagingL aServerId=%d aPhoneId=%d aBroadcastMessagingId=%d"), aServerId, aPhoneId, aBroadcastMessagingId);
+ RMobileBroadcastMessaging& BroadcastMessaging = iBroadcastMessagings[aServerId][aPhoneId][aBroadcastMessagingId];
+ User::LeaveIfError(BroadcastMessaging.Open(iPhones[aServerId][aPhoneId]));
+ }
+
+/**
+* Close a RMobileBroadcastMessaging subsession
+*/
+void CEtelSessionMgr::DoCloseBroadcastMessagingL(TServerId aServerId, TPhoneId aPhoneId, TBroadcastMessagingId aBroadcastMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseBroadcastMessagingL aServerId=%d aPhoneId=%d aBroadcastMessagingId=%d"), aServerId, aPhoneId, aBroadcastMessagingId);
+ iBroadcastMessagings[aServerId][aPhoneId][aBroadcastMessagingId].Close();
+ }
+
+/**
+* Open a RMobileUssdMessaging subsession
+*/
+void CEtelSessionMgr::DoOpenUssdMessagingL(TServerId aServerId, TPhoneId aPhoneId, TUssdMessagingId aUssdMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenUssdMessagingL aServerId=%d aPhoneId=%d aUssdMessagingId=%d"), aServerId, aPhoneId, aUssdMessagingId);
+ RMobileUssdMessaging& ussdMessaging = iUssdMessagings[aServerId][aPhoneId][aUssdMessagingId];
+ User::LeaveIfError(ussdMessaging.Open(iPhones[aServerId][aPhoneId]));
+ }
+
+/**
+* Close a RMobileUssdMessaging subsession
+*/
+void CEtelSessionMgr::DoCloseUssdMessagingL(TServerId aServerId, TPhoneId aPhoneId, TUssdMessagingId aUssdMessagingId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseUssdMessagingL aServerId=%d aPhoneId=%d aUssdMessagingId=%d"), aServerId, aPhoneId, aUssdMessagingId);
+ iUssdMessagings[aServerId][aPhoneId][aUssdMessagingId].Close();
+ }
+
+/**
+ * Open a RMmCustomAPI subsession
+ */
+void CEtelSessionMgr::DoOpenCustomApiL(TServerId aServerId, TPhoneId aPhoneId, TCustomApiId aCustomApiId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoOpenCustomApiL aServerId=%d aPhoneId=%d aCustomApiId=%d"), aServerId, aPhoneId, aCustomApiId);
+ RMmCustomAPI& customApi = iCustomApis[aServerId][aPhoneId][aCustomApiId];
+ User::LeaveIfError(customApi.Open(iPhones[aServerId][aPhoneId]));
+ }
+
+/**
+ * Close a RMmCustomAPI subsession
+ */
+void CEtelSessionMgr::DoCloseCustomApiL(TServerId aServerId, TPhoneId aPhoneId, TCustomApiId aCustomApiId)
+ {
+ TEST_FRAMEWORK_LOG4(_L("CEtelSessionMgr::DoCloseCustomApiL aServerId=%d aPhoneId=%d aCustomApiId=%d"), aServerId, aPhoneId, aCustomApiId);
+ iCustomApis[aServerId][aPhoneId][aCustomApiId].Close();
+ }
+
+
+/**
+* Load the line names into our members
+*/
+void CEtelSessionMgr::DoGetLineNamesL(RPhone& aPhone)
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::DoGetLineNamesL"));
+ //get line info for the phone
+ TInt cnt;
+ User::LeaveIfError(aPhone.EnumerateLines(cnt));
+
+ RPhone::TLineInfo info;
+ for(TInt i = 0; i < cnt; i++)
+ {
+ User::LeaveIfError(aPhone.GetLineInfo(i, info));
+ if(info.iLineCapsFlags & RLine::KCapsData)
+ {
+ iLinesName[KDataLine] = info.iName;
+ }
+ else if(info.iLineCapsFlags & RLine::KCapsVoice)
+ {
+ iLinesName[KVoiceLine] = info.iName;
+ }
+ else if(info.iLineCapsFlags & RMobileLine::KCapsAuxVoice)
+ {
+ iLinesName[KAuxLine] = info.iName;
+ }
+ else if(info.iLineCapsFlags & RLine::KCapsFax)
+ {
+ iLinesName[KFaxLine] = info.iName;
+ }
+ }
+ iHaveLineNames = ETrue;
+ }
+
+
+/**
+* TRefCountItem - C'tor
+*/
+CEtelSessionMgr::TRefCountItem::TRefCountItem() : iRefCount(0)
+ {
+
+ }
+
+/**
+* Returns count before add operation, i.e. zero if new
+*/
+TInt CEtelSessionMgr::TRefCountItem::AddRef(TDesC &aName)
+ {
+ if( !iRefCount )
+ {
+ iName = aName;
+ }
+ return iRefCount++;
+ }
+
+/**
+* Returns count after release operation, i.e. zero if now unused
+* Leaves if the count was already 0
+*/
+TInt CEtelSessionMgr::TRefCountItem::ReleaseL()
+ {
+ if( !iRefCount )
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::TRefCountItem::ReleaseL Leaving with KErrNotFound!"));
+ User::Leave(KErrNotFound);
+ }
+ return --iRefCount;
+ }
+
+/**
+* Returns the reference count
+*/
+TInt CEtelSessionMgr::TRefCountItem::GetCount() const
+ {
+ TEST_FRAMEWORK_LOG1(_L("CEtelSessionMgr::TRefCountItem::GetCount iRefCount"));
+ return iRefCount;
+ }
+
+/**
+* Returns a reference to the name associated with the ref count
+*/
+const TName& CEtelSessionMgr::TRefCountItem::GetName() const
+ {
+ return iName;
+ }
+
+void CEtelSessionMgr::AsyncExec(CThreadExec::MFunctor *aFunction)
+/**
+ * Execute a function asynchronously.
+ * @param aFunction the function to execute
+ */
+ {
+ iThreadExec->AsyncExec(aFunction);
+ }
+
+void CEtelSessionMgr::SyncExec(CThreadExec::MFunctor *aFunction)
+/**
+ * Execute a function synchronously from another thread.
+ * @param aFunction the function to execute
+ */
+ {
+ iThreadExec->Exec(aFunction);
+ }
+