Mercurial Mercurial > oss > FCL > sf > os > cellularsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
telephonyserverplugins/simtsy/src/CSimDataCall.cpp
branchRCL_3
changeset 65 630d2f34d719
parent 0 3553901f7fa8
child 66 07a122eea281
equal deleted inserted replaced
61:17af172ffa5f 65:630d2f34d719 
     1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     1 // Copyright (c) 2001-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     2 // All rights reserved.
 
     2 // All rights reserved.
 
     3 // This component and the accompanying materials are made available
 
     3 // This component and the accompanying materials are made available
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     5 // which accompanies this distribution, and is available
 
     5 // which accompanies this distribution, and is available
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    19 
    19 
    20 /**
 
    20 /**
 
    21  @file
 
    21  @file
 
    22 */
 
    22 */
 
    23 
    23 
       
    24 
       
    25 
       
    26 #include "OstTraceDefinitions.h"
 
       
    27 #ifdef OST_TRACE_COMPILER_IN_USE
 
       
    28 #include "CSimDataCallTraces.h"
 
       
    29 #endif
 
       
    30 
    24 #include <testconfigfileparser.h>
 
    31 #include <testconfigfileparser.h>
 
    25 #include "CSimDataCall.h"
 
    32 #include "CSimDataCall.h"
 
    26 #include "CSimPhone.h"
 
    33 #include "CSimPhone.h"
 
    27 #include "Simlog.h"
 
       
    28 
    34 
    29 CSimDataCall* CSimDataCall::NewL(CSimLine* aLine,const TDesC& aName, CSimPhone* aPhone)
 
    35 CSimDataCall* CSimDataCall::NewL(CSimLine* aLine,const TDesC& aName, CSimPhone* aPhone)
 
    30 /**
 
    36 /**
 
    31  * Standard two phase constructor.
 
    37  * Standard two phase constructor.
 
    32  *
 
    38  *
 
    59  * Retrieves all the pausing duration tags from the config file
 
    65  * Retrieves all the pausing duration tags from the config file
 
    60  *
 
    66  *
 
    61  * @param aName name of the data call to be constructed
 
    67  * @param aName name of the data call to be constructed
 
    62  */
 
    68  */
 
    63 	{
 
    69 	{
 
    64 	LOGDATA1("Starting to parse Data Call config parameters...");
 
    70 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_1, "Starting to parse Data Call config parameters...");
 
    65 
    71 
    66 	iDiallingPause=iLine->CfgFile()->ItemValue(KDiallingPauseDuration,KDefaultDiallingPauseDuration);
 
    72 	iDiallingPause=iLine->CfgFile()->ItemValue(KDiallingPauseDuration,KDefaultDiallingPauseDuration);
 
    67 	iConnectingPause=iLine->CfgFile()->ItemValue(KConnectingPauseDuration,KDefaultConnectingPauseDuration);
 
    73 	iConnectingPause=iLine->CfgFile()->ItemValue(KConnectingPauseDuration,KDefaultConnectingPauseDuration);
 
    68 	iDisconnectingPause=iLine->CfgFile()->ItemValue(KDisconnectingPauseDuration,KDefaultDisconnectingPauseDuration);
 
    74 	iDisconnectingPause=iLine->CfgFile()->ItemValue(KDisconnectingPauseDuration,KDefaultDisconnectingPauseDuration);
 
    69 	iAnswerIncomingPause=iLine->CfgFile()->ItemValue(KAnswerIncomingPauseDuration,KDefaultAnswerIncomingPauseDuration);
 
    75 	iAnswerIncomingPause=iLine->CfgFile()->ItemValue(KAnswerIncomingPauseDuration,KDefaultAnswerIncomingPauseDuration);
 
    81 		TUint8 digit = 0;
 
    87 		TUint8 digit = 0;
 
    82 		
    88 		
    83 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,speedCaps);
 
    89 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,speedCaps);
 
    84 		if(ret!=KErrNone)
 
    90 		if(ret!=KErrNone)
 
    85 			{
 
    91 			{
 
    86 			LOGPARSERR("speedCaps",ret,0,&KDataCallCaps);
 
    92 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element SPEEDCAPS returned %d (element no. %d) from tag %s.",ret,0,KDataCallCaps);
 
    87 			}
 
    93 			}
 
    88 		else
 
    94 		else
 
    89 			if(AsciiToNum(speedCaps, digit)==KErrNone)
 
    95 			if(AsciiToNum(speedCaps, digit)==KErrNone)
 
    90 				iMobileCallCaps.iSpeedCaps = digit;
 
    96 				iMobileCallCaps.iSpeedCaps = digit;
 
    91 
    97 
    92 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,protocolCaps);
 
    98 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,protocolCaps);
 
    93 		if(ret!=KErrNone)
 
    99 		if(ret!=KErrNone)
 
    94 			{
 
   100 			{
 
    95 			LOGPARSERR("protocolCaps",ret,1,&KDataCallCaps);
 
   101 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element PROTOCOLCAPS returned %d (element no. %d) from tag %s.",ret,1,KDataCallCaps);
 
    96 			}
 
   102 			}
 
    97 		else
 
   103 		else
 
    98 			if(AsciiToNum(protocolCaps, digit)==KErrNone)
 
   104 			if(AsciiToNum(protocolCaps, digit)==KErrNone)
 
    99 				iMobileCallCaps.iProtocolCaps = digit;
 
   105 				iMobileCallCaps.iProtocolCaps = digit;
 
   100 
   106 
   101 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,serviceCaps);
 
   107 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,serviceCaps);
 
   102 		if(ret!=KErrNone)
 
   108 		if(ret!=KErrNone)
 
   103 			{
 
   109 			{
 
   104 			LOGPARSERR("serviceCaps",ret,2,&KDataCallCaps);
 
   110 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element SERVICECAPS returned %d (element no. %d) from tag %s.",ret,2,KDataCallCaps);
 
   105 			}
 
   111 			}
 
   106 		else
 
   112 		else
 
   107 			if(AsciiToNum(serviceCaps, digit)==KErrNone)
 
   113 			if(AsciiToNum(serviceCaps, digit)==KErrNone)
 
   108 				iMobileCallCaps.iServiceCaps = digit;
 
   114 				iMobileCallCaps.iServiceCaps = digit;
 
   109 
   115 
   110 		
   116 		
   111 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,qosCaps);
 
   117 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,qosCaps);
 
   112 		if(ret!=KErrNone)
 
   118 		if(ret!=KErrNone)
 
   113 			{
 
   119 			{
 
   114 			LOGPARSERR("qosCaps",ret,3,&KDataCallCaps);
 
   120 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element QOSCAPS returned %d (element no. %d) from tag %s.",ret,3,KDataCallCaps);
 
   115 			}
 
   121 			}
 
   116 		else
 
   122 		else
 
   117 			if(AsciiToNum(qosCaps, digit)==KErrNone)
 
   123 			if(AsciiToNum(qosCaps, digit)==KErrNone)
 
   118 				iMobileCallCaps.iQoSCaps = digit;
 
   124 				iMobileCallCaps.iQoSCaps = digit;
 
   119 
   125 
   120 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,hscsdSupport);
 
   126 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,hscsdSupport);
 
   121 		if(ret!=KErrNone)
 
   127 		if(ret!=KErrNone)
 
   122 			{
 
   128 			{
 
   123 			LOGPARSERR("hscsdSupport",ret,4,&KDataCallCaps);
 
   129 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_6, "WARNING - CONFIGURATION FILE PARSING - Reading element HSCSDSUPPORT returned %d (element no. %d) from tag %s.",ret,4,KDataCallCaps);
 
   124 			}
 
   130 			}
 
   125 		else
 
   131 		else
 
   126 			iMobileCallCaps.iHscsdSupport = hscsdSupport;
 
   132 			iMobileCallCaps.iHscsdSupport = hscsdSupport;
 
   127 	
   133 	
   128 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,mClass);
 
   134 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,mClass);
 
   129 		if(ret!=KErrNone)
 
   135 		if(ret!=KErrNone)
 
   130 			{
 
   136 			{
 
   131 			LOGPARSERR("mClass",ret,5,&KDataCallCaps);
 
   137 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_7, "WARNING - CONFIGURATION FILE PARSING - Reading element MCLASS returned %d (element no. %d) from tag %s.",ret,5,KDataCallCaps);
 
   132 			}
 
   138 			}
 
   133 		else
 
   139 		else
 
   134 			iMobileCallCaps.iMClass = mClass;
 
   140 			iMobileCallCaps.iMClass = mClass;
 
   135 
   141 
   136 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,MaxRxTimeslots);
 
   142 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,MaxRxTimeslots);
 
   137 		if(ret!=KErrNone)
 
   143 		if(ret!=KErrNone)
 
   138 			{
 
   144 			{
 
   139 			LOGPARSERR("MaxRxTimeslots",ret,6,&KDataCallCaps);
 
   145 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_8, "WARNING - CONFIGURATION FILE PARSING - Reading element MAXRXTIMESLOTS returned %d (element no. %d) from tag %s.",ret,6,KDataCallCaps);
 
   140 			}
 
   146 			}
 
   141 		else
 
   147 		else
 
   142 			iMobileCallCaps.iMaxRxTimeSlots = MaxRxTimeslots;
 
   148 			iMobileCallCaps.iMaxRxTimeSlots = MaxRxTimeslots;
 
   143 
   149 
   144 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,MaxTxTimeslots);
 
   150 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,MaxTxTimeslots);
 
   145 		if(ret!=KErrNone)
 
   151 		if(ret!=KErrNone)
 
   146 			{
 
   152 			{
 
   147 			LOGPARSERR("MaxTxTimeslots",ret,7,&KDataCallCaps);
 
   153 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_9, "WARNING - CONFIGURATION FILE PARSING - Reading element MAXTXTIMESLOTS returned %d (element no. %d) from tag %s.",ret,7,KDataCallCaps);
 
   148 			}
 
   154 			}
 
   149 		else
 
   155 		else
 
   150 			iMobileCallCaps.iMaxTxTimeSlots = MaxTxTimeslots;
 
   156 			iMobileCallCaps.iMaxTxTimeSlots = MaxTxTimeslots;
 
   151 
   157 
   152 		
   158 		
   153 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,totalRxTxTimeslots);
 
   159 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,totalRxTxTimeslots);
 
   154 		if(ret!=KErrNone)
 
   160 		if(ret!=KErrNone)
 
   155 			{
 
   161 			{
 
   156 			LOGPARSERR("totalRxTxTimeslots",ret,8,&KDataCallCaps);
 
   162 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_10, "WARNING - CONFIGURATION FILE PARSING - Reading element TOTALRXTXTIMESLOTS returned %d (element no. %d) from tag %s.",ret,8,KDataCallCaps);
 
   157 			}
 
   163 			}
 
   158 		else
 
   164 		else
 
   159 			iMobileCallCaps.iTotalRxTxTimeSlots = totalRxTxTimeslots;
 
   165 			iMobileCallCaps.iTotalRxTxTimeSlots = totalRxTxTimeslots;
 
   160 
   166 
   161 		
   167 		
   162 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,codingCaps);
 
   168 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,codingCaps);
 
   163 		if(ret!=KErrNone)
 
   169 		if(ret!=KErrNone)
 
   164 			{
 
   170 			{
 
   165 			LOGPARSERR("codingCaps",ret,9,&KDataCallCaps);
 
   171 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_11, "WARNING - CONFIGURATION FILE PARSING - Reading element CODINGCAPS returned %d (element no. %d) from tag %s.",ret,9,KDataCallCaps);
 
   166 			}
 
   172 			}
 
   167 		else
 
   173 		else
 
   168 			if(AsciiToNum(codingCaps, digit)==KErrNone)
 
   174 			if(AsciiToNum(codingCaps, digit)==KErrNone)
 
   169 				iMobileCallCaps.iCodingCaps = digit;
 
   175 				iMobileCallCaps.iCodingCaps = digit;
 
   170 
   176 
   171 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,asymmetryCaps);
 
   177 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,asymmetryCaps);
 
   172 		if(ret!=KErrNone)
 
   178 		if(ret!=KErrNone)
 
   173 			{
 
   179 			{
 
   174 			LOGPARSERR("asymmetryCaps",ret,10,&KDataCallCaps);
 
   180 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_12, "WARNING - CONFIGURATION FILE PARSING - Reading element ASYMMETRYCAPS returned %d (element no. %d) from tag %s.",ret,10,KDataCallCaps);
 
   175 			}
 
   181 			}
 
   176 		else
 
   182 		else
 
   177 			if(AsciiToNum(asymmetryCaps, digit)==KErrNone)
 
   183 			if(AsciiToNum(asymmetryCaps, digit)==KErrNone)
 
   178 				iMobileCallCaps.iAsymmetryCaps = digit;
 
   184 				iMobileCallCaps.iAsymmetryCaps = digit;
 
   179 
   185 
   180 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,userInitUpgrade);
 
   186 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,userInitUpgrade);
 
   181 		if(ret!=KErrNone)
 
   187 		if(ret!=KErrNone)
 
   182 			{
 
   188 			{
 
   183 			LOGPARSERR("userInitUpgrade",ret,11,&KDataCallCaps);
 
   189 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_13, "WARNING - CONFIGURATION FILE PARSING - Reading element USERINITUPGRADE returned %d (element no. %d) from tag %s.",ret,11,KDataCallCaps);
 
   184 			}
 
   190 			}
 
   185 		else
 
   191 		else
 
   186 			iMobileCallCaps.iUserInitUpgrade = userInitUpgrade;
 
   192 			iMobileCallCaps.iUserInitUpgrade = userInitUpgrade;
 
   187 
   193 
   188 		
   194 		
   189 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,rlpVersionCaps);
 
   195 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,rlpVersionCaps);
 
   190 		if(ret!=KErrNone)
 
   196 		if(ret!=KErrNone)
 
   191 			{
 
   197 			{
 
   192 			LOGPARSERR("rlpVersionCaps",ret,10,&KDataCallCaps);
 
   198 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_14, "WARNING - CONFIGURATION FILE PARSING - Reading element RLPVERSIONCAPS returned %d (element no. %d) from tag %s.",ret,10,KDataCallCaps);
 
   193 			}
 
   199 			}
 
   194 		else
 
   200 		else
 
   195 			if(AsciiToNum(rlpVersionCaps, digit)==KErrNone)
 
   201 			if(AsciiToNum(rlpVersionCaps, digit)==KErrNone)
 
   196 				iMobileCallCaps.iRLPVersionCaps = digit;
 
   202 				iMobileCallCaps.iRLPVersionCaps = digit;
 
   197 
   203 
   198 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,v42bisCaps);
 
   204 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,v42bisCaps);
 
   199 		if(ret!=KErrNone)
 
   205 		if(ret!=KErrNone)
 
   200 			{
 
   206 			{
 
   201 			LOGPARSERR("v42bisCaps",ret,10,&KDataCallCaps);
 
   207 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_15, "WARNING - CONFIGURATION FILE PARSING - Reading element V42BISCAPS returned %d (element no. %d) from tag %s.",ret,10,KDataCallCaps);
 
   202 			}
 
   208 			}
 
   203 		else
 
   209 		else
 
   204 			if(AsciiToNum(v42bisCaps, digit)==KErrNone)
 
   210 			if(AsciiToNum(v42bisCaps, digit)==KErrNone)
 
   205 				iMobileCallCaps.iV42bisCaps  = digit;
 
   211 				iMobileCallCaps.iV42bisCaps  = digit;
 
   206 		}
 
   212 		}
 
   239 			TInt iT1Max,iT1Min,iN2Max,iN2Min,iT4Max,iT4Min;
 
   245 			TInt iT1Max,iT1Min,iN2Max,iN2Min,iT4Max,iT4Min;
 
   240 
   246 
   241 			TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iRlpVersion);
 
   247 			TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iRlpVersion);
 
   242 			if(ret!=KErrNone)
 
   248 			if(ret!=KErrNone)
 
   243 				{
 
   249 				{
 
   244 				LOGPARSERR("iRlpVersion",ret,0,&KDataRLPparams);
 
   250 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_16, "WARNING - CONFIGURATION FILE PARSING - Reading element IRLPVERSION returned %d (element no. %d) from tag %s.",ret,0,KDataRLPparams);
 
   245 				}
 
   251 				}
 
   246 			else
 
   252 			else
 
   247 				iMobileCallRLPItem.iRlpVersion = iRlpVersion;
 
   253 				iMobileCallRLPItem.iRlpVersion = iRlpVersion;
 
   248 			
   254 			
   249 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iIWSMax);
 
   255 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iIWSMax);
 
   250 			if(ret!=KErrNone)
 
   256 			if(ret!=KErrNone)
 
   251 				{
 
   257 				{
 
   252 				LOGPARSERR("iIWSMax",ret,0,&KDataRLPparams);
 
   258 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_17, "WARNING - CONFIGURATION FILE PARSING - Reading element IIWSMAX returned %d (element no. %d) from tag %s.",ret,0,KDataRLPparams);
 
   253 				}
 
   259 				}
 
   254 			else
 
   260 			else
 
   255 				iMobileCallRLPItem.iMobileCallRLP.iIWSMax = iIWSMax;
 
   261 				iMobileCallRLPItem.iMobileCallRLP.iIWSMax = iIWSMax;
 
   256 			
   262 			
   257 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iIWSMin);
 
   263 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iIWSMin);
 
   258 			if(ret!=KErrNone)
 
   264 			if(ret!=KErrNone)
 
   259 				{
 
   265 				{
 
   260 				LOGPARSERR("iIWSMin",ret,1,&KDataRLPparams);
 
   266 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_18, "WARNING - CONFIGURATION FILE PARSING - Reading element IIWSMIN returned %d (element no. %d) from tag %s.",ret,1,KDataRLPparams);
 
   261 				}
 
   267 				}
 
   262 			else
 
   268 			else
 
   263 				iMobileCallRLPItem.iMobileCallRLP.iIWSMin = iIWSMin;
 
   269 				iMobileCallRLPItem.iMobileCallRLP.iIWSMin = iIWSMin;
 
   264 
   270 
   265 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iMWSMax);
 
   271 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iMWSMax);
 
   266 			if(ret!=KErrNone)
 
   272 			if(ret!=KErrNone)
 
   267 				{
 
   273 				{
 
   268 				LOGPARSERR("iMWSMax",ret,2,&KDataRLPparams);
 
   274 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_19, "WARNING - CONFIGURATION FILE PARSING - Reading element IMWSMAX returned %d (element no. %d) from tag %s.",ret,2,KDataRLPparams);
 
   269 				}
 
   275 				}
 
   270 			else
 
   276 			else
 
   271 				iMobileCallRLPItem.iMobileCallRLP.iMWSMax = iMWSMax;
 
   277 				iMobileCallRLPItem.iMobileCallRLP.iMWSMax = iMWSMax;
 
   272 			
   278 			
   273 
   279 
   274 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iMWSMin);
 
   280 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iMWSMin);
 
   275 			if(ret!=KErrNone)
 
   281 			if(ret!=KErrNone)
 
   276 				{
 
   282 				{
 
   277 				LOGPARSERR("iMWSMin",ret,3,&KDataRLPparams);
 
   283 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_20, "WARNING - CONFIGURATION FILE PARSING - Reading element IMWSMIN returned %d (element no. %d) from tag %s.",ret,3,KDataRLPparams);
 
   278 				}
 
   284 				}
 
   279 			else
 
   285 			else
 
   280 				iMobileCallRLPItem.iMobileCallRLP.iMWSMin = iMWSMin;
 
   286 				iMobileCallRLPItem.iMobileCallRLP.iMWSMin = iMWSMin;
 
   281 			
   287 			
   282 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iT1Max);
 
   288 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iT1Max);
 
   283 			if(ret!=KErrNone)
 
   289 			if(ret!=KErrNone)
 
   284 				{
 
   290 				{
 
   285 				LOGPARSERR("iT1Max",ret,4,&KDataRLPparams);
 
   291 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_21, "WARNING - CONFIGURATION FILE PARSING - Reading element IT1MAX returned %d (element no. %d) from tag %s.",ret,4,KDataRLPparams);
 
   286 				}
 
   292 				}
 
   287 			else
 
   293 			else
 
   288 				iMobileCallRLPItem.iMobileCallRLP.iT1Max = iT1Max;
 
   294 				iMobileCallRLPItem.iMobileCallRLP.iT1Max = iT1Max;
 
   289 
   295 
   290 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,iT1Min);
 
   296 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,iT1Min);
 
   291 			if(ret!=KErrNone)
 
   297 			if(ret!=KErrNone)
 
   292 				{
 
   298 				{
 
   293 				LOGPARSERR("iT1Min",ret,5,&KDataRLPparams);
 
   299 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_22, "WARNING - CONFIGURATION FILE PARSING - Reading element IT1MIN returned %d (element no. %d) from tag %s.",ret,5,KDataRLPparams);
 
   294 				}
 
   300 				}
 
   295 			else
 
   301 			else
 
   296 				iMobileCallRLPItem.iMobileCallRLP.iT1Min = iT1Min;
 
   302 				iMobileCallRLPItem.iMobileCallRLP.iT1Min = iT1Min;
 
   297 
   303 
   298 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,iN2Max);
 
   304 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,iN2Max);
 
   299 			if(ret!=KErrNone)
 
   305 			if(ret!=KErrNone)
 
   300 				{
 
   306 				{
 
   301 				LOGPARSERR("iN2Max",ret,6,&KDataRLPparams);
 
   307 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_23, "WARNING - CONFIGURATION FILE PARSING - Reading element IN2MAX returned %d (element no. %d) from tag %s.",ret,6,KDataRLPparams);
 
   302 				}
 
   308 				}
 
   303 			else
 
   309 			else
 
   304 				iMobileCallRLPItem.iMobileCallRLP.iN2Max = iN2Max;
 
   310 				iMobileCallRLPItem.iMobileCallRLP.iN2Max = iN2Max;
 
   305 
   311 
   306 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,iN2Min);
 
   312 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,iN2Min);
 
   307 			if(ret!=KErrNone)
 
   313 			if(ret!=KErrNone)
 
   308 				{
 
   314 				{
 
   309 				LOGPARSERR("iN2Min",ret,7,&KDataRLPparams);
 
   315 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_24, "WARNING - CONFIGURATION FILE PARSING - Reading element IN2MIN returned %d (element no. %d) from tag %s.",ret,7,KDataRLPparams);
 
   310 				}
 
   316 				}
 
   311 			else
 
   317 			else
 
   312 				iMobileCallRLPItem.iMobileCallRLP.iN2Min = iN2Min;
 
   318 				iMobileCallRLPItem.iMobileCallRLP.iN2Min = iN2Min;
 
   313 
   319 
   314 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,iT4Max);
 
   320 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,iT4Max);
 
   315 			if(ret!=KErrNone)
 
   321 			if(ret!=KErrNone)
 
   316 				{
 
   322 				{
 
   317 				LOGPARSERR("iT4Max",ret,8,&KDataRLPparams);
 
   323 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_25, "WARNING - CONFIGURATION FILE PARSING - Reading element IT4MAX returned %d (element no. %d) from tag %s.",ret,8,KDataRLPparams);
 
   318 				}
 
   324 				}
 
   319 			else
 
   325 			else
 
   320 				iMobileCallRLPItem.iMobileCallRLP.iT4Max = iT4Max;
 
   326 				iMobileCallRLPItem.iMobileCallRLP.iT4Max = iT4Max;
 
   321 
   327 
   322 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,iT4Min);
 
   328 			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,iT4Min);
 
   323 			if(ret!=KErrNone)
 
   329 			if(ret!=KErrNone)
 
   324 				{
 
   330 				{
 
   325 				LOGPARSERR("iT4Min",ret,9,&KDataRLPparams);
 
   331 				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_26, "WARNING - CONFIGURATION FILE PARSING - Reading element IT4MIN returned %d (element no. %d) from tag %s.",ret,9,KDataRLPparams);
 
   326 				}
 
   332 				}
 
   327 			else
 
   333 			else
 
   328 				iMobileCallRLPItem.iMobileCallRLP.iT4Min = iT4Min;
 
   334 				iMobileCallRLPItem.iMobileCallRLP.iT4Min = iT4Min;
 
   329 			
   335 			
   330 			iMobileCallRLPList->AppendL(iMobileCallRLPItem);		
   336 			iMobileCallRLPList->AppendL(iMobileCallRLPItem);		
   355 		TUint8 digit=0;
 
   361 		TUint8 digit=0;
 
   356 	
   362 	
   357 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iAiur);
 
   363 		TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iAiur);
 
   358 		if(ret!=KErrNone)
 
   364 		if(ret!=KErrNone)
 
   359 			{
 
   365 			{
 
   360 			LOGPARSERR("iAiur",ret,0,&KDynamicHSCSDInfo);
 
   366 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_27, "WARNING - CONFIGURATION FILE PARSING - Reading element IAIUR returned %d (element no. %d) from tag %s.",ret,0,KDynamicHSCSDInfo);
 
   361 			}
 
   367 			}
 
   362 		else
 
   368 		else
 
   363 			if(AsciiToNum(iAiur, digit)==KErrNone)
 
   369 			if(AsciiToNum(iAiur, digit)==KErrNone)
 
   364 				iHscsdInfo.iAiur = (RMobileCall::TMobileCallAiur) digit;
 
   370 				iHscsdInfo.iAiur = (RMobileCall::TMobileCallAiur) digit;
 
   365 		
   371 		
   366 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iRxTimeSlots);
 
   372 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iRxTimeSlots);
 
   367 		if(ret!=KErrNone)
 
   373 		if(ret!=KErrNone)
 
   368 			{
 
   374 			{
 
   369 			LOGPARSERR("iRxTimeSlots",ret,1,&KDynamicHSCSDInfo);
 
   375 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_28, "WARNING - CONFIGURATION FILE PARSING - Reading element IRXTIMESLOTS returned %d (element no. %d) from tag %s.",ret,1,KDynamicHSCSDInfo);
 
   370 			}
 
   376 			}
 
   371 		else
 
   377 		else
 
   372 			iHscsdInfo.iRxTimeSlots = iRxTimeSlots;
 
   378 			iHscsdInfo.iRxTimeSlots = iRxTimeSlots;
 
   373 		
   379 		
   374 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iTxTimeSlots);
 
   380 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,iTxTimeSlots);
 
   375 		if(ret!=KErrNone)
 
   381 		if(ret!=KErrNone)
 
   376 			{
 
   382 			{
 
   377 			LOGPARSERR("iTxTimeSlots",ret,2,&KDynamicHSCSDInfo);
 
   383 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_29, "WARNING - CONFIGURATION FILE PARSING - Reading element ITXTIMESLOTS returned %d (element no. %d) from tag %s.",ret,2,KDynamicHSCSDInfo);
 
   378 			}
 
   384 			}
 
   379 		else
 
   385 		else
 
   380 			iHscsdInfo.iTxTimeSlots = iTxTimeSlots;
 
   386 			iHscsdInfo.iTxTimeSlots = iTxTimeSlots;
 
   381 
   387 
   382 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iCodings);
 
   388 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iCodings);
 
   383 		if(ret!=KErrNone)
 
   389 		if(ret!=KErrNone)
 
   384 			{
 
   390 			{
 
   385 			LOGPARSERR("iCodings",ret,3,&KDynamicHSCSDInfo);
 
   391 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_30, "WARNING - CONFIGURATION FILE PARSING - Reading element ICODINGS returned %d (element no. %d) from tag %s.",ret,3,KDynamicHSCSDInfo);
 
   386 			}
 
   392 			}
 
   387 		else
 
   393 		else
 
   388 			if(AsciiToNum(iCodings, digit)==KErrNone)
 
   394 			if(AsciiToNum(iCodings, digit)==KErrNone)
 
   389 				iHscsdInfo.iCodings = (RMobileCall::TMobileCallTchCoding) digit;
 
   395 				iHscsdInfo.iCodings = (RMobileCall::TMobileCallTchCoding) digit;
 
   390 	}
 
   396 	}
 
   401 		{
 
   407 		{
 
   402 		TPtrC8 portName,csyName;
 
   408 		TPtrC8 portName,csyName;
 
   403 		TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,csyName);	// The 3rd parameter (0) represents the index of the variable on the config file line
 
   409 		TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,csyName);	// The 3rd parameter (0) represents the index of the variable on the config file line
 
   404 		if (err!=KErrNone)
 
   410 		if (err!=KErrNone)
 
   405 			{
 
   411 			{
 
   406 			LOGPARSERR("csyName",err,0,&KCommSetup);
 
   412 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_31, "WARNING - CONFIGURATION FILE PARSING - Reading element CSYNAME returned %d (element no. %d) from tag %s.",err,0,KCommSetup);
 
   407 			iCsyName.Copy(KDefaultCsyName);
 
   413 			iCsyName.Copy(KDefaultCsyName);
 
   408 			}
 
   414 			}
 
   409 		else
 
   415 		else
 
   410 			iCsyName.Copy(csyName);
 
   416 			iCsyName.Copy(csyName);
 
   411 
   417 
   412 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,portName);		// The 3rd parameter (1) represents the index of the variable on the config file line
 
   418 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,portName);		// The 3rd parameter (1) represents the index of the variable on the config file line
 
   413 		if (err!=KErrNone)
 
   419 		if (err!=KErrNone)
 
   414 			{
 
   420 			{
 
   415 			LOGPARSERR("portName",err,1,&KCommSetup);
 
   421 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_32, "WARNING - CONFIGURATION FILE PARSING - Reading element PORTNAME returned %d (element no. %d) from tag %s.",err,1,KCommSetup);
 
   416 			iPortName.Copy(KDefaultPortName);
 
   422 			iPortName.Copy(KDefaultPortName);
 
   417 			}
 
   423 			}
 
   418 		else
 
   424 		else
 
   419 			iPortName.Copy(portName);
 
   425 			iPortName.Copy(portName);
 
   420 
   426 
   421 		TInt dataRate,handshake;
 
   427 		TInt dataRate,handshake;
 
   422 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dataRate);		// The 3rd parameter (2) represents the index of the variable on the config file line
 
   428 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dataRate);		// The 3rd parameter (2) represents the index of the variable on the config file line
 
   423 		if (err!=KErrNone)
 
   429 		if (err!=KErrNone)
 
   424 			{
 
   430 			{
 
   425 			LOGPARSERR("dataRate",err,2,&KCommSetup);
 
   431 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_33, "WARNING - CONFIGURATION FILE PARSING - Reading element DATARATE returned %d (element no. %d) from tag %s.",err,2,KCommSetup);
 
   426 			iConfig.iRate=KDefaultCommPortRate;
 
   432 			iConfig.iRate=KDefaultCommPortRate;
 
   427 			}
 
   433 			}
 
   428 		else
 
   434 		else
 
   429 			iConfig.iRate=(TBps)dataRate;
 
   435 			iConfig.iRate=(TBps)dataRate;
 
   430 
   436 
   431 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,handshake);		// The 3rd parameter (3) represents the index of the variable on the config file line
 
   437 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,handshake);		// The 3rd parameter (3) represents the index of the variable on the config file line
 
   432 		if (err!=KErrNone)
 
   438 		if (err!=KErrNone)
 
   433 			{
 
   439 			{
 
   434 			LOGPARSERR("handshake",err,3,&KCommSetup);
 
   440 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_34, "WARNING - CONFIGURATION FILE PARSING - Reading element HANDSHAKE returned %d (element no. %d) from tag %s.",err,3,KCommSetup);
 
   435 			iConfig.iHandshake=KDefaultHandshake;
 
   441 			iConfig.iHandshake=KDefaultHandshake;
 
   436 			}
 
   442 			}
 
   437 		else
 
   443 		else
 
   438 			iConfig.iHandshake=(TUint)handshake;
 
   444 			iConfig.iHandshake=(TUint)handshake;
 
   439 		}
 
   445 		}
 
   451 		{
 
   457 		{
 
   452 		TInt bearerCaps,bearerSpeed;
 
   458 		TInt bearerCaps,bearerSpeed;
 
   453 		TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,bearerCaps);	// The 3rd parameter (0) represents the index of the variable on the config file line
 
   459 		TInt err=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,bearerCaps);	// The 3rd parameter (0) represents the index of the variable on the config file line
 
   454 		if (err!=KErrNone)
 
   460 		if (err!=KErrNone)
 
   455 			{
 
   461 			{
 
   456 			LOGPARSERR("bearerCaps",err,0,&KBearerService);
 
   462 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_35, "WARNING - CONFIGURATION FILE PARSING - Reading element BEARERCAPS returned %d (element no. %d) from tag %s.",err,0,KBearerService);
 
   457 			iBearerService.iBearerCaps=KDefaultBearerCaps;
 
   463 			iBearerService.iBearerCaps=KDefaultBearerCaps;
 
   458 			}
 
   464 			}
 
   459 		else
 
   465 		else
 
   460 			iBearerService.iBearerCaps=bearerCaps;
 
   466 			iBearerService.iBearerCaps=bearerCaps;
 
   461 		
   467 		
   462 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,bearerSpeed);		// The 3rd parameter (1) represents the index of the variable on the config file line
 
   468 		err=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,bearerSpeed);		// The 3rd parameter (1) represents the index of the variable on the config file line
 
   463 		if (err!=KErrNone)
 
   469 		if (err!=KErrNone)
 
   464 			{
 
   470 			{
 
   465 			LOGPARSERR("bearerSpeed",err,1,&KBearerService);
 
   471 			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_36, "WARNING - CONFIGURATION FILE PARSING - Reading element BEARERSPEED returned %d (element no. %d) from tag %s.",err,1,KBearerService);
 
   466 			iBearerService.iBearerSpeed=KDefaultBearerSpeed;
 
   472 			iBearerService.iBearerSpeed=KDefaultBearerSpeed;
 
   467 			}
 
   473 			}
 
   468 		else
 
   474 		else
 
   469 			iBearerService.iBearerSpeed=(RCall::TCallBearerSpeed)bearerSpeed;
 
   475 			iBearerService.iBearerSpeed=(RCall::TCallBearerSpeed)bearerSpeed;
 
   470 		
   476 		
   490  	if (item)
 
   496  	if (item)
 
   491  		{
 
   497  		{
 
   492  		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,delay);
 
   498  		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,delay);
 
   493  		if(ret!=KErrNone)
 
   499  		if(ret!=KErrNone)
 
   494  			{
 
   500  			{
 
   495  			LOGPARSERR("delay",ret,0,&KNotifyRemotePartyInfo);
 
   501  			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_37, "WARNING - CONFIGURATION FILE PARSING - Reading element DELAY returned %d (element no. %d) from tag %s.",ret,0,KNotifyRemotePartyInfo);
 
   496  			}
 
   502  			}
 
   497  		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,callingname);
 
   503  		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,callingname);
 
   498  		if(ret!=KErrNone)
 
   504  		if(ret!=KErrNone)
 
   499  			{
 
   505  			{
 
   500  			LOGPARSERR("callingname",ret,1,&KNotifyRemotePartyInfo);
 
   506  			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_38, "WARNING - CONFIGURATION FILE PARSING - Reading element CALLINGNAME returned %d (element no. %d) from tag %s.",ret,1,KNotifyRemotePartyInfo);
 
   501  			}
 
   507  			}
 
   502  		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,remotenumber);
 
   508  		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,remotenumber);
 
   503  		if(ret!=KErrNone)
 
   509  		if(ret!=KErrNone)
 
   504  			{
 
   510  			{
 
   505  			LOGPARSERR("remotenumber",ret,2,&KNotifyRemotePartyInfo);
 
   511  			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_39, "WARNING - CONFIGURATION FILE PARSING - Reading element REMOTENUMBER returned %d (element no. %d) from tag %s.",ret,2,KNotifyRemotePartyInfo);
 
   506  			}
 
   512  			}
 
   507  		
   513  		
   508  		iNotifyRemotePartyInfoTimer->iDelay = delay;
 
   514  		iNotifyRemotePartyInfoTimer->iDelay = delay;
 
   509  		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iDirection = RMobileCall::EDirectionUnknown;
 
   515  		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iDirection = RMobileCall::EDirectionUnknown;
 
   510  		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iCallingName.Copy(callingname);
 
   516  		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iCallingName.Copy(callingname);
 
   516  	else
 
   522  	else
 
   517  		{
 
   523  		{
 
   518  		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown;
 
   524  		iNotifyRemotePartyInfoTimer->iRemotePartyInfoV1.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown;
 
   519  		}
 
   525  		}
 
   520 	
   526 	
   521 	LOGDATA1("...Finished parsing Data Call config parameters...");
 
   527 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CONSTRUCTL_40, "...Finished parsing Data Call config parameters...");
 
   522 	}
 
   528 	}
 
   523 
   529 
   524 CSimDataCall::~CSimDataCall()
 
   530 CSimDataCall::~CSimDataCall()
 
   525 /**
 
   531 /**
 
   526  * Destroy all the objects constructed.
 
   532  * Destroy all the objects constructed.
 
   551  */
 
   557  */
 
   552 	{
 
   558 	{
 
   553 	TAny* dataPtr=aPackage.Ptr1();
 
   559 	TAny* dataPtr=aPackage.Ptr1();
 
   554 	TAny* dataPtr2=aPackage.Ptr2();
 
   560 	TAny* dataPtr2=aPackage.Ptr2();
 
   555 
   561 
   556 	LOGDATA2("CSimDataCall::ExtFunc: IPC Number is %d",aIpc);
 
   562 	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_EXTFUNC_1, "CSimDataCall::ExtFunc: IPC Number is %d",aIpc);
 
   557 	// The request data has to extracted from TDataPackage and the TAny* pointers have to
 
   563 	// The request data has to extracted from TDataPackage and the TAny* pointers have to
 
   558 	// be "cast" to the expected request data type
 
   564 	// be "cast" to the expected request data type
 
   559 
   565 
   560 	switch (aIpc)
 
   566 	switch (aIpc)
 
   561 		{
 
   567 		{
 
   607 	
   613 	
   608 	case EMobileCallNotifyRemotePartyInfoChange:
 
   614 	case EMobileCallNotifyRemotePartyInfoChange:
 
   609  		return NotifyRemotePartyInfoChange(aTsyReqHandle, aPackage.Des1n());
 
   615  		return NotifyRemotePartyInfoChange(aTsyReqHandle, aPackage.Des1n());
 
   610 
   616 
   611 	default:
 
   617 	default:
 
   612 		LOGDATA2("CSimDataCall::ExtFunc: Unsupported IPC detected - number %d",aIpc);
 
   618 		OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_EXTFUNC_2, "CSimDataCall::ExtFunc: Unsupported IPC detected - number %d",aIpc);
 
   613 		break;
 
   619 		break;
 
   614 		}
 
   620 		}
 
   615 
   621 
   616 	return KErrNotSupported;
 
   622 	return KErrNotSupported;
 
   617 	}
 
   623 	}
 
   649 	
   655 	
   650 	case EMobileCallNotifyRemotePartyInfoChange:
 
   656 	case EMobileCallNotifyRemotePartyInfoChange:
 
   651  		return NotifyRemotePartyInfoChangeCancel();
 
   657  		return NotifyRemotePartyInfoChangeCancel();
 
   652 
   658 
   653 	default:
 
   659 	default:
 
   654 		LOGDATA1("CSimDataCall::CancelService: No match for IPC, defering to base function");
 
   660 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_CANCELSERVICE_1, "CSimDataCall::CancelService: No match for IPC, defering to base function");
 
   655 		break;
 
   661 		break;
 
   656 		}
 
   662 		}
 
   657 	return CCallBase::CancelService(aIpc,aTsyReqHandle);
 
   663 	return CCallBase::CancelService(aIpc,aTsyReqHandle);
 
   658 	}
 
   664 	}
 
   659 
   665 
   665  * @param aCallParams  the call parameters
 
   671  * @param aCallParams  the call parameters
 
   666  * @param aTelNumber The telephone number to dial
 
   672  * @param aTelNumber The telephone number to dial
 
   667  * @return KErrNone
 
   673  * @return KErrNone
 
   668  */
 
   674  */
 
   669 	{
 
   675 	{
 
   670 	LOGDATA1(">>CSimDataCall::Dial");
 
   676 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_DIAL_1, ">>CSimDataCall::Dial");
 
   671 	iDialRequestHandle=aTsyReqHandle;
 
   677 	iDialRequestHandle=aTsyReqHandle;
 
   672 	PopulateCallParams(aCallParams);
 
   678 	PopulateCallParams(aCallParams);
 
   673 
   679 
   674 	TInt err=ActionEvent(ECallEventDial,KErrNone);
 
   680 	TInt err=ActionEvent(ECallEventDial,KErrNone);
 
   675 	if(err!=KErrNone)
 
   681 	if(err!=KErrNone)
 
   676 		ReqCompleted(aTsyReqHandle,err);
 
   682 		ReqCompleted(aTsyReqHandle,err);
 
   677 
   683 
   678 	LOGDATA1("<<CSimDataCall::Dial");
 
   684 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_DIAL_2, "<<CSimDataCall::Dial");
 
   679 	return KErrNone;
 
   685 	return KErrNone;
 
   680 	}
 
   686 	}
 
   681 
   687 
   682 TInt CSimDataCall::DialCancel(const TTsyReqHandle /*aTsyReqHandle*/)
 
   688 TInt CSimDataCall::DialCancel(const TTsyReqHandle /*aTsyReqHandle*/)
 
   683 /**
 
   689 /**
 
   685 *
 
   691 *
 
   686 * @param aTsyReqHandle
 
   692 * @param aTsyReqHandle
 
   687 * @return KErrNone if successfully cancelled
 
   693 * @return KErrNone if successfully cancelled
 
   688 */
 
   694 */
 
   689 	{
 
   695 	{
 
   690 	LOGDATA1(">>CSimDataCall::DialCancel");
 
   696 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_DIALCANCEL_1, ">>CSimDataCall::DialCancel");
 
   691 	switch(iState)
 
   697 	switch(iState)
 
   692 		{
 
   698 		{
 
   693 	case RMobileCall::EStatusIdle:
 
   699 	case RMobileCall::EStatusIdle:
 
   694 	case RMobileCall::EStatusConnected:
 
   700 	case RMobileCall::EStatusConnected:
 
   695 		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.
 
   701 		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.
 
   711 			ReqCompleted(iDialRequestHandle, KErrCancel);
 
   717 			ReqCompleted(iDialRequestHandle, KErrCancel);
 
   712 			}
 
   718 			}
 
   713 		break;
 
   719 		break;
 
   714 
   720 
   715 	default:
 
   721 	default:
 
   716 		LOGDATA2("CSimDataCall::DialCancel: No action taken - state: %d",iState);
 
   722 		OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_DIALCANCEL_2, "CSimDataCall::DialCancel: No action taken - state: %d",iState);
 
   717 		break;
 
   723 		break;
 
   718 		}
 
   724 		}
 
   719 	LOGDATA1("<<CSimDataCall::DialCancel");
 
   725 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_DIALCANCEL_3, "<<CSimDataCall::DialCancel");
 
   720 	return KErrNone;
 
   726 	return KErrNone;
 
   721 	}
 
   727 	}
 
   722 
   728 
   723 TInt CSimDataCall::AnswerIncomingCall(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams)
 
   729 TInt CSimDataCall::AnswerIncomingCall(const TTsyReqHandle aTsyReqHandle,const TDesC8* aCallParams)
 
   724 /**
 
   730 /**
 
   729 * @param aTsyReqHandle
 
   735 * @param aTsyReqHandle
 
   730 * @param aCallParams  the call parameters
 
   736 * @param aCallParams  the call parameters
 
   731 * @return KErrNone
 
   737 * @return KErrNone
 
   732 */
 
   738 */
 
   733 	{
 
   739 	{
 
   734 	LOGDATA1(">>CSimDataCall::AnswerIncomingCall");
 
   740 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ANSWERINCOMINGCALL_1, ">>CSimDataCall::AnswerIncomingCall");
 
   735 	TInt err=iLine->SetAutoAnswerCallObject(this);
 
   741 	TInt err=iLine->SetAutoAnswerCallObject(this);
 
   736 	if(err!=KErrNone)
 
   742 	if(err!=KErrNone)
 
   737 		{
 
   743 		{
 
   738 		ReqCompleted(aTsyReqHandle,err);
 
   744 		ReqCompleted(aTsyReqHandle,err);
 
   739 		return KErrNone;
 
   745 		return KErrNone;
 
   752 		if(ret == KErrNone)
 
   758 		if(ret == KErrNone)
 
   753 			{
 
   759 			{
 
   754 			ret = ActionEvent(ECallEventAnswerIncoming,KErrNone);	
   760 			ret = ActionEvent(ECallEventAnswerIncoming,KErrNone);	
   755 			}
 
   761 			}
 
   756 		}
 
   762 		}
 
   757 	LOGDATA1("<<CSimDataCall::AnswerIncomingCall");
 
   763 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ANSWERINCOMINGCALL_2, "<<CSimDataCall::AnswerIncomingCall");
 
   758 	return ret;
 
   764 	return ret;
 
   759 	}
 
   765 	}
 
   760 
   766 
   761 TInt CSimDataCall::AnswerIncomingCallCancel(const TTsyReqHandle /*aTsyReqHandle*/)
 
   767 TInt CSimDataCall::AnswerIncomingCallCancel(const TTsyReqHandle /*aTsyReqHandle*/)
 
   762 /**
 
   768 /**
 
   764 *
 
   770 *
 
   765 * @param aTsyReqHandle
 
   771 * @param aTsyReqHandle
 
   766 * @return KErrNone if successfully cancelled
 
   772 * @return KErrNone if successfully cancelled
 
   767 */
 
   773 */
 
   768 	{
 
   774 	{
 
   769 	LOGDATA1(">>CSimDataCall::AnswerIncomingCallCancel");
 
   775 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ANSWERINCOMINGCALLCANCEL_1, ">>CSimDataCall::AnswerIncomingCallCancel");
 
   770 	if(iAnswerIncomingCall.iNotifyPending)
 
   776 	if(iAnswerIncomingCall.iNotifyPending)
 
   771 		{
 
   777 		{
 
   772 		iAnswerIncomingCall.iNotifyPending=EFalse;
 
   778 		iAnswerIncomingCall.iNotifyPending=EFalse;
 
   773 		iLine->ResetAutoAnswerCallObject(this);
 
   779 		iLine->ResetAutoAnswerCallObject(this);
 
   774 		ReqCompleted(iAnswerIncomingCall.iNotifyHandle,KErrCancel);
 
   780 		ReqCompleted(iAnswerIncomingCall.iNotifyHandle,KErrCancel);
 
   775 		}
 
   781 		}
 
   776 	LOGDATA1("<<CSimDataCall::AnswerIncomingCallCancel");
 
   782 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ANSWERINCOMINGCALLCANCEL_2, "<<CSimDataCall::AnswerIncomingCallCancel");
 
   777 	return KErrNone;
 
   783 	return KErrNone;
 
   778 	}
 
   784 	}
 
   779 
   785 
   780 TInt CSimDataCall::Connect(const TTsyReqHandle aTsyReqHandle,const TDesC8* /*aCallParams*/)
 
   786 TInt CSimDataCall::Connect(const TTsyReqHandle aTsyReqHandle,const TDesC8* /*aCallParams*/)
 
   781 	{
 
   787 	{
 
   795 *
 
   801 *
 
   796 * @param aTsyReqHandle
 
   802 * @param aTsyReqHandle
 
   797 * @return KErrNone
 
   803 * @return KErrNone
 
   798 */
 
   804 */
 
   799 	{
 
   805 	{
 
   800 	LOGDATA1(">>CSimDataCall::HangUp");
 
   806 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_HANGUP_1, ">>CSimDataCall::HangUp");
 
   801 	iHangUpRequestHandle=aTsyReqHandle;
 
   807 	iHangUpRequestHandle=aTsyReqHandle;
 
   802 	TInt err=ActionEvent(ECallEventHangUp,KErrNone);
 
   808 	TInt err=ActionEvent(ECallEventHangUp,KErrNone);
 
   803 	if(err!=KErrNone)
 
   809 	if(err!=KErrNone)
 
   804 		ReqCompleted(aTsyReqHandle,err);
 
   810 		ReqCompleted(aTsyReqHandle,err);
 
   805 	LOGDATA1("<<CSimDataCall::HangUp");
 
   811 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_HANGUP_2, "<<CSimDataCall::HangUp");
 
   806 	return KErrNone;
 
   812 	return KErrNone;
 
   807 	}
 
   813 	}
 
   808 
   814 
   809 TInt CSimDataCall::HangUpCancel(const TTsyReqHandle /*aTsyReqHandle*/)
 
   815 TInt CSimDataCall::HangUpCancel(const TTsyReqHandle /*aTsyReqHandle*/)
 
   810 /**
 
   816 /**
 
   812 *
 
   818 *
 
   813 * @param aTsyReqHandle
 
   819 * @param aTsyReqHandle
 
   814 * @return KErrNone if successfully cancelled
 
   820 * @return KErrNone if successfully cancelled
 
   815 */
 
   821 */
 
   816 	{
 
   822 	{
 
   817 	LOGDATA1(">>CSimDataCall::HangUpCancel");
 
   823 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_HANGUPCANCEL_1, ">>CSimDataCall::HangUpCancel");
 
   818 	switch(iState)
 
   824 	switch(iState)
 
   819 		{
 
   825 		{
 
   820 	case RMobileCall::EStatusIdle:
 
   826 	case RMobileCall::EStatusIdle:
 
   821 		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.
 
   827 		SimPanic(EIllegalCancelRequest);		// A DialCancel should never reach the TSY in this state.
 
   822 		break;
 
   828 		break;
 
   836 			ReqCompleted(iHangUpRequestHandle, KErrCancel);
 
   842 			ReqCompleted(iHangUpRequestHandle, KErrCancel);
 
   837 			}
 
   843 			}
 
   838 		break;
 
   844 		break;
 
   839 
   845 
   840 	default:
 
   846 	default:
 
   841 		LOGDATA2("CSimDataCall::HangUpCancel: No action taken - state: %d",iState);
 
   847 		OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_HANGUPCANCEL_2, "CSimDataCall::HangUpCancel: No action taken - state: %d",iState);
 
   842 		break;
 
   848 		break;
 
   843 		}
 
   849 		}
 
   844 	LOGDATA1("<<CSimDataCall::HangUpCancel");
 
   850 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_HANGUPCANCEL_3, "<<CSimDataCall::HangUpCancel");
 
   845 	return KErrNone;
 
   851 	return KErrNone;
 
   846 	}
 
   852 	}
 
   847 
   853 
   848 TInt CSimDataCall::RelinquishOwnership()
 
   854 TInt CSimDataCall::RelinquishOwnership()
 
   849 	{
 
   855 	{
 
   999 	__ASSERT_ALWAYS(iState!=RMobileCall::EStatusUnknown,SimPanic(ECallStatusUnknownIllegal));
 
  1005 	__ASSERT_ALWAYS(iState!=RMobileCall::EStatusUnknown,SimPanic(ECallStatusUnknownIllegal));
 
  1000 
  1006 
  1001 	switch(aEvent)
 
  1007 	switch(aEvent)
 
  1002 		{
 
  1008 		{
 
  1003 	case ECallEventDial:
 
  1009 	case ECallEventDial:
 
  1004 		LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventDial]");
 
  1010 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_1, ">>CSimDataCall::ActionEvent = [ECallEventDial]");
 
  1005 		if(iState==RMobileCall::EStatusIdle)
 
  1011 		if(iState==RMobileCall::EStatusIdle)
 
  1006 			{
 
  1012 			{
 
  1007 			TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusDialling,EFalse,EFalse));
 
  1013 			TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusDialling,EFalse,EFalse));
 
  1008 			if(ret==KErrNone)
 
  1014 			if(ret==KErrNone)
 
  1009 				iTimer->Start(iDiallingPause,this);
 
  1015 				iTimer->Start(iDiallingPause,this);
 
  1012 			return KErrEtelCallAlreadyActive;
 
  1018 			return KErrEtelCallAlreadyActive;
 
  1013 		break;
 
  1019 		break;
 
  1014 
  1020 
  1015 	case ECallEventHangUp:
 
  1021 	case ECallEventHangUp:
 
  1016 		{
 
  1022 		{
 
  1017 		LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventHangUp]");
 
  1023 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_2, ">>CSimDataCall::ActionEvent = [ECallEventHangUp]");
 
  1018 		switch(iState)
 
  1024 		switch(iState)
 
  1019 			{
 
  1025 			{
 
  1020 		case RMobileCall::EStatusConnected:
 
  1026 		case RMobileCall::EStatusConnected:
 
  1021 			iCommPortLoaned=EFalse;
 
  1027 			iCommPortLoaned=EFalse;
 
  1022 			iNtRas->Terminate();
 
  1028 			iNtRas->Terminate();
 
  1035 			}
 
  1041 			}
 
  1036 		}
 
  1042 		}
 
  1037 		break;
 
  1043 		break;
 
  1038 
  1044 
  1039 	case ECallEventIncomingCall:
 
  1045 	case ECallEventIncomingCall:
 
  1040 		LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventIncomingCall]");
 
  1046 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_3, ">>CSimDataCall::ActionEvent = [ECallEventIncomingCall]");
 
  1041 		if(iState==RMobileCall::EStatusIdle)
 
  1047 		if(iState==RMobileCall::EStatusIdle)
 
  1042 			{
 
  1048 			{
 
  1043 			if(iAnswerIncomingCall.iNotifyPending)
 
  1049 			if(iAnswerIncomingCall.iNotifyPending)
 
  1044 				{
 
  1050 				{
 
  1045 				TRAP(ret,	ret=ProcessAnswerIncomingCallL());
 
  1051 				TRAP(ret,	ret=ProcessAnswerIncomingCallL());
 
  1054 		else
 
  1060 		else
 
  1055 			return KErrEtelCallAlreadyActive;
 
  1061 			return KErrEtelCallAlreadyActive;
 
  1056 		break;
 
  1062 		break;
 
  1057 
  1063 
  1058 	case ECallEventAnswerIncoming:
 
  1064 	case ECallEventAnswerIncoming:
 
  1059 		LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventAnswerIncoming]");
 
  1065 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_4, ">>CSimDataCall::ActionEvent = [ECallEventAnswerIncoming]");
 
  1060 		if(iState==RMobileCall::EStatusRinging)
 
  1066 		if(iState==RMobileCall::EStatusRinging)
 
  1061 			{
 
  1067 			{
 
  1062 			TRAP(ret, ret=ProcessAnswerIncomingCallL());
 
  1068 			TRAP(ret, ret=ProcessAnswerIncomingCallL());
 
  1063 			}
 
  1069 			}
 
  1064 		else
 
  1070 		else
 
  1065 			SimPanic(EIllegalStateInconsistancy);		// The state is checked in AnswerIncomingCall, so there's been an inconsistancy if the state is out of line.
 
  1071 			SimPanic(EIllegalStateInconsistancy);		// The state is checked in AnswerIncomingCall, so there's been an inconsistancy if the state is out of line.
 
  1066 		break;
 
  1072 		break;
 
  1067 
  1073 
  1068 	case ECallEventRemoteHangup:
 
  1074 	case ECallEventRemoteHangup:
 
  1069 		LOGDATA1(">>CSimDataCall::ActionEvent = [ECallEventRemoteHangup]");
 
  1075 		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_5, ">>CSimDataCall::ActionEvent = [ECallEventRemoteHangup]");
 
  1070 		if(iState==RMobileCall::EStatusConnected)
 
  1076 		if(iState==RMobileCall::EStatusConnected)
 
  1071 			{
 
  1077 			{
 
  1072 			TRAP(ret, ret=ProcessRemoteHangupL());
 
  1078 			TRAP(ret, ret=ProcessRemoteHangupL());
 
  1073 			}
 
  1079 			}
 
  1074 		else
 
  1080 		else
 
  1075 			SimPanic(EIllegalStateInconsistancy);		// The state is checked in RemoteHangup, so there's been an inconsistancy if the state is out of line.
 
  1081 			SimPanic(EIllegalStateInconsistancy);		// The state is checked in RemoteHangup, so there's been an inconsistancy if the state is out of line.
 
  1076 		break;
 
  1082 		break;
 
  1077 
  1083 
  1078 	case ECallEventTimeOut:
 
  1084 	case ECallEventTimeOut:
 
  1079 			{
 
  1085 			{
 
  1080 			LOGDATA1(">>CSimVoiceCall::ActionEvent = [ECallEventTimeOut]");
 
  1086 			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_6, ">>CSimVoiceCall::ActionEvent = [ECallEventTimeOut]");
 
  1081 			switch(iState)
 
  1087 			switch(iState)
 
  1082 				{
 
  1088 				{
 
  1083 			case RMobileCall::EStatusDialling:
 
  1089 			case RMobileCall::EStatusDialling:
 
  1084 				LOGDATA1(">>CSimDataCall::State = [EStatusDialling]");
 
  1090 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_7, ">>CSimDataCall::State = [EStatusDialling]");
 
  1085 				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnecting,EFalse,EFalse));
 
  1091 				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnecting,EFalse,EFalse));
 
  1086 				if(ret==KErrNone)
 
  1092 				if(ret==KErrNone)
 
  1087 					iTimer->Start(iConnectingPause,this);
 
  1093 					iTimer->Start(iConnectingPause,this);
 
  1088 				return ret;
 
  1094 				return ret;
 
  1089 
  1095 
  1090 			case RMobileCall::EStatusConnecting:
 
  1096 			case RMobileCall::EStatusConnecting:
 
  1091 				LOGDATA1(">>CSimDataCall::State = [EStatusConnecting]");
 
  1097 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_8, ">>CSimDataCall::State = [EStatusConnecting]");
 
  1092 // If the config file has not spec'ed a CSY, then fail the dial...
 
  1098 // If the config file has not spec'ed a CSY, then fail the dial...
 
  1093 				if(iCsyName.Length()==0)
 
  1099 				if(iCsyName.Length()==0)
 
  1094 					{
 
  1100 					{
 
  1095 					ReqCompleted(iDialRequestHandle,KErrEtelNoCarrier);
 
  1101 					ReqCompleted(iDialRequestHandle,KErrEtelNoCarrier);
 
  1096 					TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse));
 
  1102 					TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse));
 
  1102 				if(ret!=KErrNone)
 
  1108 				if(ret!=KErrNone)
 
  1103 					ReqCompleted(iDialRequestHandle,ret);
 
  1109 					ReqCompleted(iDialRequestHandle,ret);
 
  1104 				return ret;
 
  1110 				return ret;
 
  1105 
  1111 
  1106 			case RMobileCall::EStatusDisconnecting:
 
  1112 			case RMobileCall::EStatusDisconnecting:
 
  1107 				LOGDATA1(">>CSimDataCall::State = [EStatusDisconnecting]");
 
  1113 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_9, ">>CSimDataCall::State = [EStatusDisconnecting]");
 
  1108 				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse));
 
  1114 				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusIdle,EFalse,EFalse));
 
  1109 				ReqCompleted(iHangUpRequestHandle,ret);
 
  1115 				ReqCompleted(iHangUpRequestHandle,ret);
 
  1110 				return ret;
 
  1116 				return ret;
 
  1111 
  1117 
  1112 			case RMobileCall::EStatusAnswering:
 
  1118 			case RMobileCall::EStatusAnswering:
 
  1113 				LOGDATA1(">>CSimDataCall::State = [EStatusAnswering]");
 
  1119 				OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_10, ">>CSimDataCall::State = [EStatusAnswering]");
 
  1114 				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnected,EFalse,EFalse));
 
  1120 				TRAP(ret, ret=ChangeStateL(RMobileCall::EStatusConnected,EFalse,EFalse));
 
  1115 				ReqCompleted(iAnswerIncomingCall.iNotifyHandle,ret);
 
  1121 				ReqCompleted(iAnswerIncomingCall.iNotifyHandle,ret);
 
  1116 				return ret;
 
  1122 				return ret;
 
  1117 
  1123 
  1118 			default:
 
  1124 			default:
 
  1119 				LOGDATA2(">>CSimDataCall::State = [%d]",iState);
 
  1125 				OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_ACTIONEVENT_11, ">>CSimDataCall::State = [%d]",iState);
 
  1120 				break;
 
  1126 				break;
 
  1121 				}
 
  1127 				}
 
  1122 			}
 
  1128 			}
 
  1123 		break;
 
  1129 		break;
 
  1124 
  1130 
  1150 /**
 
  1156 /**
 
  1151 * Timer callback function.  When the timer goes off, it will call back into this
 
  1157 * Timer callback function.  When the timer goes off, it will call back into this
 
  1152 * function for further processing.
 
  1158 * function for further processing.
 
  1153 */
 
  1159 */
 
  1154 	{
 
  1160 	{
 
  1155 	LOGDATA1(">>CSimDataCall::TimerCallBack");
 
  1161 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_TIMERCALLBACK_1, ">>CSimDataCall::TimerCallBack");
 
  1156 	TInt err=ActionEvent(ECallEventTimeOut,KErrNone);
 
  1162 	TInt err=ActionEvent(ECallEventTimeOut,KErrNone);
 
  1157 	__ASSERT_ALWAYS(err==KErrNone,SimPanic(ETimeOutEventActionFailed));
 
  1163 	__ASSERT_ALWAYS(err==KErrNone,SimPanic(ETimeOutEventActionFailed));
 
  1158 	LOGDATA1("<<CSimDataCall::TimerCallBack");
 
  1164 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_TIMERCALLBACK_2, "<<CSimDataCall::TimerCallBack");
 
  1159 	}
 
  1165 	}
 
  1160 
  1166 
  1161 TInt CSimDataCall::ProcessAnswerIncomingCallL()
 
  1167 TInt CSimDataCall::ProcessAnswerIncomingCallL()
 
  1162 /**
 
  1168 /**
 
  1163 * Answers an Incoming Call.
 
  1169 * Answers an Incoming Call.
 
  1164 * First the call state must be changed to "answering", then the flag indicating
 
  1170 * First the call state must be changed to "answering", then the flag indicating
 
  1165 * that an answer incoming call request is no longer pending.  Finally, a new
 
  1171 * that an answer incoming call request is no longer pending.  Finally, a new
 
  1166 * call object must be assigned to receive the details of the next incoming call.
 
  1172 * call object must be assigned to receive the details of the next incoming call.
 
  1167 */
 
  1173 */
 
  1168 	{
 
  1174 	{
 
  1169 	LOGDATA1(">>CSimDataCall::ProcessAnswerIncomingCall");
 
  1175 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_PROCESSANSWERINCOMINGCALLL_1, ">>CSimDataCall::ProcessAnswerIncomingCall");
 
  1170 	TInt ret=ChangeStateL(RMobileCall::EStatusAnswering,EFalse,EFalse);
 
  1176 	TInt ret=ChangeStateL(RMobileCall::EStatusAnswering,EFalse,EFalse);
 
  1171 	if(ret!=KErrNone)
 
  1177 	if(ret!=KErrNone)
 
  1172 		return ret;
 
  1178 		return ret;
 
  1173 	iTimer->Start(iAnswerIncomingPause,this);
 
  1179 	iTimer->Start(iAnswerIncomingPause,this);
 
  1174 	iAnswerIncomingCall.iNotifyPending=EFalse;
 
  1180 	iAnswerIncomingCall.iNotifyPending=EFalse;
 
  1175 	iLine->ResetAutoAnswerCallObject(this);
 
  1181 	iLine->ResetAutoAnswerCallObject(this);
 
  1176 	LOGDATA1("<<CSimDataCall::ProcessAnswerIncomingCall");
 
  1182 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_PROCESSANSWERINCOMINGCALLL_2, "<<CSimDataCall::ProcessAnswerIncomingCall");
 
  1177 	return ret;
 
  1183 	return ret;
 
  1178 	}
 
  1184 	}
 
  1179 
  1185 
  1180 TInt CSimDataCall::ProcessRemoteHangupL()
 
  1186 TInt CSimDataCall::ProcessRemoteHangupL()
 
  1181 /**
 
  1187 /**
 
  1183 * First the call state must be changed to "disconnecting", then the flag indicating
 
  1189 * First the call state must be changed to "disconnecting", then the flag indicating
 
  1184 * that a remote hangup request is no longer pending.  Finally, a new
 
  1190 * that a remote hangup request is no longer pending.  Finally, a new
 
  1185 * call object must be assigned to be the next remotely hung up call.
 
  1191 * call object must be assigned to be the next remotely hung up call.
 
  1186 */
 
  1192 */
 
  1187 	{
 
  1193 	{
 
  1188 	LOGDATA1(">>CSimDataCall::ProcessRemoteHangupL");
 
  1194 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_PROCESSREMOTEHANGUPL_1, ">>CSimDataCall::ProcessRemoteHangupL");
 
  1189 	TInt ret=ChangeStateL(RMobileCall::EStatusDisconnecting,EFalse,EFalse);
 
  1195 	TInt ret=ChangeStateL(RMobileCall::EStatusDisconnecting,EFalse,EFalse);
 
  1190 	if(ret!=KErrNone)
 
  1196 	if(ret!=KErrNone)
 
  1191 		return ret;
 
  1197 		return ret;
 
  1192 	iTimer->Start(iRemoteHangupPause,this);
 
  1198 	iTimer->Start(iRemoteHangupPause,this);
 
  1193 	iLine->ResetRemoteHangupCallObject(this);
 
  1199 	iLine->ResetRemoteHangupCallObject(this);
 
  1194 	LOGDATA1("<<CSimDataCall::ProcessRemoteHangupL");
 
  1200 	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMDATACALL_PROCESSREMOTEHANGUPL_2, "<<CSimDataCall::ProcessRemoteHangupL");
 
  1195 	return ret;
 
  1201 	return ret;
 
  1196 	}
 
  1202 	}
 
  1197 
  1203 
  1198 
  1204 
  1199 void CSimDataCall::PopulateCallParams(const TDesC8* aCallParams)
 
  1205 void CSimDataCall::PopulateCallParams(const TDesC8* aCallParams)
FCL/sf/os/cellularsrv