1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Implementattion for CSimSat Class

    15 // This file contains the implementation of the Similator TSY Sat functionality.  

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21 */

    22 

    23 #include "CSimSat.h" 

    24 #include "Simlog.h"

    25 #include "CSimPhone.h"

    26 #include "utils.h"

    27 #include <satcs.h>

    28 #include <e32math.h>

    29 

    30 const TInt KSatGranularity=2;		// < Granularity for sat list array

    31 

    32 CSimSat* CSimSat::NewL(CSimPhone* aPhone)

    33 /**

    34 * Standard two phase constructor

    35 *

    36 * @param aPhone Pointer to the phone object (CSimPhone)

    37 * @return CSimSat pointer to the Sat object created.

    38 * @leave Leaves if no memory or object is not created for any reason.

    39 */

    40 	{

    41 	CSimSat* simSat=new(ELeave) CSimSat(aPhone);

    42 	CleanupStack::PushL(simSat);

    43 	simSat->ConstructL();

    44 	CleanupStack::Pop();

    45 	return simSat;

    46 	}

    47 

    48 void CSimSat::Init()

    49 	{}

    50 

    51 CSimSat::CSimSat(CSimPhone* aPhone)

    52 	: iPhone(aPhone), iSatIndex(0), iRefreshRequiredPending(EFalse),

    53 		iMmsDownloadDataHandle(NULL),iEventDnldHandle(NULL)

    54 

    55 /**

    56 * Trivial Constructor.  Initialises all the data members

    57 *

    58 * @param aPhone pointer to the phone object that owns this class.

    59 */

    60 	{

    61 	iNotifyRefresh.iNotifyPending= EFalse;	

    62 	}

    63 

    64 void CSimSat::ConstructL()

    65 /**

    66 * Second phase of the 2-phase constructor.

    67 * Constructs all the member data and retrieves all the data from the config file specific to this class.

    68 *

    69 * @leave Leaves no memory or any data member does not construct for any reason.

    70 */

    71 	{

    72 	

    73 	LOGMISC1("CSimSat: Entered ConstructL()");

    74 	

    75 	iSatInfo	=new(ELeave) CArrayFixFlat<TSatInfo>(KSatGranularity);

    76 

    77 	iTimer = CSimTimer::NewL(iPhone);

    78 

    79 	LOGMISC1("Starting to parse Sat config parameters...");

    80 	

    81 	TInt count		=CfgFile()->ItemCount(KSatRefresh);

    82 	const CTestConfigItem* item=NULL;

    83 	TInt ret=KErrNone;

    84 

    85 	TInt i;

    86 	for(i=0;i<count;i++)

    87 		{

    88 		item=CfgFile()->Item(KSatRefresh,i);

    89 		if(!item)

    90 			break;

    91 

    92 		TInt duration,type;

    93 		TPtrC8 fileList;

    94 

    95 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);

    96 		if(ret!=KErrNone)

    97 			{

    98 			LOGPARSERR("duration",ret,0,&KSatRefresh);

    99 			continue;

   100 			}

   101 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);

   102 		if(ret!=KErrNone)

   103 			{

   104 			LOGPARSERR("type",ret,1,&KSatRefresh);

   105 			continue;

   106 			}

   107 		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,fileList);

   108 		if(ret!=KErrNone)

   109 			{

   110 			LOGPARSERR("fileList",ret,2,&KSatRefresh);

   111 			continue;

   112 			}

   113 

   114 		TSatInfo satInfo;

   115 		satInfo.iDuration = duration;

   116 		satInfo.iType = type;

   117 		TInt location = fileList.Locate('\n');

   118 		if(location > 0)

   119 			satInfo.iFileList.Set(fileList.Left(location));

   120 		else

   121 			satInfo.iFileList.Set(fileList);

   122 		iSatInfo->AppendL(satInfo);

   123 		}

   124 	

   125 	LOGMISC1("...Finished parsing Sat config parameters...");

   126 	

   127 	if(iSatInfo->Count()!=0)

   128 		{

   129 		iSatIndex=0;

   130 		iTimer->Start(iSatInfo->At(0).iDuration,this);

   131 		}

   132 	}

   133 		

   134 CSimSat::~CSimSat()

   135 /**

   136 * Trivial Destructor

   137 * Closes all CObject type objects and destroys all other objects created in the ConstructL()

   138 *

   139 */

   140 	{

   141 	LOGMISC1("CSimSat: Entered destructor");

   142 	delete iTimer;

   143 	if(iSatInfo)

   144 		{

   145 		iSatInfo->Delete(0,iSatInfo->Count());

   146 		delete iSatInfo;

   147 		}

   148 	if(iMMRetrieve)

   149 		{

   150 		iMMRetrieve->Delete(0,iMMRetrieve->Count());

   151 		delete iMMRetrieve;

   152 		}

   153 	if(iMMSubmit)

   154 		{

   155 		iMMSubmit->Delete(0,iMMSubmit->Count());

   156 		delete iMMSubmit;

   157 		}

   158 	if(iMMDisplay)

   159 		{

   160 		iMMDisplay->Delete(0,iMMDisplay->Count());

   161 		delete iMMDisplay;

   162 		}

   163 	if(iSetFrms)

   164 		{

   165 		iSetFrms->Delete(0,iSetFrms->Count());

   166 		delete iSetFrms;

   167 		}

   168 	if(iGetFrmsSts)

   169 		{

   170 		iGetFrmsSts->Delete(0,iGetFrmsSts->Count());

   171 		delete iGetFrmsSts;

   172 		}

   173 	if(iMmsDownloadData)

   174 		{

   175 		iMmsDownloadData->Delete(0,iMmsDownloadData->Count());

   176 		delete iMmsDownloadData;

   177 		}

   178 	if(iUssdData)

   179 		{

   180 		iUssdData->Delete(0,iUssdData->Count());

   181 		delete iUssdData;

   182 		}

   183 	if(iLocalInfo)

   184 		{

   185 		iLocalInfo->Delete(0,iLocalInfo->Count());

   186 		delete iLocalInfo;

   187 		}

   188 	if(iOpenChn)

   189 		{

   190 		iOpenChn->Delete(0,iOpenChn->Count());

   191 		delete iOpenChn;

   192 		}

   193 	if(iMiscCmd)

   194 		{

   195 		iMiscCmd->Delete(0,iMiscCmd->Count());

   196 		delete iMiscCmd;

   197 		}

   198 	if(iEventList)

   199 		{

   200 		iEventList->Delete(0,iEventList->Count());

   201 		delete iEventList;

   202 		}

   203 	if(iSendUssd)

   204 		{

   205 		iSendUssd->Delete(0,iSendUssd->Count());

   206 		delete iSendUssd;

   207 		}

   208 	if(iRefresh)

   209 		{

   210 		iRefresh->Delete(0,iRefresh->Count());

   211 		delete iRefresh;

   212 		}

   213 	if(iElemFiles)

   214 		{

   215 		iElemFiles->Delete(0,iElemFiles->Count());

   216 		delete iElemFiles;

   217 		}

   218 	if(iLnchBrwsr)

   219 		{

   220 		iLnchBrwsr->Delete(0,iLnchBrwsr->Count());

   221 		delete iLnchBrwsr;

   222 		}

   223 	if(iSendSS)

   224 		{

   225 		iSendSS->Delete(0,iSendSS->Count());

   226 		delete iSendSS;

   227 		}

   228 	}

   229 

   230 TInt CSimSat::ConvertTextToFileList(const TPtrC8& aText,

   231  									RSat::TRefreshFileList& aFileList) const

   232 /**

   233 * Converts a text based file list (e.g. "6F3A6F3B") to a binary file list (e.g

   234 * {0x6f3a, 0x6f3b}).

   235 *

   236 * @param aText Text string to convert.

   237 * @param aFileList Returned file list.

   238 * @return Error code KErrNone if request completes ok.  Otherwise a relevant error

   239 *         code.

   240 */

   241 	{

   242  	aFileList.Zero();

   243 

   244 	//

   245 	// Go through the string and take upto 4 characters at a time.  Convert each set

   246 	// from hexidecimal to an integer and then append them to the file list.

   247 	//

   248 	TInt  position(0);

   249 

   250 	while (position < aText.Length())

   251 		{

   252 		TInt  numberLength(4);

   253 

   254 		if (aText.Length() - position < 4)

   255 			{

   256 			numberLength = aText.Length() - position;

   257 			}

   258 

   259 		TLex8  token(aText.Mid(position, numberLength));

   260 		TUint  value;

   261 		TInt  ret;

   262 

   263 		ret = token.Val(value, EHex);

   264 		if (ret != KErrNone)

   265 			{

   266 			return(ret);

   267 			}

   268 

   269 		aFileList.Append(value);

   270 		position +=4;

   271 		}

   272 

   273 	return(KErrNone);

   274 }

   275 

   276 CTelObject* CSimSat::OpenNewObjectByNameL(const TDesC& /*aName*/)

   277 /**

   278 * Returns a pointer to an existing  object identified by name.

   279 * If the object is deleted then reopen it then return a handle to it.

   280 *

   281 * @param aName name of the Sat object to be opened

   282 * @return CTelObject pointer to the CSimSat object or null if not possible or not found

   283 * @leave Leaves if object cannot be opened or created.

   284 */

   285 	{

   286 	User::Leave(KErrNotSupported);

   287 	return NULL;

   288 	}

   289 

   290 CTelObject* CSimSat::OpenNewObjectL(TDes& /*aNewName*/)

   291 /**

   292 * Creates a new CSimSat object and returns a pointer to it.

   293 *

   294 * @param aName new name of the object created

   295 * @return CTelObject pointer to the CSimSat object created

   296 * @leave Leaves 

   297 */

   298 	{

   299 	User::Leave(KErrNotSupported);

   300 	return NULL;

   301 	}

   302 

   303 CTelObject::TReqMode CSimSat::ReqModeL(const TInt aIpc)

   304 /**

   305 * ReqModeL is called from the server's CTelObject::ReqAnalyserL

   306 * in order to check the type of request it has.

   307 * 

   308 * 

   309 * @param aIpc the ipc number that identifies the client request

   310 * @return CTelObject::TReqMode The request mode to be used for this request

   311 * @leave Leaves if not supported by this tsy

   312 */	

   313 	{

   314 	CTelObject::TReqMode ret=0;

   315 	switch (aIpc)

   316 		{

   317 		case ESatNotifyRefreshPCmd:

   318 		case ESatNotifyRefreshRequired:

   319 		case ESatNotifyRefreshRequiredParam:

   320 		case ESatNotifyRetrieveMultimediaMsgPCmd:

   321 		case ESatNotifySubmitMultimediaMsgPCmd:

   322 		case ESatNotifyDisplayMultimediaMsgPCmd:

   323 		case ESatNotifySetFramesPCmd:

   324 		case ESatNotifyGetFramesStatusPCmd:

   325 		case ESatNotifyLocalInfoPCmd:

   326 		case ESatNotifyOpenChannelPCmd:

   327 		case ESatNotifyPlayTonePCmd:

   328 		case ESatNotifySetUpCallPCmd:

   329 		case ESatNotifySendUssdPCmd:

   330 		case ESatNotifyGetInkeyPCmd:

   331 		case ESatNotifySendSsPCmd:

   332 		case ESatNotifyLaunchBrowserPCmd:

   333 			LOGMISC1("CSimSat: ReqModeL");

   334 			ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   335 			break;

   336 		case ESatRefreshAllowed:

   337 		case ESatTerminalRsp:

   338 		case ESatGetMeSideSatProfile:

   339 		case ESatEventDownload:

   340 		case ESatClientSatProfileIndication:

   341 		case ESatMmsTransferStatus:

   342 		case ESatMmsNotificationDownload:

   343 		case ESatUssdDataDownload:

   344 			break;

   345 		default:

   346 			User::Leave(KErrNotSupported);

   347 			break;

   348 		}

   349 	return ret;

   350 	}

   351 

   352 TInt CSimSat::RegisterNotification(const TInt aIpc)

   353 /**

   354 * RegisterNotification is called when the server recognises that this notification

   355 * is being posted for the first time on this sub-session object.

   356 * 

   357 * It enables the TSY to "turn on" any regular notification messages that it may receive 

   358 * from the phone

   359 *

   360 * @param aIpc the ipc number that identifies the client request

   361 * @return err KErrNone if fine

   362 */

   363 	{

   364 	switch (aIpc)

   365 		{

   366 		case ESatNotifyRefreshPCmd:

   367 		case ESatNotifyRefreshRequired:

   368 		case ESatNotifyRefreshRequiredParam:

   369 		case ESatNotifyRetrieveMultimediaMsgPCmd:

   370 		case ESatNotifySubmitMultimediaMsgPCmd:

   371 		case ESatNotifyDisplayMultimediaMsgPCmd:

   372 		case ESatNotifySetFramesPCmd:

   373 		case ESatNotifyGetFramesStatusPCmd:

   374 		case ESatGetMeSideSatProfile:

   375 		case ESatClientSatProfileIndication:

   376 		case ESatNotifyLocalInfoPCmd:

   377 		case ESatNotifyOpenChannelPCmd:

   378 		case ESatNotifyPlayTonePCmd: 

   379 		case ESatNotifySetUpCallPCmd:

   380 		case ESatEventDownload:

   381 		case ESatNotifySendUssdPCmd:

   382 		case ESatNotifyGetInkeyPCmd:

   383 		case ESatNotifySendSsPCmd:

   384 		case ESatNotifyLaunchBrowserPCmd:

   385 			LOGMISC1("CSimSat: RegisterNotification");

   386 			return KErrNone;

   387 		default:

   388 			// Unknown or invalid IPC

   389 			LOGMISC1("CSimSat: Register error, unknown IPC");

   390 			return KErrNotSupported;

   391 		}

   392 	}

   393 

   394 TInt CSimSat::DeregisterNotification(const TInt aIpc)

   395 /**

   396 * DeregisterNotification is called when the server recognises that this notification

   397 * will not be posted again because the last client to have a handle on this sub-session

   398 * object has just closed the handle.

   399 *

   400 * It enables the TSY to "turn off" any regular notification messages that it may 

   401 * receive from the phone

   402 *

   403 * @param aIpc the ipc number that identifies the client request

   404 * @return err KErrNone if fine

   405 */

   406 	{

   407 	switch (aIpc)

   408 		{

   409 		case ESatNotifyRefreshPCmd:

   410 		case ESatNotifyRefreshRequired:

   411 		case ESatNotifyRefreshRequiredParam:

   412 		case ESatNotifyRetrieveMultimediaMsgPCmd:

   413 		case ESatNotifySubmitMultimediaMsgPCmd:

   414 		case ESatNotifyDisplayMultimediaMsgPCmd:

   415 		case ESatNotifySetFramesPCmd:

   416 		case ESatNotifyGetFramesStatusPCmd:

   417 		case ESatGetMeSideSatProfile:

   418 		case ESatClientSatProfileIndication:

   419 		case ESatNotifyLocalInfoPCmd:

   420 		case ESatNotifyOpenChannelPCmd:

   421 		case ESatNotifyPlayTonePCmd:

   422 		case ESatNotifySetUpCallPCmd:

   423 		case ESatEventDownload:

   424 		case ESatNotifySendUssdPCmd:

   425 		case ESatNotifyGetInkeyPCmd:

   426 		case ESatNotifySendSsPCmd:

   427 		case ESatNotifyLaunchBrowserPCmd:

   428 			LOGMISC1("CSimSat: DeregisterNotification");

   429 			return KErrNone;

   430 		default:

   431 			// Unknown or invalid IPC

   432 			LOGMISC1("CSimSat: Deregister error, unknown IPC");

   433 			return KErrNotSupported;

   434 		}

   435 	}

   436 

   437 TInt CSimSat::NumberOfSlotsL(const TInt aIpc)

   438 /**

   439 * NumberOfSlotsL is called by the server when it is registering a new notification

   440 * It enables the TSY to tell the server how many buffer slots to allocate for

   441 * "repost immediately" notifications that may trigger before clients collect them

   442 *

   443 * @param aIpc the ipc number that identifies the client request

   444 * @return err KErrNone if fine

   445 */

   446 	{

   447 	TInt numberOfSlots=1;

   448 	switch (aIpc)

   449 		{

   450 		case ESatNotifyRefreshPCmd:

   451 		case ESatNotifyRefreshRequired:

   452 		case ESatNotifyRefreshRequiredParam:

   453 		case ESatNotifyRetrieveMultimediaMsgPCmd:

   454 		case ESatNotifySubmitMultimediaMsgPCmd:

   455 		case ESatNotifyDisplayMultimediaMsgPCmd:

   456 		case ESatNotifySetFramesPCmd:

   457 		case ESatNotifyGetFramesStatusPCmd:

   458 		case ESatNotifyLocalInfoPCmd:

   459 		case ESatNotifyOpenChannelPCmd:

   460 		case ESatNotifyPlayTonePCmd:

   461 		case ESatNotifySetUpCallPCmd:

   462 		case ESatEventDownload:

   463 		case ESatNotifySendUssdPCmd:

   464 		case ESatNotifyGetInkeyPCmd:

   465 		case ESatNotifySendSsPCmd:

   466 		case ESatNotifyLaunchBrowserPCmd:

   467 			LOGMISC1("CSimSat: Registered with 2 slot");

   468 			numberOfSlots=2;

   469 			break;

   470 		default:

   471 			// Unknown or invalid IPC

   472 			LOGMISC1("CSimSat: Number of Slots error, unknown IPC");

   473 			User::Leave(KErrNotSupported);

   474 			break;

   475 		}  

   476 	return numberOfSlots;

   477 	}

   478 

   479 

   480 TInt CSimSat::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

   481 							  const TDataPackage& aPackage)

   482 /**

   483 * ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request

   484 * for the TSY to process.

   485 * A request handle, request type and request data are passed to the TSY

   486 * 

   487 * @param aTsyReqHandle  The request handle for completing the request 

   488 * @param aIpc Ipc representing the request

   489 * @param aPackage any data associated with the request

   490 * @return err KErrNone if request completes ok

   491 */

   492 	{

   493 	//TAny* dataPtr=NULL;

   494 

   495 	switch (aIpc)

   496 		{

   497 		case ESatNotifyRefreshPCmd:

   498 			return NotifyRefreshPCmd(aTsyReqHandle, aPackage.Des1n());

   499 		case ESatNotifyRefreshRequired:

   500 			return NotifyRefreshRequired(aTsyReqHandle);

   501 		case ESatNotifyRefreshRequiredParam:

   502 			return NotifyRefreshRequired(aTsyReqHandle, aPackage.Des1n());

   503 		case ESatRefreshAllowed:

   504 			return RefreshAllowed(aTsyReqHandle, aPackage.Des1n());

   505 		case ESatNotifyRetrieveMultimediaMsgPCmd:

   506 			return NotifyRetrieveMultimediaMsgPCmd(aTsyReqHandle,aPackage.Des1n());

   507 		case ESatNotifySubmitMultimediaMsgPCmd:

   508 			return NotifySubmitMultimediaMsgPCmd(aTsyReqHandle,aPackage.Des1n());

   509 		case ESatNotifyDisplayMultimediaMsgPCmd:

   510 			return NotifyDisplayMultimediaMsgPCmd(aTsyReqHandle,aPackage.Des1n());

   511 		case ESatNotifySetFramesPCmd:

   512 			return NotifySetFramesPCmd(aTsyReqHandle,aPackage.Des1n());

   513 		case ESatNotifyGetFramesStatusPCmd:

   514 			return NotifyGetFramesStatusPCmd(aTsyReqHandle,aPackage.Des1n());

   515 		case ESatTerminalRsp:

   516 			return TerminalRsp(aTsyReqHandle,

   517 				REINTERPRET_CAST(RSat::TPCmd*,aPackage.Ptr1()),aPackage.Des2n());

   518 		case ESatGetMeSideSatProfile:

   519 			return GetMeSideSatProfile(aTsyReqHandle, aPackage.Des1n());

   520 		case ESatClientSatProfileIndication:

   521 			return ClientSatProfileIndication(aTsyReqHandle,aPackage.Des1n());

   522 		case ESatMmsTransferStatus:

   523 			return MmsTransferStatus(aTsyReqHandle, aPackage.Des1n());

   524 		case ESatMmsNotificationDownload:

   525 			return MmsNotificationDownload(aTsyReqHandle, aPackage.Des1n());

   526 		case ESatUssdDataDownload:

   527 			return UssdDataDownload(aTsyReqHandle, aPackage.Des1n());

   528 		case ESatNotifyLocalInfoPCmd:

   529 			return NotifyLocalInfoPCmd(aTsyReqHandle, aPackage.Des1n());

   530 		case ESatNotifyOpenChannelPCmd:

   531 			return NotifyOpenChannelPCmd(aTsyReqHandle,aPackage.Des1n());

   532 		case ESatNotifyPlayTonePCmd:

   533 			return NotifyPlayTonePCmd(aTsyReqHandle,aPackage.Des1n());

   534 		case ESatNotifySetUpCallPCmd:

   535 			return NotifySetupCallPCmd(aTsyReqHandle,aPackage.Des1n());

   536 		case ESatEventDownload:

   537 			return EventDownload(aTsyReqHandle,

   538 				REINTERPRET_CAST(RSat::TEventList*, aPackage.Ptr1()),aPackage.Des2n());

   539 		case ESatNotifySendUssdPCmd:

   540 			return NotifySendUssdPCmd(aTsyReqHandle,aPackage.Des1n());

   541 		case ESatNotifyGetInkeyPCmd:

   542 			return NotifyGetInkeyPCmd(aTsyReqHandle,aPackage.Des1n());

   543 		case ESatNotifySendSsPCmd:

   544 			return NotifySendSsPCmd(aTsyReqHandle,aPackage.Des1n());

   545 		case ESatNotifyLaunchBrowserPCmd:

   546 			return NotifyLaunchBrowserPCmd(aTsyReqHandle,aPackage.Des1n());

   547 		default:

   548 			return KErrNotSupported;

   549 		}

   550 	}

   551 

   552 TInt CSimSat::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

   553 /**

   554 * CancelService is called by the server when it is "cleaning-up" any still outstanding

   555 * asynchronous requests before closing a client's sub-session.

   556 * This will happen if a client closes its R-class handle without cancelling outstanding asynchronous requests.

   557 * 

   558 *  This function will be called when a client explicitly cancels

   559 *

   560 * @param aTsyReqHandle  The request handle for completing the request 

   561 * @param aIpc Ipc representing the request

   562 * @return err KErrNone if request completes ok

   563 */

   564 	{

   565 	LOGMISC1("CSimSat: - CancelService called");

   566 	switch (aIpc)

   567 		{

   568 		case ESatNotifyRefreshPCmd:

   569 			return NotifyRefreshPCmdCancel(aTsyReqHandle);

   570 		case ESatNotifyRefreshRequired:

   571 		case ESatNotifyRefreshRequiredParam:

   572 			return NotifyRefreshRequiredCancel(aTsyReqHandle);

   573 		case ESatRefreshAllowed:

   574 			return RefreshAllowedCancel(aTsyReqHandle);

   575 		case ESatNotifyRetrieveMultimediaMsgPCmd:

   576 			return NotifyRetrieveMultimediaMsgPCmdCancel(aTsyReqHandle);

   577 		case ESatNotifySubmitMultimediaMsgPCmd:

   578 			return NotifySubmitMultimediaMsgPCmdCancel(aTsyReqHandle);

   579 		case ESatNotifyDisplayMultimediaMsgPCmd:

   580 			return NotifyDisplayMultimediaMsgPCmdCancel(aTsyReqHandle);

   581 		case ESatNotifySetFramesPCmd:

   582 			return NotifySetFramesPCmdCancel(aTsyReqHandle);

   583 		case ESatNotifyGetFramesStatusPCmd:

   584 			return NotifyGetFramesStatusPCmdCancel(aTsyReqHandle);

   585 		case ESatTerminalRsp:

   586 			return TerminalRspCancel(aTsyReqHandle);

   587 		case ESatGetMeSideSatProfile:

   588 			return GetMeSideSatProfileCancel(aTsyReqHandle);

   589 		case ESatMmsTransferStatus:

   590 			return MmsTransferStatusCancel(aTsyReqHandle);

   591 		case ESatMmsNotificationDownload:

   592 			return MmsNotificationDownloadCancel(aTsyReqHandle);

   593 		case ESatUssdDataDownload:	

   594 			return UssdDataDownloadCancel(aTsyReqHandle);

   595 		case ESatNotifyLocalInfoPCmd:

   596 			return NotifyLocalInfoPCmdCancel(aTsyReqHandle);

   597 		case ESatNotifyOpenChannelPCmd:

   598 			return NotifyOpenChannelPCmdCancel(aTsyReqHandle);

   599 		case ESatNotifyPlayTonePCmd:

   600 			return NotifyPlayTonePCmdCancel(aTsyReqHandle);

   601 		case ESatNotifySetUpCallPCmd:

   602 			return NotifySetupCallPCmdCancel(aTsyReqHandle);

   603 		case ESatEventDownload:

   604 			return EventDownloadCancel(aTsyReqHandle);

   605 		case ESatNotifySendUssdPCmd:

   606 			return NotifySendUssdPCmdCancel(aTsyReqHandle);

   607 		case ESatNotifyGetInkeyPCmd:

   608 			return NotifyGetInkeyPCmdCancel(aTsyReqHandle);

   609 		case ESatNotifySendSsPCmd:

   610 			return NotifySendSsPCmdCancel(aTsyReqHandle);

   611 		case ESatNotifyLaunchBrowserPCmd:

   612 			return NotifyLaunchBrowserPCmdCancel(aTsyReqHandle);

   613 		default:

   614 			return KErrGeneral; 

   615 		} 

   616 	}

   617 

   618 

   619 TInt CSimSat::NotifyRefreshPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)

   620 	{

   621 	if(!iConfigDone)

   622 		{

   623 		TInt ret = KErrNone;

   624 		TRAPD(err, ret = ConfigL(SIMTSY_REFRESH_PCMD_NUMBER));

   625 		if(err != KErrNone)

   626 			{

   627 			ret = err;

   628 			}

   629 

   630 		if(ret!= KErrNone)

   631 			{

   632 			return ret;

   633 			}

   634 		else

   635 			{

   636 			iConfigDone = ETrue;

   637 			}

   638 		}

   639 

   640 	if(iSatInfo->Count()==0)

   641 		{

   642 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

   643 		return KErrNone;

   644 		}

   645 

   646 	__ASSERT_ALWAYS(!iNotifyRefresh.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

   647 	RSat::TRefreshV1Pckg* refreshPckg = (RSat::TRefreshV1Pckg*)aPCmd;

   648 	RSat::TRefreshV1& refresh = (*refreshPckg)();

   649 	

   650 

   651 	iNotifyRefresh.iNotifyPending=ETrue;

   652 	iNotifyRefresh.iNotifyHandle=aTsyReqHandle;

   653 	iNotifyRefresh.iNotifyData = &refresh;

   654 	

   655 	if(refresh.iType == RSat::E3GSessionReset || refresh.iType == RSat::EFileChangeNotification)

   656 	{

   657 		RSat::TRefreshV2Pckg* refreshPckg = (RSat::TRefreshV2Pckg*)aPCmd;

   658 		RSat::TRefreshV2& refresh2 = (*refreshPckg)();

   659 		

   660 		iNotifyRefresh.iNotifyData = &refresh2;

   661 		iRefreshV2 = ETrue;

   662 	}

   663 

   664 	return KErrNone;

   665 	}

   666 

   667 

   668 TInt CSimSat::NotifyRefreshPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)

   669 	{

   670 	if(iNotifyRefresh.iNotifyPending)

   671 		{

   672 		iNotifyRefresh.iNotifyPending=EFalse;

   673 		// Clear this flag here since if not within refresh required will be false, and if inside refresh required can be sure results will not be processed

   674 		iRefreshRequiredPending=EFalse; 

   675 		ReqCompleted(iNotifyRefresh.iNotifyHandle,KErrCancel);

   676 		}

   677 	return KErrNone;

   678 	}

   679 

   680 TInt CSimSat::NotifyRefreshRequired(const TTsyReqHandle aTsyReqHandle)

   681 	{

   682 	if(iSatInfo->Count()==0)

   683 		{

   684 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

   685 		return KErrNone;

   686 		}

   687 

   688 	__ASSERT_ALWAYS(!iRefreshRequired.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

   689 	iRefreshRequired.iNotifyPending=ETrue;

   690 	iRefreshRequired.iNotifyHandle=aTsyReqHandle;

   691 	iRefreshRequired.iNotifyData = NULL;

   692 	return KErrNone;	

   693 	}

   694 

   695 TInt CSimSat::NotifyRefreshRequired(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)

   696 	{

   697 	if(iSatInfo->Count()==0)

   698 		{

   699 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

   700 		return KErrNone;

   701 		}

   702 

   703 	__ASSERT_ALWAYS(!iRefreshRequired.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

   704 	RSat::TRefreshV1Pckg* refreshPckg = (RSat::TRefreshV1Pckg*)aPCmd;

   705 	RSat::TRefreshV1& refresh = (*refreshPckg)();

   706 

   707 	iRefreshRequired.iNotifyPending=ETrue;

   708 	iRefreshRequired.iNotifyHandle=aTsyReqHandle;

   709 	iRefreshRequired.iNotifyData = &refresh;

   710 	return KErrNone;	

   711 	}

   712 

   713 TInt CSimSat::NotifyRefreshRequiredCancel(const TTsyReqHandle /*aTsyReqHandle*/)

   714 	{

   715 	if(iRefreshRequired.iNotifyPending)

   716 		{

   717 		iRefreshRequired.iNotifyPending=EFalse;

   718 		iRefreshRequiredPending=EFalse;

   719 		ReqCompleted(iRefreshRequired.iNotifyHandle,KErrCancel);

   720 		}

   721 	return KErrNone;

   722 	}

   723 

   724 TInt CSimSat::RefreshAllowed(const TTsyReqHandle aTsyReqHandle, TDes8* aRefreshAllowedRsp)

   725 	{

   726 	if(iSatInfo->Count()==0)

   727 		{

   728 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

   729 		return KErrNone;

   730 		}

   731 

   732 	RSat::TRefreshRspV1Pckg* aRspPckg = (RSat::TRefreshRspV1Pckg*)aRefreshAllowedRsp;

   733 	RSat::TRefreshRspV1& rspV1 = (*aRspPckg)();

   734 

   735 	LOGMISC2("RefreshAllowed: - aRefreshAllowedResult %d",rspV1.iGeneralResult);

   736 

   737 	/* Set simtsy status to reflect clients status */

   738 	RSat::TPCmdResult refreshAllowedResult = rspV1.iGeneralResult;

   739 

   740 	__ASSERT_ALWAYS(!iRefreshAllowed.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

   741 

   742 	ReqCompleted(aTsyReqHandle, KErrNone);

   743 

   744 	iRefreshAllowed.iNotifyPending=EFalse;

   745 

   746 	if(iRefreshRequiredPending && iNotifyRefresh.iNotifyPending && refreshAllowedResult == RSat::KSuccess)

   747 		{

   748 		iNotifyRefresh.iNotifyPending=EFalse;

   749 		iRefreshRequiredPending=EFalse;

   750 

   751  		RSat::TRefreshV1&  refreshData = *(RSat::TRefreshV1*)iNotifyRefresh.iNotifyData;

   752 

   753   		refreshData.iType = iType;

   754   		refreshData.iFileList = iFileList;

   755   		

   756   		ReqCompleted(iNotifyRefresh.iNotifyHandle, KErrNone);

   757 		}

   758 

   759 	return KErrNone;	

   760 	}

   761 

   762 TInt CSimSat::RefreshAllowedCancel(const TTsyReqHandle /*aTsyReqHandle*/)

   763 	{

   764 	if(iRefreshAllowed.iNotifyPending)

   765 		{

   766 		iRefreshAllowed.iNotifyPending=EFalse;

   767 		ReqCompleted(iRefreshAllowed.iNotifyHandle,KErrCancel);

   768 		}

   769 	return KErrNone;

   770 	}

   771 

   772 TInt CSimSat::NotifyRetrieveMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)

   773 	{

   774 	

   775 	if(!iConfigDone)

   776 		{

   777 		TInt ret = KErrNone;

   778 		TRAPD(err, ret = ConfigL(SIMTSY_RET_MM_PCMD_NUMBER));

   779 		if(err != KErrNone)

   780 			{

   781 			ret = err;

   782 			}

   783 

   784 		if(ret!= KErrNone)

   785 			{

   786 			return ret;

   787 			}

   788 		else

   789 			{

   790 			TRAP(err, ret = ConfigL(SIMTSY_SUB_MM_PCMD_NUMBER));

   791 			if(err != KErrNone)

   792 				{

   793 				ret = err;

   794 				}

   795 

   796 			if(ret!=KErrNone)

   797 				{

   798 				return ret;

   799 				}

   800 			else

   801 				{

   802 				TRAP(err, ret = ConfigL(SIMTSY_ELEMFILES_CMD_NUMBER));

   803 				if(err != KErrNone)

   804 					{

   805 					ret = err;

   806 					}

   807 				if(ret!=KErrNone)

   808 					{

   809 					return ret;

   810 					}

   811 				else

   812 					{

   813 					iConfigDone = ETrue;

   814 					}

   815 				}

   816 			}

   817 		}

   818 	

   819 	if(iMMRetrieve->Count()==0)

   820 		{

   821 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

   822 		return KErrNone;

   823 		}

   824 

   825 	__ASSERT_ALWAYS(!iNotifyRetrieveMM.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

   826 	

   827 	

   828 	RSat::TRetrieveMultimediaMessageV6Pckg *aRspPckg = (RSat::TRetrieveMultimediaMessageV6Pckg*)aPCmd;

   829 	RSat::TRetrieveMultimediaMessageV6& rspRetMM = (*aRspPckg)();

   830 	

   831 	iNotifyRetrieveMM.iNotifyPending=ETrue;

   832 	iNotifyRetrieveMM.iNotifyHandle=aTsyReqHandle;

   833 	iNotifyRetrieveMM.iNotifyData = &rspRetMM;

   834 	

   835 	iRefreshEf= ETrue;

   836 		

   837 	return KErrNone;

   838 	

   839 	}

   840 

   841 TInt CSimSat::NotifyRetrieveMultimediaMsgPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)

   842 	{

   843 	

   844 	if(iNotifyRetrieveMM.iNotifyPending)

   845 		{

   846 		iNotifyRetrieveMM.iNotifyPending=EFalse;

   847 		ReqCompleted(iNotifyRetrieveMM.iNotifyHandle,KErrCancel);

   848 		}

   849 	else

   850 		{

   851 		ReqCompleted(iNotifyRetrieveMM.iNotifyHandle,KErrNone);

   852 		}

   853 	return KErrNone;

   854 		

   855 	}

   856 

   857 TInt CSimSat::NotifyLaunchBrowserPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)

   858 	{

   859 	

   860 	if(!iConfigDone)

   861 		{

   862 		TInt ret = KErrNone;

   863 		TRAPD(err, ret = ConfigL(SIMTSY_LNCH_BRWSR_PCMD_NUMBER));

   864 		if(err != KErrNone)

   865 			{

   866 			ret = err;

   867 			}

   868 

   869 		if(ret!= KErrNone)

   870 			{

   871 			return ret;

   872 			}

   873 		else

   874 			{

   875 			TRAP(err, ret = ConfigL(SIMTSY_EVENT_LIST_CMD_NUMBER));

   876 			if(err != KErrNone)

   877 				{

   878 				ret = err;

   879 				}

   880 

   881 			if(ret != KErrNone)

   882 				{

   883 				return ret;

   884 				}

   885 			else

   886 				{

   887 				iConfigDone = ETrue;

   888 				}

   889 			}

   890 		}

   891 

   892 	if(iLnchBrwsr->Count()==0)

   893 		{

   894 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

   895 		return KErrNone;

   896 		}

   897 

   898 	__ASSERT_ALWAYS(!iNotifyLnchBrwsr.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

   899 	

   900 	RSat::TLaunchBrowserV6Pckg *aRspPckg = (RSat::TLaunchBrowserV6Pckg*)aPCmd;

   901 	RSat::TLaunchBrowserV6& rspLncBrwsr = (*aRspPckg)();

   902 	

   903 	iNotifyLnchBrwsr.iNotifyPending=ETrue;

   904 	iNotifyLnchBrwsr.iNotifyHandle=aTsyReqHandle;

   905 	iNotifyLnchBrwsr.iNotifyData = &rspLncBrwsr;

   906 	

   907 	if(!iRefreshEf)

   908 		{

   909 		iRefreshEf= ETrue;

   910 		}

   911 	

   912 	return KErrNone;

   913 	

   914 	}

   915 

   916 

   917 TInt CSimSat::NotifyLaunchBrowserPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)

   918 	{

   919 	

   920 	if(iNotifyLnchBrwsr.iNotifyPending)

   921 		{

   922 		iNotifyLnchBrwsr.iNotifyPending=EFalse;

   923 		ReqCompleted(iNotifyLnchBrwsr.iNotifyHandle,KErrCancel);

   924 		}

   925 	else

   926 		{

   927 		ReqCompleted(iNotifyLnchBrwsr.iNotifyHandle,KErrNone);

   928 		}

   929 	return KErrNone;

   930 		

   931 	}

   932 	

   933 TInt CSimSat::NotifySubmitMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)

   934 	{

   935 	

   936 	if(!iConfigDone)

   937 		{

   938 		TInt ret = KErrNone;

   939 		TRAPD(err, ret = ConfigL(SIMTSY_SUB_MM_PCMD_NUMBER));

   940 		if(err != KErrNone)

   941 			{

   942 			ret = err;

   943 			}

   944 

   945 		if(ret!= KErrNone)

   946 			{

   947 			return ret;

   948 			}

   949 		else

   950 			{

   951 			TRAP(err, ret = ConfigL(SIMTSY_ELEMFILES_CMD_NUMBER));

   952 			if(err != KErrNone)

   953 				{

   954 				ret = err;

   955 				}

   956 

   957 			if(ret!=KErrNone)

   958 				{

   959 				return ret;

   960 				}

   961 			else

   962 				{

   963 				iConfigDone = ETrue;

   964 				}

   965 			}

   966 		}

   967 	

   968 	if(iMMSubmit->Count()==0)

   969 		{

   970 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

   971 		return KErrNone;

   972 		}

   973 

   974 	__ASSERT_ALWAYS(!iNotifySubmitMM.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

   975 	

   976 	RSat::TSubmitMultimediaMessageV6Pckg *aRspPckg = (RSat::TSubmitMultimediaMessageV6Pckg*)aPCmd;

   977 	RSat::TSubmitMultimediaMessageV6& rspRetMM = (*aRspPckg)();

   978 	

   979 	iNotifySubmitMM.iNotifyPending=ETrue;

   980 	iNotifySubmitMM.iNotifyHandle=aTsyReqHandle;

   981 	iNotifySubmitMM.iNotifyData = &rspRetMM;

   982 	

   983 	if(!iRefreshEf)

   984 		{

   985 		iRefreshEf= ETrue;

   986 		}

   987 	

   988 	return KErrNone;

   989 	

   990 	}

   991 

   992 TInt CSimSat::NotifySubmitMultimediaMsgPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)

   993 	{

   994 	

   995 	if(iNotifySubmitMM.iNotifyPending)

   996 		{

   997 		iNotifySubmitMM.iNotifyPending=EFalse;

   998 		ReqCompleted(iNotifySubmitMM.iNotifyHandle,KErrCancel);

   999 		}

  1000 	else

  1001 		{

  1002 		ReqCompleted(iNotifySubmitMM.iNotifyHandle,KErrNone);

  1003 		}

  1004 	return KErrNone;

  1005 		

  1006 	}

  1007 

  1008 TInt CSimSat::NotifyDisplayMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)

  1009 	{

  1010 	

  1011 	if(!iConfigDone)

  1012 		{

  1013 		TInt ret = KErrNone;

  1014 		TRAPD(err, ret = ConfigL(SIMTSY_DISP_MM_PCMD_NUMBER));

  1015 		if(err != KErrNone)

  1016 			{

  1017 			ret = err;

  1018 			}

  1019 

  1020 		if(ret!= KErrNone)

  1021 			{

  1022 			return ret;

  1023 			}

  1024 		else

  1025 			{

  1026 			iConfigDone = ETrue;

  1027 			}

  1028 		}

  1029 

  1030 	if(iMMDisplay->Count()==0)

  1031 		{

  1032 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

  1033 		return KErrNone;

  1034 		}

  1035 

  1036 	__ASSERT_ALWAYS(!iNotifyDisplayMM.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

  1037 	

  1038 	RSat::TDisplayMultimediaMessageV6Pckg *aRspPckg = (RSat::TDisplayMultimediaMessageV6Pckg*)aPCmd;

  1039 	RSat::TDisplayMultimediaMessageV6& rspRetMM = (*aRspPckg)();

  1040 	

  1041 	iNotifyDisplayMM.iNotifyPending=ETrue;

  1042 	iNotifyDisplayMM.iNotifyHandle=aTsyReqHandle;

  1043 	iNotifyDisplayMM.iNotifyData = &rspRetMM;

  1044 	

  1045 	return KErrNone;

  1046 	

  1047 	}

  1048 

  1049 TInt CSimSat::NotifyDisplayMultimediaMsgPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)

  1050 	{

  1051 	

  1052 	if(iNotifyDisplayMM.iNotifyPending)

  1053 		{

  1054 		iNotifyDisplayMM.iNotifyPending=EFalse;

  1055 		ReqCompleted(iNotifyDisplayMM.iNotifyHandle,KErrCancel);

  1056 		}

  1057 	else

  1058 		{

  1059 		ReqCompleted(iNotifyDisplayMM.iNotifyHandle,KErrNone);

  1060 		}

  1061 	return KErrNone;

  1062 		

  1063 	}

  1064 

  1065 TInt CSimSat::NotifySetFramesPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)

  1066 	{

  1067 

  1068 	if(!iConfigDone)

  1069 		{

  1070 		TInt ret = KErrNone;

  1071 		TRAPD(err, ret = ConfigL(SIMTSY_SET_FRMS_PCMD_NUMBER));

  1072 		if(err != KErrNone)

  1073 			{

  1074 			ret = err;

  1075 			}

  1076 

  1077 		if(ret!= KErrNone)

  1078 			{

  1079 			return ret;

  1080 			}

  1081 		else

  1082 			{

  1083 			iConfigDone = ETrue;

  1084 			}

  1085 		}

  1086 

  1087 	if(iSetFrms->Count() == 0)

  1088 		{

  1089 		ReqCompleted(aTsyReqHandle,KErrNotSupported);

  1090 		return KErrNone;

  1091 		}

  1092 	

  1093 	__ASSERT_ALWAYS(!iNotifySetFrms.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

  1094 	

  1095 	RSat::TSetFramesV6Pckg *aRspPckg = (RSat::TSetFramesV6Pckg*)aPCmd;

  1096 	RSat::TSetFramesV6& rspSetFrmsV6 = (*aRspPckg)();

  1097 	

  1098 	iNotifySetFrms.iNotifyPending=ETrue;

  1099 	iNotifySetFrms.iNotifyHandle=aTsyReqHandle;

  1100 	iNotifySetFrms.iNotifyData = &rspSetFrmsV6;

  1101 	

  1102 	return KErrNone;

  1103 	}

  1104 

  1105 TInt CSimSat::NotifySetFramesPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)

  1106 	{

  1107 	

  1108 	if(iNotifySetFrms.iNotifyPending)

  1109 		{

  1110 		iNotifySetFrms.iNotifyPending=EFalse;

  1111 		ReqCompleted(iNotifySetFrms.iNotifyHandle,KErrCancel);

  1112 		}

  1113 	else

  1114 		{

  1115 		ReqCompleted(iNotifySetFrms.iNotifyHandle,KErrNone);

  1116 		}

  1117 	return KErrNone;

  1118 		

  1119 	}

  1120 

  1121 TInt CSimSat::NotifyGetFramesStatusPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)

  1122 	{

  1123 	

  1124 	if(!iConfigDone)

  1125 		{

  1126 		TInt ret = KErrNone;

  1127 		TRAPD(err, ret = ConfigL(SIMTSY_GET_FRMS_STS_PCMD_NUMBER));

  1128 		if(err != KErrNone)

  1129 			{

  1130 			ret = err;

  1131 			}

  1132 

  1133 		if(ret!= KErrNone)

  1134 			{