--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/simtsy/src/CSimSat.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,4341 @@
+// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Implementattion for CSimSat Class
+// This file contains the implementation of the Similator TSY Sat functionality.
+//
+//
+
+/**
+ @file
+*/
+
+#include "CSimSat.h"
+#include "Simlog.h"
+#include "CSimPhone.h"
+#include "utils.h"
+#include <satcs.h>
+#include <e32math.h>
+
+const TInt KSatGranularity=2; // < Granularity for sat list array
+
+CSimSat* CSimSat::NewL(CSimPhone* aPhone)
+/**
+* Standard two phase constructor
+*
+* @param aPhone Pointer to the phone object (CSimPhone)
+* @return CSimSat pointer to the Sat object created.
+* @leave Leaves if no memory or object is not created for any reason.
+*/
+ {
+ CSimSat* simSat=new(ELeave) CSimSat(aPhone);
+ CleanupStack::PushL(simSat);
+ simSat->ConstructL();
+ CleanupStack::Pop();
+ return simSat;
+ }
+
+void CSimSat::Init()
+ {}
+
+CSimSat::CSimSat(CSimPhone* aPhone)
+ : iPhone(aPhone), iSatIndex(0), iRefreshRequiredPending(EFalse),
+ iMmsDownloadDataHandle(NULL),iEventDnldHandle(NULL)
+
+/**
+* Trivial Constructor. Initialises all the data members
+*
+* @param aPhone pointer to the phone object that owns this class.
+*/
+ {
+ iNotifyRefresh.iNotifyPending= EFalse;
+ }
+
+void CSimSat::ConstructL()
+/**
+* Second phase of the 2-phase constructor.
+* Constructs all the member data and retrieves all the data from the config file specific to this class.
+*
+* @leave Leaves no memory or any data member does not construct for any reason.
+*/
+ {
+
+ LOGMISC1("CSimSat: Entered ConstructL()");
+
+ iSatInfo =new(ELeave) CArrayFixFlat<TSatInfo>(KSatGranularity);
+
+ iTimer = CSimTimer::NewL(iPhone);
+
+ LOGMISC1("Starting to parse Sat config parameters...");
+
+ TInt count =CfgFile()->ItemCount(KSatRefresh);
+ const CTestConfigItem* item=NULL;
+ TInt ret=KErrNone;
+
+ TInt i;
+ for(i=0;i<count;i++)
+ {
+ item=CfgFile()->Item(KSatRefresh,i);
+ if(!item)
+ break;
+
+ TInt duration,type;
+ TPtrC8 fileList;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("duration",ret,0,&KSatRefresh);
+ continue;
+ }
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("type",ret,1,&KSatRefresh);
+ continue;
+ }
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,fileList);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("fileList",ret,2,&KSatRefresh);
+ continue;
+ }
+
+ TSatInfo satInfo;
+ satInfo.iDuration = duration;
+ satInfo.iType = type;
+ TInt location = fileList.Locate('\n');
+ if(location > 0)
+ satInfo.iFileList.Set(fileList.Left(location));
+ else
+ satInfo.iFileList.Set(fileList);
+ iSatInfo->AppendL(satInfo);
+ }
+
+ LOGMISC1("...Finished parsing Sat config parameters...");
+
+ if(iSatInfo->Count()!=0)
+ {
+ iSatIndex=0;
+ iTimer->Start(iSatInfo->At(0).iDuration,this);
+ }
+ }
+
+CSimSat::~CSimSat()
+/**
+* Trivial Destructor
+* Closes all CObject type objects and destroys all other objects created in the ConstructL()
+*
+*/
+ {
+ LOGMISC1("CSimSat: Entered destructor");
+ delete iTimer;
+ if(iSatInfo)
+ {
+ iSatInfo->Delete(0,iSatInfo->Count());
+ delete iSatInfo;
+ }
+ if(iMMRetrieve)
+ {
+ iMMRetrieve->Delete(0,iMMRetrieve->Count());
+ delete iMMRetrieve;
+ }
+ if(iMMSubmit)
+ {
+ iMMSubmit->Delete(0,iMMSubmit->Count());
+ delete iMMSubmit;
+ }
+ if(iMMDisplay)
+ {
+ iMMDisplay->Delete(0,iMMDisplay->Count());
+ delete iMMDisplay;
+ }
+ if(iSetFrms)
+ {
+ iSetFrms->Delete(0,iSetFrms->Count());
+ delete iSetFrms;
+ }
+ if(iGetFrmsSts)
+ {
+ iGetFrmsSts->Delete(0,iGetFrmsSts->Count());
+ delete iGetFrmsSts;
+ }
+ if(iMmsDownloadData)
+ {
+ iMmsDownloadData->Delete(0,iMmsDownloadData->Count());
+ delete iMmsDownloadData;
+ }
+ if(iUssdData)
+ {
+ iUssdData->Delete(0,iUssdData->Count());
+ delete iUssdData;
+ }
+ if(iLocalInfo)
+ {
+ iLocalInfo->Delete(0,iLocalInfo->Count());
+ delete iLocalInfo;
+ }
+ if(iOpenChn)
+ {
+ iOpenChn->Delete(0,iOpenChn->Count());
+ delete iOpenChn;
+ }
+ if(iMiscCmd)
+ {
+ iMiscCmd->Delete(0,iMiscCmd->Count());
+ delete iMiscCmd;
+ }
+ if(iEventList)
+ {
+ iEventList->Delete(0,iEventList->Count());
+ delete iEventList;
+ }
+ if(iSendUssd)
+ {
+ iSendUssd->Delete(0,iSendUssd->Count());
+ delete iSendUssd;
+ }
+ if(iRefresh)
+ {
+ iRefresh->Delete(0,iRefresh->Count());
+ delete iRefresh;
+ }
+ if(iElemFiles)
+ {
+ iElemFiles->Delete(0,iElemFiles->Count());
+ delete iElemFiles;
+ }
+ if(iLnchBrwsr)
+ {
+ iLnchBrwsr->Delete(0,iLnchBrwsr->Count());
+ delete iLnchBrwsr;
+ }
+ if(iSendSS)
+ {
+ iSendSS->Delete(0,iSendSS->Count());
+ delete iSendSS;
+ }
+ }
+
+TInt CSimSat::ConvertTextToFileList(const TPtrC8& aText,
+ RSat::TRefreshFileList& aFileList) const
+/**
+* Converts a text based file list (e.g. "6F3A6F3B") to a binary file list (e.g
+* {0x6f3a, 0x6f3b}).
+*
+* @param aText Text string to convert.
+* @param aFileList Returned file list.
+* @return Error code KErrNone if request completes ok. Otherwise a relevant error
+* code.
+*/
+ {
+ aFileList.Zero();
+
+ //
+ // Go through the string and take upto 4 characters at a time. Convert each set
+ // from hexidecimal to an integer and then append them to the file list.
+ //
+ TInt position(0);
+
+ while (position < aText.Length())
+ {
+ TInt numberLength(4);
+
+ if (aText.Length() - position < 4)
+ {
+ numberLength = aText.Length() - position;
+ }
+
+ TLex8 token(aText.Mid(position, numberLength));
+ TUint value;
+ TInt ret;
+
+ ret = token.Val(value, EHex);
+ if (ret != KErrNone)
+ {
+ return(ret);
+ }
+
+ aFileList.Append(value);
+ position +=4;
+ }
+
+ return(KErrNone);
+}
+
+CTelObject* CSimSat::OpenNewObjectByNameL(const TDesC& /*aName*/)
+/**
+* Returns a pointer to an existing object identified by name.
+* If the object is deleted then reopen it then return a handle to it.
+*
+* @param aName name of the Sat object to be opened
+* @return CTelObject pointer to the CSimSat object or null if not possible or not found
+* @leave Leaves if object cannot be opened or created.
+*/
+ {
+ User::Leave(KErrNotSupported);
+ return NULL;
+ }
+
+CTelObject* CSimSat::OpenNewObjectL(TDes& /*aNewName*/)
+/**
+* Creates a new CSimSat object and returns a pointer to it.
+*
+* @param aName new name of the object created
+* @return CTelObject pointer to the CSimSat object created
+* @leave Leaves
+*/
+ {
+ User::Leave(KErrNotSupported);
+ return NULL;
+ }
+
+CTelObject::TReqMode CSimSat::ReqModeL(const TInt aIpc)
+/**
+* ReqModeL is called from the server's CTelObject::ReqAnalyserL
+* in order to check the type of request it has.
+*
+*
+* @param aIpc the ipc number that identifies the client request
+* @return CTelObject::TReqMode The request mode to be used for this request
+* @leave Leaves if not supported by this tsy
+*/
+ {
+ CTelObject::TReqMode ret=0;
+ switch (aIpc)
+ {
+ case ESatNotifyRefreshPCmd:
+ case ESatNotifyRefreshRequired:
+ case ESatNotifyRefreshRequiredParam:
+ case ESatNotifyRetrieveMultimediaMsgPCmd:
+ case ESatNotifySubmitMultimediaMsgPCmd:
+ case ESatNotifyDisplayMultimediaMsgPCmd:
+ case ESatNotifySetFramesPCmd:
+ case ESatNotifyGetFramesStatusPCmd:
+ case ESatNotifyLocalInfoPCmd:
+ case ESatNotifyOpenChannelPCmd:
+ case ESatNotifyPlayTonePCmd:
+ case ESatNotifySetUpCallPCmd:
+ case ESatNotifySendUssdPCmd:
+ case ESatNotifyGetInkeyPCmd:
+ case ESatNotifySendSsPCmd:
+ case ESatNotifyLaunchBrowserPCmd:
+ LOGMISC1("CSimSat: ReqModeL");
+ ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
+ break;
+ case ESatRefreshAllowed:
+ case ESatTerminalRsp:
+ case ESatGetMeSideSatProfile:
+ case ESatEventDownload:
+ case ESatClientSatProfileIndication:
+ case ESatMmsTransferStatus:
+ case ESatMmsNotificationDownload:
+ case ESatUssdDataDownload:
+ break;
+ default:
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ return ret;
+ }
+
+TInt CSimSat::RegisterNotification(const TInt aIpc)
+/**
+* RegisterNotification is called when the server recognises that this notification
+* is being posted for the first time on this sub-session object.
+*
+* It enables the TSY to "turn on" any regular notification messages that it may receive
+* from the phone
+*
+* @param aIpc the ipc number that identifies the client request
+* @return err KErrNone if fine
+*/
+ {
+ switch (aIpc)
+ {
+ case ESatNotifyRefreshPCmd:
+ case ESatNotifyRefreshRequired:
+ case ESatNotifyRefreshRequiredParam:
+ case ESatNotifyRetrieveMultimediaMsgPCmd:
+ case ESatNotifySubmitMultimediaMsgPCmd:
+ case ESatNotifyDisplayMultimediaMsgPCmd:
+ case ESatNotifySetFramesPCmd:
+ case ESatNotifyGetFramesStatusPCmd:
+ case ESatGetMeSideSatProfile:
+ case ESatClientSatProfileIndication:
+ case ESatNotifyLocalInfoPCmd:
+ case ESatNotifyOpenChannelPCmd:
+ case ESatNotifyPlayTonePCmd:
+ case ESatNotifySetUpCallPCmd:
+ case ESatEventDownload:
+ case ESatNotifySendUssdPCmd:
+ case ESatNotifyGetInkeyPCmd:
+ case ESatNotifySendSsPCmd:
+ case ESatNotifyLaunchBrowserPCmd:
+ LOGMISC1("CSimSat: RegisterNotification");
+ return KErrNone;
+ default:
+ // Unknown or invalid IPC
+ LOGMISC1("CSimSat: Register error, unknown IPC");
+ return KErrNotSupported;
+ }
+ }
+
+TInt CSimSat::DeregisterNotification(const TInt aIpc)
+/**
+* DeregisterNotification is called when the server recognises that this notification
+* will not be posted again because the last client to have a handle on this sub-session
+* object has just closed the handle.
+*
+* It enables the TSY to "turn off" any regular notification messages that it may
+* receive from the phone
+*
+* @param aIpc the ipc number that identifies the client request
+* @return err KErrNone if fine
+*/
+ {
+ switch (aIpc)
+ {
+ case ESatNotifyRefreshPCmd:
+ case ESatNotifyRefreshRequired:
+ case ESatNotifyRefreshRequiredParam:
+ case ESatNotifyRetrieveMultimediaMsgPCmd:
+ case ESatNotifySubmitMultimediaMsgPCmd:
+ case ESatNotifyDisplayMultimediaMsgPCmd:
+ case ESatNotifySetFramesPCmd:
+ case ESatNotifyGetFramesStatusPCmd:
+ case ESatGetMeSideSatProfile:
+ case ESatClientSatProfileIndication:
+ case ESatNotifyLocalInfoPCmd:
+ case ESatNotifyOpenChannelPCmd:
+ case ESatNotifyPlayTonePCmd:
+ case ESatNotifySetUpCallPCmd:
+ case ESatEventDownload:
+ case ESatNotifySendUssdPCmd:
+ case ESatNotifyGetInkeyPCmd:
+ case ESatNotifySendSsPCmd:
+ case ESatNotifyLaunchBrowserPCmd:
+ LOGMISC1("CSimSat: DeregisterNotification");
+ return KErrNone;
+ default:
+ // Unknown or invalid IPC
+ LOGMISC1("CSimSat: Deregister error, unknown IPC");
+ return KErrNotSupported;
+ }
+ }
+
+TInt CSimSat::NumberOfSlotsL(const TInt aIpc)
+/**
+* NumberOfSlotsL is called by the server when it is registering a new notification
+* It enables the TSY to tell the server how many buffer slots to allocate for
+* "repost immediately" notifications that may trigger before clients collect them
+*
+* @param aIpc the ipc number that identifies the client request
+* @return err KErrNone if fine
+*/
+ {
+ TInt numberOfSlots=1;
+ switch (aIpc)
+ {
+ case ESatNotifyRefreshPCmd:
+ case ESatNotifyRefreshRequired:
+ case ESatNotifyRefreshRequiredParam:
+ case ESatNotifyRetrieveMultimediaMsgPCmd:
+ case ESatNotifySubmitMultimediaMsgPCmd:
+ case ESatNotifyDisplayMultimediaMsgPCmd:
+ case ESatNotifySetFramesPCmd:
+ case ESatNotifyGetFramesStatusPCmd:
+ case ESatNotifyLocalInfoPCmd:
+ case ESatNotifyOpenChannelPCmd:
+ case ESatNotifyPlayTonePCmd:
+ case ESatNotifySetUpCallPCmd:
+ case ESatEventDownload:
+ case ESatNotifySendUssdPCmd:
+ case ESatNotifyGetInkeyPCmd:
+ case ESatNotifySendSsPCmd:
+ case ESatNotifyLaunchBrowserPCmd:
+ LOGMISC1("CSimSat: Registered with 2 slot");
+ numberOfSlots=2;
+ break;
+ default:
+ // Unknown or invalid IPC
+ LOGMISC1("CSimSat: Number of Slots error, unknown IPC");
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ return numberOfSlots;
+ }
+
+
+TInt CSimSat::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,
+ const TDataPackage& aPackage)
+/**
+* ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request
+* for the TSY to process.
+* A request handle, request type and request data are passed to the TSY
+*
+* @param aTsyReqHandle The request handle for completing the request
+* @param aIpc Ipc representing the request
+* @param aPackage any data associated with the request
+* @return err KErrNone if request completes ok
+*/
+ {
+ //TAny* dataPtr=NULL;
+
+ switch (aIpc)
+ {
+ case ESatNotifyRefreshPCmd:
+ return NotifyRefreshPCmd(aTsyReqHandle, aPackage.Des1n());
+ case ESatNotifyRefreshRequired:
+ return NotifyRefreshRequired(aTsyReqHandle);
+ case ESatNotifyRefreshRequiredParam:
+ return NotifyRefreshRequired(aTsyReqHandle, aPackage.Des1n());
+ case ESatRefreshAllowed:
+ return RefreshAllowed(aTsyReqHandle, aPackage.Des1n());
+ case ESatNotifyRetrieveMultimediaMsgPCmd:
+ return NotifyRetrieveMultimediaMsgPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifySubmitMultimediaMsgPCmd:
+ return NotifySubmitMultimediaMsgPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifyDisplayMultimediaMsgPCmd:
+ return NotifyDisplayMultimediaMsgPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifySetFramesPCmd:
+ return NotifySetFramesPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifyGetFramesStatusPCmd:
+ return NotifyGetFramesStatusPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatTerminalRsp:
+ return TerminalRsp(aTsyReqHandle,
+ REINTERPRET_CAST(RSat::TPCmd*,aPackage.Ptr1()),aPackage.Des2n());
+ case ESatGetMeSideSatProfile:
+ return GetMeSideSatProfile(aTsyReqHandle, aPackage.Des1n());
+ case ESatClientSatProfileIndication:
+ return ClientSatProfileIndication(aTsyReqHandle,aPackage.Des1n());
+ case ESatMmsTransferStatus:
+ return MmsTransferStatus(aTsyReqHandle, aPackage.Des1n());
+ case ESatMmsNotificationDownload:
+ return MmsNotificationDownload(aTsyReqHandle, aPackage.Des1n());
+ case ESatUssdDataDownload:
+ return UssdDataDownload(aTsyReqHandle, aPackage.Des1n());
+ case ESatNotifyLocalInfoPCmd:
+ return NotifyLocalInfoPCmd(aTsyReqHandle, aPackage.Des1n());
+ case ESatNotifyOpenChannelPCmd:
+ return NotifyOpenChannelPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifyPlayTonePCmd:
+ return NotifyPlayTonePCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifySetUpCallPCmd:
+ return NotifySetupCallPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatEventDownload:
+ return EventDownload(aTsyReqHandle,
+ REINTERPRET_CAST(RSat::TEventList*, aPackage.Ptr1()),aPackage.Des2n());
+ case ESatNotifySendUssdPCmd:
+ return NotifySendUssdPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifyGetInkeyPCmd:
+ return NotifyGetInkeyPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifySendSsPCmd:
+ return NotifySendSsPCmd(aTsyReqHandle,aPackage.Des1n());
+ case ESatNotifyLaunchBrowserPCmd:
+ return NotifyLaunchBrowserPCmd(aTsyReqHandle,aPackage.Des1n());
+ default:
+ return KErrNotSupported;
+ }
+ }
+
+TInt CSimSat::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)
+/**
+* CancelService is called by the server when it is "cleaning-up" any still outstanding
+* asynchronous requests before closing a client's sub-session.
+* This will happen if a client closes its R-class handle without cancelling outstanding asynchronous requests.
+*
+* This function will be called when a client explicitly cancels
+*
+* @param aTsyReqHandle The request handle for completing the request
+* @param aIpc Ipc representing the request
+* @return err KErrNone if request completes ok
+*/
+ {
+ LOGMISC1("CSimSat: - CancelService called");
+ switch (aIpc)
+ {
+ case ESatNotifyRefreshPCmd:
+ return NotifyRefreshPCmdCancel(aTsyReqHandle);
+ case ESatNotifyRefreshRequired:
+ case ESatNotifyRefreshRequiredParam:
+ return NotifyRefreshRequiredCancel(aTsyReqHandle);
+ case ESatRefreshAllowed:
+ return RefreshAllowedCancel(aTsyReqHandle);
+ case ESatNotifyRetrieveMultimediaMsgPCmd:
+ return NotifyRetrieveMultimediaMsgPCmdCancel(aTsyReqHandle);
+ case ESatNotifySubmitMultimediaMsgPCmd:
+ return NotifySubmitMultimediaMsgPCmdCancel(aTsyReqHandle);
+ case ESatNotifyDisplayMultimediaMsgPCmd:
+ return NotifyDisplayMultimediaMsgPCmdCancel(aTsyReqHandle);
+ case ESatNotifySetFramesPCmd:
+ return NotifySetFramesPCmdCancel(aTsyReqHandle);
+ case ESatNotifyGetFramesStatusPCmd:
+ return NotifyGetFramesStatusPCmdCancel(aTsyReqHandle);
+ case ESatTerminalRsp:
+ return TerminalRspCancel(aTsyReqHandle);
+ case ESatGetMeSideSatProfile:
+ return GetMeSideSatProfileCancel(aTsyReqHandle);
+ case ESatMmsTransferStatus:
+ return MmsTransferStatusCancel(aTsyReqHandle);
+ case ESatMmsNotificationDownload:
+ return MmsNotificationDownloadCancel(aTsyReqHandle);
+ case ESatUssdDataDownload:
+ return UssdDataDownloadCancel(aTsyReqHandle);
+ case ESatNotifyLocalInfoPCmd:
+ return NotifyLocalInfoPCmdCancel(aTsyReqHandle);
+ case ESatNotifyOpenChannelPCmd:
+ return NotifyOpenChannelPCmdCancel(aTsyReqHandle);
+ case ESatNotifyPlayTonePCmd:
+ return NotifyPlayTonePCmdCancel(aTsyReqHandle);
+ case ESatNotifySetUpCallPCmd:
+ return NotifySetupCallPCmdCancel(aTsyReqHandle);
+ case ESatEventDownload:
+ return EventDownloadCancel(aTsyReqHandle);
+ case ESatNotifySendUssdPCmd:
+ return NotifySendUssdPCmdCancel(aTsyReqHandle);
+ case ESatNotifyGetInkeyPCmd:
+ return NotifyGetInkeyPCmdCancel(aTsyReqHandle);
+ case ESatNotifySendSsPCmd:
+ return NotifySendSsPCmdCancel(aTsyReqHandle);
+ case ESatNotifyLaunchBrowserPCmd:
+ return NotifyLaunchBrowserPCmdCancel(aTsyReqHandle);
+ default:
+ return KErrGeneral;
+ }
+ }
+
+
+TInt CSimSat::NotifyRefreshPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_REFRESH_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iSatInfo->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyRefresh.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+ RSat::TRefreshV1Pckg* refreshPckg = (RSat::TRefreshV1Pckg*)aPCmd;
+ RSat::TRefreshV1& refresh = (*refreshPckg)();
+
+
+ iNotifyRefresh.iNotifyPending=ETrue;
+ iNotifyRefresh.iNotifyHandle=aTsyReqHandle;
+ iNotifyRefresh.iNotifyData = &refresh;
+
+ if(refresh.iType == RSat::E3GSessionReset || refresh.iType == RSat::EFileChangeNotification)
+ {
+ RSat::TRefreshV2Pckg* refreshPckg = (RSat::TRefreshV2Pckg*)aPCmd;
+ RSat::TRefreshV2& refresh2 = (*refreshPckg)();
+
+ iNotifyRefresh.iNotifyData = &refresh2;
+ iRefreshV2 = ETrue;
+ }
+
+ return KErrNone;
+ }
+
+
+TInt CSimSat::NotifyRefreshPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iNotifyRefresh.iNotifyPending)
+ {
+ iNotifyRefresh.iNotifyPending=EFalse;
+ // 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
+ iRefreshRequiredPending=EFalse;
+ ReqCompleted(iNotifyRefresh.iNotifyHandle,KErrCancel);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyRefreshRequired(const TTsyReqHandle aTsyReqHandle)
+ {
+ if(iSatInfo->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iRefreshRequired.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+ iRefreshRequired.iNotifyPending=ETrue;
+ iRefreshRequired.iNotifyHandle=aTsyReqHandle;
+ iRefreshRequired.iNotifyData = NULL;
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyRefreshRequired(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+ if(iSatInfo->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iRefreshRequired.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+ RSat::TRefreshV1Pckg* refreshPckg = (RSat::TRefreshV1Pckg*)aPCmd;
+ RSat::TRefreshV1& refresh = (*refreshPckg)();
+
+ iRefreshRequired.iNotifyPending=ETrue;
+ iRefreshRequired.iNotifyHandle=aTsyReqHandle;
+ iRefreshRequired.iNotifyData = &refresh;
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyRefreshRequiredCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iRefreshRequired.iNotifyPending)
+ {
+ iRefreshRequired.iNotifyPending=EFalse;
+ iRefreshRequiredPending=EFalse;
+ ReqCompleted(iRefreshRequired.iNotifyHandle,KErrCancel);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::RefreshAllowed(const TTsyReqHandle aTsyReqHandle, TDes8* aRefreshAllowedRsp)
+ {
+ if(iSatInfo->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ RSat::TRefreshRspV1Pckg* aRspPckg = (RSat::TRefreshRspV1Pckg*)aRefreshAllowedRsp;
+ RSat::TRefreshRspV1& rspV1 = (*aRspPckg)();
+
+ LOGMISC2("RefreshAllowed: - aRefreshAllowedResult %d",rspV1.iGeneralResult);
+
+ /* Set simtsy status to reflect clients status */
+ RSat::TPCmdResult refreshAllowedResult = rspV1.iGeneralResult;
+
+ __ASSERT_ALWAYS(!iRefreshAllowed.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ ReqCompleted(aTsyReqHandle, KErrNone);
+
+ iRefreshAllowed.iNotifyPending=EFalse;
+
+ if(iRefreshRequiredPending && iNotifyRefresh.iNotifyPending && refreshAllowedResult == RSat::KSuccess)
+ {
+ iNotifyRefresh.iNotifyPending=EFalse;
+ iRefreshRequiredPending=EFalse;
+
+ RSat::TRefreshV1& refreshData = *(RSat::TRefreshV1*)iNotifyRefresh.iNotifyData;
+
+ refreshData.iType = iType;
+ refreshData.iFileList = iFileList;
+
+ ReqCompleted(iNotifyRefresh.iNotifyHandle, KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::RefreshAllowedCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iRefreshAllowed.iNotifyPending)
+ {
+ iRefreshAllowed.iNotifyPending=EFalse;
+ ReqCompleted(iRefreshAllowed.iNotifyHandle,KErrCancel);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyRetrieveMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_RET_MM_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ TRAP(err, ret = ConfigL(SIMTSY_SUB_MM_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!=KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ TRAP(err, ret = ConfigL(SIMTSY_ELEMFILES_CMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+ if(ret!=KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+ }
+ }
+
+ if(iMMRetrieve->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyRetrieveMM.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+
+ RSat::TRetrieveMultimediaMessageV6Pckg *aRspPckg = (RSat::TRetrieveMultimediaMessageV6Pckg*)aPCmd;
+ RSat::TRetrieveMultimediaMessageV6& rspRetMM = (*aRspPckg)();
+
+ iNotifyRetrieveMM.iNotifyPending=ETrue;
+ iNotifyRetrieveMM.iNotifyHandle=aTsyReqHandle;
+ iNotifyRetrieveMM.iNotifyData = &rspRetMM;
+
+ iRefreshEf= ETrue;
+
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifyRetrieveMultimediaMsgPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+
+ if(iNotifyRetrieveMM.iNotifyPending)
+ {
+ iNotifyRetrieveMM.iNotifyPending=EFalse;
+ ReqCompleted(iNotifyRetrieveMM.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyRetrieveMM.iNotifyHandle,KErrNone);
+ }
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifyLaunchBrowserPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_LNCH_BRWSR_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ TRAP(err, ret = ConfigL(SIMTSY_EVENT_LIST_CMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret != KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+ }
+
+ if(iLnchBrwsr->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyLnchBrwsr.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TLaunchBrowserV6Pckg *aRspPckg = (RSat::TLaunchBrowserV6Pckg*)aPCmd;
+ RSat::TLaunchBrowserV6& rspLncBrwsr = (*aRspPckg)();
+
+ iNotifyLnchBrwsr.iNotifyPending=ETrue;
+ iNotifyLnchBrwsr.iNotifyHandle=aTsyReqHandle;
+ iNotifyLnchBrwsr.iNotifyData = &rspLncBrwsr;
+
+ if(!iRefreshEf)
+ {
+ iRefreshEf= ETrue;
+ }
+
+ return KErrNone;
+
+ }
+
+
+TInt CSimSat::NotifyLaunchBrowserPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+
+ if(iNotifyLnchBrwsr.iNotifyPending)
+ {
+ iNotifyLnchBrwsr.iNotifyPending=EFalse;
+ ReqCompleted(iNotifyLnchBrwsr.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyLnchBrwsr.iNotifyHandle,KErrNone);
+ }
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifySubmitMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_SUB_MM_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ TRAP(err, ret = ConfigL(SIMTSY_ELEMFILES_CMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!=KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+ }
+
+ if(iMMSubmit->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifySubmitMM.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TSubmitMultimediaMessageV6Pckg *aRspPckg = (RSat::TSubmitMultimediaMessageV6Pckg*)aPCmd;
+ RSat::TSubmitMultimediaMessageV6& rspRetMM = (*aRspPckg)();
+
+ iNotifySubmitMM.iNotifyPending=ETrue;
+ iNotifySubmitMM.iNotifyHandle=aTsyReqHandle;
+ iNotifySubmitMM.iNotifyData = &rspRetMM;
+
+ if(!iRefreshEf)
+ {
+ iRefreshEf= ETrue;
+ }
+
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifySubmitMultimediaMsgPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+
+ if(iNotifySubmitMM.iNotifyPending)
+ {
+ iNotifySubmitMM.iNotifyPending=EFalse;
+ ReqCompleted(iNotifySubmitMM.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifySubmitMM.iNotifyHandle,KErrNone);
+ }
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifyDisplayMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_DISP_MM_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iMMDisplay->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyDisplayMM.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TDisplayMultimediaMessageV6Pckg *aRspPckg = (RSat::TDisplayMultimediaMessageV6Pckg*)aPCmd;
+ RSat::TDisplayMultimediaMessageV6& rspRetMM = (*aRspPckg)();
+
+ iNotifyDisplayMM.iNotifyPending=ETrue;
+ iNotifyDisplayMM.iNotifyHandle=aTsyReqHandle;
+ iNotifyDisplayMM.iNotifyData = &rspRetMM;
+
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifyDisplayMultimediaMsgPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+
+ if(iNotifyDisplayMM.iNotifyPending)
+ {
+ iNotifyDisplayMM.iNotifyPending=EFalse;
+ ReqCompleted(iNotifyDisplayMM.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyDisplayMM.iNotifyHandle,KErrNone);
+ }
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifySetFramesPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_SET_FRMS_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iSetFrms->Count() == 0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifySetFrms.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TSetFramesV6Pckg *aRspPckg = (RSat::TSetFramesV6Pckg*)aPCmd;
+ RSat::TSetFramesV6& rspSetFrmsV6 = (*aRspPckg)();
+
+ iNotifySetFrms.iNotifyPending=ETrue;
+ iNotifySetFrms.iNotifyHandle=aTsyReqHandle;
+ iNotifySetFrms.iNotifyData = &rspSetFrmsV6;
+
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifySetFramesPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+
+ if(iNotifySetFrms.iNotifyPending)
+ {
+ iNotifySetFrms.iNotifyPending=EFalse;
+ ReqCompleted(iNotifySetFrms.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifySetFrms.iNotifyHandle,KErrNone);
+ }
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifyGetFramesStatusPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_GET_FRMS_STS_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iGetFrmsSts->Count() == 0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyGetFrmsSts.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TGetFramesStatusV6Pckg *aRspPckg = (RSat::TGetFramesStatusV6Pckg*)aPCmd;
+ RSat::TGetFramesStatusV6& rspGetFrmsV6 = (*aRspPckg)();
+
+ iNotifyGetFrmsSts.iNotifyPending = ETrue;
+ iNotifyGetFrmsSts.iNotifyHandle = aTsyReqHandle;
+ iNotifyGetFrmsSts.iNotifyData = &rspGetFrmsV6;
+
+ return KErrNone;
+
+ }
+
+TInt CSimSat::NotifyGetFramesStatusPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+
+ if(iNotifyGetFrmsSts.iNotifyPending)
+ {
+ iNotifyGetFrmsSts.iNotifyPending=EFalse;
+ ReqCompleted(iNotifyGetFrmsSts.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyGetFrmsSts.iNotifyHandle,KErrNone);
+ }
+
+ return KErrNone;
+
+ }
+
+TInt CSimSat::UssdDataDownload(const TTsyReqHandle aTsyReqHandle, TDes8* aDes)
+ {
+ // Has the config file been parsed for this functionality
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_USSD_CMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ TInt err(KErrNone);
+ TBool found(EFalse);
+ TInt count(iUssdData->Count());
+
+ // If the config file does not contain any USSD Download related data
+ // then complete the request with KErrNotSupported
+ if(!count)
+ {
+ err = KErrNotSupported;
+ }
+ else
+ {
+ // otherwise extract the data supplied by the client
+ RSat::TUssdDataDownloadV6Pckg *ussdDataV6Pckg = (RSat::TUssdDataDownloadV6Pckg*)aDes;
+ RSat::TUssdDataDownloadV6& ussdDataV6 = (*ussdDataV6Pckg)();
+
+ for(TInt i=0; i<count; i++)
+ {
+ TUssdData tempUssdData = iUssdData->At(i);
+
+ // Compare the supplied data to the data retrieved from the config file
+ // and proceed only if they match
+ if((ussdDataV6.iDeviceId == STATIC_CAST(RSat::TDeviceId, tempUssdData.iSrc)) &&
+ (ussdDataV6.iUssdString.iDcs == tempUssdData.iDcs) &&
+ (ussdDataV6.iUssdString.iUssdString.Compare(tempUssdData.iUssdStr) == 0))
+ {
+ found = ETrue;
+
+ if(tempUssdData.iUICCRsp == SIMTSY_UICC_SUCC_RSP)
+ {
+ err = KErrNone;
+ }
+ else if(tempUssdData.iUICCRsp == SIMTSY_UICC_RETRY_RSP)
+ {
+ err = KErrNotReady;
+ }
+ else if(tempUssdData.iUICCRsp == SIMTSY_UICC_FLR_RSP_1 ||
+ tempUssdData.iUICCRsp == SIMTSY_UICC_FLR_RSP_2)
+ {
+ err = KErrNotSupported;
+ }
+
+ iUSSDDataDownloadHandle = aTsyReqHandle;
+ break;
+ }
+ } // end for loop
+ } // end else
+
+ // the supplied data does not match the one in the config file, so complete the request with an error
+ if(!found)
+ err = KErrCorrupt;
+
+ ReqCompleted(aTsyReqHandle, err);
+ return KErrNone;
+ }
+
+
+TInt CSimSat::UssdDataDownloadCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ if(iUSSDDataDownloadHandle == aTsyReqHandle)
+ {
+ ReqCompleted(aTsyReqHandle, KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle, KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyLocalInfoPCmd(const TTsyReqHandle aTsyReqHandle,TDes8* aPCmd)
+ {
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_PRV_LCL_INFO_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iLocalInfo->Count() == 0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ RSat::TLocalInfoV6Pckg *aRspPckg = (RSat::TLocalInfoV6Pckg*)aPCmd;
+ RSat::TLocalInfoV6& rspLocalInfo = (*aRspPckg)();
+
+ iNotifyLocalInfo.iNotifyPending = ETrue;
+ iNotifyLocalInfo.iNotifyHandle = aTsyReqHandle;
+ iNotifyLocalInfo.iNotifyData = &rspLocalInfo;
+
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyLocalInfoPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+{
+ if(iNotifyLocalInfo.iNotifyPending)
+ {
+ iNotifyLocalInfo.iNotifyPending= EFalse;
+ ReqCompleted(iNotifyLocalInfo.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyLocalInfo.iNotifyHandle,KErrNone);
+ }
+ return KErrNone;
+}
+
+
+TInt CSimSat::NotifyOpenChannelPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_OPEN_CHAN_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iOpenChn->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyOpenChn.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+ RSat::TOpenLocalLinksChannelV5Pckg* opnChnPckg = (RSat::TOpenLocalLinksChannelV5Pckg*)aPCmd;
+ RSat::TOpenLocalLinksChannelV5 & opnChn = (*opnChnPckg)();
+
+ iNotifyOpenChn.iNotifyPending=ETrue;
+ iNotifyOpenChn.iNotifyHandle=aTsyReqHandle;
+ iNotifyOpenChn.iNotifyData = &opnChn;
+ return KErrNone;
+ }
+
+
+TInt CSimSat::NotifyOpenChannelPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iNotifyOpenChn.iNotifyPending)
+ {
+ iNotifyOpenChn.iNotifyPending= EFalse;
+ ReqCompleted(iNotifyOpenChn.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyOpenChn.iNotifyHandle,KErrNone);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyPlayTonePCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_PLAY_TONE_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iMiscCmd->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+ if(!iPlayTone)
+ {
+ iPlayTone = ETrue;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyMiscCmd.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TPlayToneV6Pckg* playTonePckg = (RSat::TPlayToneV6Pckg*)aPCmd;
+ RSat::TPlayToneV6& playTone = (*playTonePckg)();
+
+ iNotifyMiscCmd.iNotifyPending=ETrue;
+ iNotifyMiscCmd.iNotifyHandle=aTsyReqHandle;
+ iNotifyMiscCmd.iNotifyData = &playTone;
+ return KErrNone;
+ }
+
+
+TInt CSimSat::NotifyPlayTonePCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iNotifyMiscCmd.iNotifyPending)
+ {
+ iNotifyMiscCmd.iNotifyPending= EFalse;
+ iMiscCmdIndex ++;
+ ReqCompleted(iNotifyMiscCmd.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyMiscCmd.iNotifyHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifySetupCallPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_SETUP_CALL_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iMiscCmd->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ if(!iPlayTone && !iSetupCall)
+ {
+ iMiscCmdIndex += SIMTSY_PLAYTONE_TESTCASES_NUMBER;
+ }
+
+ if(!iSetupCall)
+ {
+ iSetupCall = ETrue;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyMiscCmd.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TSetUpCallV6Pckg* setupCallPckg = (RSat::TSetUpCallV6Pckg*)aPCmd;
+ RSat::TSetUpCallV6& setupCall = (*setupCallPckg)();
+
+ iNotifyMiscCmd.iNotifyPending=ETrue;
+ iNotifyMiscCmd.iNotifyHandle=aTsyReqHandle;
+ iNotifyMiscCmd.iNotifyData = &setupCall;
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifySetupCallPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iNotifyMiscCmd.iNotifyPending)
+ {
+ iNotifyMiscCmd.iNotifyPending= EFalse;
+ iMiscCmdIndex ++;
+ ReqCompleted(iNotifyMiscCmd.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyMiscCmd.iNotifyHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+
+TInt CSimSat::NotifyGetInkeyPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_GET_INKEY_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ TRAP(err, ret = ConfigL(SIMTSY_SENDSS_CMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret != KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+ }
+
+ if(iMiscCmd->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ if(!iGetInkey)
+ {
+ iMiscCmdIndex += (SIMTSY_PLAYTONE_TESTCASES_NUMBER + SIMTSY_SETUPCALL_TESTCASES_NUMBER);
+ iGetInkey = ETrue;
+ }
+
+ __ASSERT_ALWAYS(!iNotifyMiscCmd.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TGetInkeyV6Pckg* getInkeyPckg = (RSat::TGetInkeyV6Pckg*)aPCmd;
+ RSat::TGetInkeyV6& getInkey = (*getInkeyPckg)();
+
+ iNotifyMiscCmd.iNotifyPending=ETrue;
+ iNotifyMiscCmd.iNotifyHandle=aTsyReqHandle;
+ iNotifyMiscCmd.iNotifyData = &getInkey;
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifyGetInkeyPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iNotifyMiscCmd.iNotifyPending)
+ {
+ iNotifyMiscCmd.iNotifyPending= EFalse;
+ iMiscCmdIndex ++;
+ ReqCompleted(iNotifyMiscCmd.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifyMiscCmd.iNotifyHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifySendSsPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+
+ if(iSendSS->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifySendSs.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TSendSsV6Pckg *sendSsV6Pckg = (RSat::TSendSsV6Pckg*)aPCmd;
+ RSat::TSendSsV6 & sendSsV6 = (*sendSsV6Pckg)();
+
+ iNotifySendSs.iNotifyPending=ETrue;
+ iNotifySendSs.iNotifyHandle=aTsyReqHandle;
+ iNotifySendSs.iNotifyData = &sendSsV6;
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifySendSsPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iNotifySendSs.iNotifyPending)
+ {
+ iNotifySendSs.iNotifyPending= EFalse;
+ iSendSsIndex++;
+ ReqCompleted(iNotifySendSs.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifySendSs.iNotifyHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifySendUssdPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_SEND_USSD_PCMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ if(iSendUssd->Count()==0)
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+ __ASSERT_ALWAYS(!iNotifySendUssd.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+
+ RSat::TSendUssdV6Pckg* sendUSSDPckg = (RSat::TSendUssdV6Pckg*)aPCmd;
+ RSat::TSendUssdV6& sendUSSD = (*sendUSSDPckg)();
+
+ iNotifySendUssd.iNotifyPending=ETrue;
+ iNotifySendUssd.iNotifyHandle=aTsyReqHandle;
+ iNotifySendUssd.iNotifyData = &sendUSSD;
+ return KErrNone;
+ }
+
+TInt CSimSat::NotifySendUssdPCmdCancel(const TTsyReqHandle /*aTsyReqHandle*/)
+ {
+ if(iNotifySendUssd.iNotifyPending)
+ {
+ iNotifySendUssd.iNotifyPending= EFalse;
+ iSendUssdIndex ++;
+ ReqCompleted(iNotifySendUssd.iNotifyHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(iNotifySendUssd.iNotifyHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::TerminalRsp(const TTsyReqHandle aTsyReqHandle, RSat::TPCmd* aPCmd, TDes8* aRsp)
+{
+ LOGMISC1(">>CSimSat::TerminalRsp");
+ iPendingTerRsp = ETrue;
+
+ switch (*aPCmd)
+ {
+ case RSat::ERetrieveMultimediaMsg:
+ return RetrieveMultimediaRsp(aTsyReqHandle, aRsp);
+ case RSat::ESubmitMultimediaMsg:
+ return SubmitMultimediaRsp(aTsyReqHandle, aRsp);
+ case RSat::EDisplayMultimediaMsg:
+ return DisplayMultimediaRsp(aTsyReqHandle, aRsp);
+ case RSat::ESetFrames:
+ return SetFramesRsp(aTsyReqHandle,aRsp);
+ case RSat::EGetFramesStatus:
+ return GetFramesStatusRsp(aTsyReqHandle,aRsp);
+ case RSat::ELocalInfo:
+ return ProvideLocalInfoRsp(aTsyReqHandle,aRsp);
+ case RSat::EOpenChannelGprs:
+ case RSat::EOpenChannelLocal:
+ case RSat::ECloseChannel:
+ return OpenChannelRsp(aTsyReqHandle,aRsp);
+ case RSat::EPlayTone:
+ return PlayToneRsp(aTsyReqHandle,aRsp);
+ case RSat::ESetUpCall:
+ return SetupCallRsp(aTsyReqHandle,aRsp);
+ case RSat::ERefresh:
+ return RefreshRsp(aTsyReqHandle,aRsp);
+ case RSat::ESendUssd:
+ return SendUssdRsp(aTsyReqHandle,aRsp);
+ case RSat::EGetInkey:
+ return GetInkeyRsp(aTsyReqHandle,aRsp);
+ case RSat::ELaunchBrowser:
+ return LaunchBrowserRsp(aTsyReqHandle,aRsp);
+ default:
+ iPendingTerRsp = EFalse;
+ return KErrGeneral;
+ }
+}
+
+TInt CSimSat::TerminalRspCancel(const TTsyReqHandle aTsyReqHandle)
+{
+ if(iPendingTerRsp)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ return KErrNone;
+}
+
+
+void CSimSat::TimerCallBack(TInt /*aId*/)
+/**
+* Timer callback function. When the timer goes off, it will call back into this
+* function for further processing.
+*
+* @param aId an id identifying which timer callback is being called
+*/
+ {
+ LOGMISC1(">>CSimSat::TimerCallBack");
+
+ //
+ // Convert the SIM TSY text version into the RSat binary version...
+ //
+ /* Obtain type and file list if present and cache for completion by Refresh Allowed */
+ if(iSatIndex < iSatInfo->Count() & !(iRefreshEf))
+ {
+ iType = STATIC_CAST(RSat::TRefreshType,iSatInfo->At(iSatIndex).iType);
+ iConvertTextToFileReturnCode = ConvertTextToFileList(iSatInfo->At(iSatIndex).iFileList,
+ iFileList);
+ iSatIndex++;
+ }
+
+ // Only process NotifyRefreshPCmd here if not enclosed in RefreshRequired cycle
+ if(iNotifyRefresh.iNotifyPending && !iRefreshRequired.iNotifyPending)
+ {
+ iNotifyRefresh.iNotifyPending=EFalse;
+
+ RSat::TRefreshV1& refreshData = *(RSat::TRefreshV1*)iNotifyRefresh.iNotifyData;
+
+ refreshData.iType = iType;
+ refreshData.iFileList = iFileList;
+
+ if(iRefreshV2)
+ {
+ RSat::TRefreshV2& refresh2 = *(RSat::TRefreshV2*)iNotifyRefresh.iNotifyData;
+ refresh2.iType = STATIC_CAST(RSat::TRefreshType,iRefresh->At(iRefreshIndex).iType);
+ ConvertTextToTBuf16(iRefresh->At(iRefreshIndex).iFileList,refresh2.iAid);
+ iRefreshIndex++;
+ }
+
+ if(iRefreshEf)
+ {
+ refreshData.iType = STATIC_CAST(RSat::TRefreshType,iElemFiles->At(iElemFilesIndex).iType);
+ ConvertTextToFileList(iElemFiles->At(iElemFilesIndex).iFileList,refreshData.iFileList);
+ iElemFilesIndex++;
+ }
+
+ ReqCompleted(iNotifyRefresh.iNotifyHandle, iConvertTextToFileReturnCode);
+ }
+
+ if(iRefreshRequired.iNotifyPending)
+ {
+ if (iConvertTextToFileReturnCode == KErrNone)
+ {
+ iRefreshRequired.iNotifyPending=EFalse;
+ iRefreshRequiredPending = ETrue;
+
+ if (iRefreshRequired.iNotifyData != NULL)
+ {
+ RSat::TRefreshV1& refreshData = *(RSat::TRefreshV1*)iRefreshRequired.iNotifyData;
+
+ refreshData.iType = iType;
+ refreshData.iFileList = iFileList;
+ }
+ }
+
+ ReqCompleted(iRefreshRequired.iNotifyHandle, iConvertTextToFileReturnCode);
+ }
+
+ if(iNotifyRetrieveMM.iNotifyPending)
+ {
+
+ RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = (RSat::TRetrieveMultimediaMessageV6*)iNotifyRetrieveMM.iNotifyData;
+
+ tMMMessageV6->iDestination = STATIC_CAST(RSat::TDeviceId,iMMRetrieve->At(iRetIndex).iDestn);
+ tMMMessageV6->iAlphaId.iStatus = STATIC_CAST(RSat::TAlphaIdStatus,iMMRetrieve->At(iRetIndex).iAlphaStatus);
+
+ ConvertTextToTBuf254(iMMRetrieve->At(iRetIndex).iAlphaIDBuf,tMMMessageV6->iAlphaId.iAlphaId);
+
+ tMMMessageV6->iIconId.iQualifier = STATIC_CAST(RSat::TIconQualifier,iMMRetrieve->At(iRetIndex).iIconID);
+ tMMMessageV6->iIconId.iIdentifier = STATIC_CAST(TUint8,iMMRetrieve->At(iRetIndex).iIconIDBuf);
+
+ ConvertTextToTBuf255(iMMRetrieve->At(iRetIndex).iMMMsgRef,tMMMessageV6->iMultimediaMessageRef);
+ ConvertTextToTBuf242(iMMRetrieve->At(iRetIndex).iRcptnFile,tMMMessageV6->iReceptionFile);
+ ConvertTextToTBuf255(iMMRetrieve->At(iRetIndex).iContentId,tMMMessageV6->iMultimediaContentId);
+ ConvertTextToTBuf255(iMMRetrieve->At(iRetIndex).iMsgId,tMMMessageV6->iMultimediaMessageId);
+
+ tMMMessageV6->iTextAttribute.iStatus = STATIC_CAST(RSat::TTextAttributeStatus, iMMRetrieve->At(iRetIndex).iTextAttStatus);
+
+ ConvertTextToTBuf4(iMMRetrieve->At(iRetIndex).iTextAttBuf,tMMMessageV6->iTextAttribute.iTextAttributeData);
+
+ iNotifyRetrieveMM.iNotifyPending = EFalse;
+ if(iRetIndex < iMMRetrieve->Count())
+ {
+ iRetTIndex = iRetIndex;
+ iRetIndex++;
+ }
+
+ ReqCompleted(iNotifyRetrieveMM.iNotifyHandle, KErrNone);
+
+ }
+
+ if(iNotifySubmitMM.iNotifyPending)
+ {
+
+ RSat::TSubmitMultimediaMessageV6 *tMMMessageV6 = (RSat::TSubmitMultimediaMessageV6*)iNotifySubmitMM.iNotifyData;
+
+
+ tMMMessageV6->iDestination = STATIC_CAST(RSat::TDeviceId,iMMSubmit->At(iSubIndex).iDestn);
+ tMMMessageV6->iAlphaId.iStatus = STATIC_CAST(RSat::TAlphaIdStatus,iMMSubmit->At(iSubIndex).iAlphaStatus);
+
+ ConvertTextToTBuf254(iMMSubmit->At(iSubIndex).iAlphaIDBuf,tMMMessageV6->iAlphaId.iAlphaId);
+
+ tMMMessageV6->iIconId.iQualifier = STATIC_CAST(RSat::TIconQualifier,iMMSubmit->At(iSubIndex).iIconID);
+ tMMMessageV6->iIconId.iIdentifier = STATIC_CAST(TUint8,iMMSubmit->At(iSubIndex).iIconIDBuf);
+
+ ConvertTextToTBuf242(iMMSubmit->At(iSubIndex).iSbmsnFile,tMMMessageV6->iSubmissionFile);
+ ConvertTextToTBuf255(iMMSubmit->At(iSubIndex).iMsgId,tMMMessageV6->iMultimediaMessageId);
+
+ tMMMessageV6->iTextAttribute.iStatus = STATIC_CAST(RSat::TTextAttributeStatus, iMMSubmit->At(iSubIndex).iTextAttStatus);
+
+ ConvertTextToTBuf4(iMMSubmit->At(iSubIndex).iTextAttBuf,tMMMessageV6->iTextAttribute.iTextAttributeData);
+
+ iNotifySubmitMM.iNotifyPending = EFalse;
+
+ if(iSubIndex < iMMSubmit->Count())
+ {
+ iSubTIndex = iSubIndex;
+ iSubIndex++;
+ }
+
+ ReqCompleted(iNotifySubmitMM.iNotifyHandle, KErrNone);
+
+ }
+
+ if(iNotifyDisplayMM.iNotifyPending)
+ {
+
+ RSat::TDisplayMultimediaMessageV6 *tMMMessageV6 = (RSat::TDisplayMultimediaMessageV6*)iNotifyDisplayMM.iNotifyData;
+
+
+ tMMMessageV6->iDestination = STATIC_CAST(RSat::TDeviceId,iMMDisplay->At(iDispIndex).iDestn);
+ tMMMessageV6->iDisplayPriority = STATIC_CAST(RSat::TDisplayPriority,iMMDisplay->At(iDispIndex).iDispPri);
+ tMMMessageV6->iClearScreenTrigger = STATIC_CAST(RSat::TClearScreenTrigger,iMMDisplay->At(iDispIndex).iClrScr);
+
+
+ ConvertTextToTBuf242(iMMDisplay->At(iDispIndex).iSbmsnFile,tMMMessageV6->iSubmissionFile);
+ ConvertTextToTBuf255(iMMDisplay->At(iDispIndex).iMsgId,tMMMessageV6->iMultimediaMessageId);
+ tMMMessageV6->iImmediateRsp = STATIC_CAST(RSat::TImmediateRsp,iMMDisplay->At(iDispIndex).iImmRsp);
+
+ iNotifyDisplayMM.iNotifyPending = EFalse;
+
+ if(iDispIndex < iMMDisplay->Count())
+ {
+ iDispTIndex = iDispIndex;
+ iDispIndex++;
+ }
+
+ ReqCompleted(iNotifyDisplayMM.iNotifyHandle, KErrNone);
+
+ }
+ if(iNotifySetFrms.iNotifyPending)
+ {
+ RSat::TSetFramesV6 *tSetFramesV6 = (RSat::TSetFramesV6*)iNotifySetFrms.iNotifyData;
+
+ tSetFramesV6->iDestination = STATIC_CAST(RSat::TDeviceId,iSetFrms->At(iSetFrmsIndex).iDestn);
+ tSetFramesV6->iFrameId = iSetFrms->At(iSetFrmsIndex).iFrmId;
+ tSetFramesV6->iFrameLayout.iFramesLayout = STATIC_CAST(RSat::TFramesLayout,iSetFrms->At(iSetFrmsIndex).iFrmLayout);
+
+ ConvertTextToTBuf243(iSetFrms->At(iSetFrmsIndex).iFrmLayoutBuf,tSetFramesV6->iFrameLayout.iFrameLayoutBuf);
+
+ tSetFramesV6->iDefaultFrameId = iSetFrms->At(iSetFrmsIndex).iDefFrmId;
+ tSetFramesV6->iFramesSeparator = STATIC_CAST(RSat::TFramesSeparator,iSetFrms->At(iSetFrmsIndex).iFrmSeparator);
+
+ iNotifySetFrms.iNotifyPending = EFalse;
+
+ if(iSetFrmsIndex < iSetFrms->Count())
+ {
+ iSetFrmsIndex++;
+ }
+
+ ReqCompleted(iNotifySetFrms.iNotifyHandle, KErrNone);
+ }
+
+ if(iNotifyGetFrmsSts.iNotifyPending)
+ {
+ RSat::TGetFramesStatusV6 *tGetFramesV6 = (RSat::TGetFramesStatusV6*) iNotifyGetFrmsSts.iNotifyData;
+
+ tGetFramesV6->iDestination = STATIC_CAST(RSat::TDeviceId,iGetFrmsSts->At(iGetFrmsStsIndex).iDestn);
+
+ iNotifyGetFrmsSts.iNotifyPending = EFalse;
+
+ if(iGetFrmsStsIndex < iGetFrmsSts->Count())
+ {
+ iGetFrmsStsIndex++;
+ }
+
+ ReqCompleted(iNotifyGetFrmsSts.iNotifyHandle,KErrNone);
+ }
+
+ if(iNotifyLnchBrwsr.iNotifyPending)
+ {
+ RSat::TLaunchBrowserV6 *tLnchBrwsr = (RSat::TLaunchBrowserV6*)iNotifyLnchBrwsr.iNotifyData;
+
+ tLnchBrwsr->iFrameId = iLnchBrwsr->At(iLnchBrwsrIndex).iFrameId;
+
+ iNotifyLnchBrwsr.iNotifyPending = EFalse;
+
+ if(iLnchBrwsrIndex < iLnchBrwsr->Count())
+ {
+ iLnchBrwsrIndex++;
+ }
+
+ ReqCompleted(iNotifyLnchBrwsr.iNotifyHandle,KErrNone);
+ }
+
+
+ if(iNotifyLocalInfo.iNotifyPending)
+ {
+ RSat::TLocalInfoV6 *tLocal = (RSat::TLocalInfoV6*)iNotifyLocalInfo.iNotifyData;
+
+ if(iLocalInfoIndex == 2)
+ {
+ iLocalInfoIndex ++;
+ }
+
+ tLocal->iDevideId =
+ STATIC_CAST(RSat::TDeviceId,iLocalInfo->At(iLocalInfoIndex).iDeviceId);
+ tLocal->iInfoType =
+ STATIC_CAST(RSat::TLocaInfomationType,iLocalInfo->At(iLocalInfoIndex).iLocalInfoType);
+ tLocal->iUtranMeasurementQualifier =
+ STATIC_CAST(RSat::TUtranMeasurementQualifier,iLocalInfo->At(iLocalInfoIndex).iUTRANQlfr);
+
+ iNotifyLocalInfo.iNotifyPending = EFalse;
+
+ if(iLocalInfoIndex< iLocalInfo->Count())
+ {
+ iLocalInfoIndex++;
+ }
+
+ if(iLocalInfoIndex == 1 || iLocalInfoIndex == 4 )
+ {
+ ReqCompleted(iNotifyLocalInfo.iNotifyHandle,KErrNone);
+ }
+ if(iLocalInfoIndex == 2 || iLocalInfoIndex == 5 || iLocalInfoIndex == 6)
+ {
+ ReqCompleted(iNotifyLocalInfo.iNotifyHandle,KErrNotSupported);
+ }
+ else
+ {
+ ReqCompleted(iNotifyLocalInfo.iNotifyHandle,KErrCorrupt);
+ }
+ }
+
+ if(iNotifyOpenChn.iNotifyPending)
+ {
+ RSat::TOpenLocalLinksChannelV5 *tOpenChannel = (RSat::TOpenLocalLinksChannelV5*) iNotifyOpenChn.iNotifyData;
+
+ tOpenChannel->iBearer.iType = STATIC_CAST(RSat::TBearerType,iOpenChn->At(iOpenChnIndex).iBearerType);
+
+ iNotifyOpenChn.iNotifyPending = EFalse;
+
+ if(iOpenChnIndex < iOpenChn->Count())
+ {
+ }
+
+ ReqCompleted(iNotifyOpenChn.iNotifyHandle,KErrNone);
+ }
+
+ if((iEventDnldHandle) && iEventDnldIndex <= iEventList->Count())
+ {
+ if(iSendRspEventDnld )
+ {
+ ReqCompleted(iEventDnldHandle,KErrNone);
+ }
+ else
+ {
+ ReqCompleted(iEventDnldHandle,KErrCorrupt);
+ }
+ }
+
+ if(iNotifySendUssd.iNotifyPending)
+ {
+
+ RSat::TSendUssdV6 *tSendUssd = (RSat::TSendUssdV6*)iNotifySendUssd.iNotifyData;
+
+ tSendUssd->iTextAttribute.iStatus = STATIC_CAST(RSat::TTextAttributeStatus,iSendUssd->At(iSendUssdIndex).iTextAttStatus);
+
+ ConvertTextToTBuf4(iSendUssd->At(iSendUssdIndex).iTextAttBuf,tSendUssd->iTextAttribute.iTextAttributeData);
+
+ iNotifySendUssd.iNotifyPending = EFalse;
+
+ if(iSendUssdIndex < iSendUssd->Count())
+ {
+ iSendUssdIndex++;
+ }
+
+ ReqCompleted(iNotifySendUssd.iNotifyHandle,KErrNone);
+ }
+
+ if(iNotifyMiscCmd.iNotifyPending)
+ {
+ if((iPlayTone) && (iMiscCmdIndex < SIMTSY_PLAYTONE_TESTCASES_NUMBER))
+ {
+ RSat::TPlayToneV6* tPlayTone = (RSat::TPlayToneV6*)iNotifyMiscCmd.iNotifyData;
+
+ tPlayTone->iFrameId = iMiscCmd->At(iMiscCmdIndex).iFrameId;
+ }
+ else if((iSetupCall) && (iMiscCmdIndex < (SIMTSY_SETUPCALL_TESTCASES_NUMBER + SIMTSY_PLAYTONE_TESTCASES_NUMBER)))
+ {
+ RSat::TSetUpCallV6* tSetupCall = (RSat::TSetUpCallV6*)iNotifyMiscCmd.iNotifyData;
+
+ tSetupCall->iFrameId = iMiscCmd->At(iMiscCmdIndex).iFrameId;
+ }
+ else if(iMiscCmdIndex < iMiscCmd->Count())
+ {
+ RSat::TGetInkeyV6* tGetInkey = (RSat::TGetInkeyV6*)iNotifyMiscCmd.iNotifyData;
+
+ tGetInkey->iFrameId = iMiscCmd->At(iMiscCmdIndex).iFrameId;
+ }
+
+ iNotifyMiscCmd.iNotifyPending = EFalse;
+
+ if(iMiscCmdIndex < iMiscCmd->Count())
+ {
+ iMiscCmdIndex ++;
+ }
+
+ ReqCompleted(iNotifyMiscCmd.iNotifyHandle,KErrNone);
+ }
+
+
+ if(iNotifySendSs.iNotifyPending)
+ {
+ RSat::TSendSsV6 *tSendSs = (RSat::TSendSsV6*)iNotifySendSs.iNotifyData;
+ tSendSs->iTextAttribute.iStatus= STATIC_CAST(RSat::TTextAttributeStatus,iSendSS->At(iSendSsIndex).iTextAttStatus);
+
+ ConvertTextToTBuf4(iSendSS->At(iSendSsIndex).iTextAttBuf,tSendSs->iTextAttribute.iTextAttributeData);
+
+ iNotifySendSs.iNotifyPending = EFalse;
+
+ if(iSendSsIndex < iSendSS->Count())
+ {
+ iSendSsIndex++;
+ }
+
+ ReqCompleted(iNotifySendSs.iNotifyHandle,KErrNone);
+ }
+
+
+ if(iSatIndex < iSatInfo->Count())
+ {
+ iTimer->Start(iSatInfo->At(iSatIndex).iDuration,this);
+ }
+ else
+ {
+ iTimer->Start(randTime(),this);
+ }
+
+ LOGMISC1("<<CSimSat::TimerCallBack");
+ }
+
+
+const CTestConfigSection* CSimSat::CfgFile()
+/**
+ * Returns a pointer to the current configuration file section.
+ *
+ * @return CTestConfigSection A pointer to the current configuration file section.
+ */
+ {
+ return iPhone->CfgFile();
+ }
+
+TInt CSimSat::ConvertTextToTBuf242(const TPtrC8& aText,
+ TBuf<242>& aFileList) const
+/**
+* Converts a text based file list (e.g. "6F3A6F3B") to a binary file list (e.g
+* {0x6f3a, 0x6f3b}).
+*
+* @param aText Text string to convert.
+* @param aFileList Returned file list.
+* @return Error code KErrNone if request completes ok. Otherwise a relevant error
+* code.
+*/
+ {
+ aFileList.Zero();
+
+ //
+ // Go through the string and take upto 4 characters at a time. Convert each set
+ // from hexidecimal to an integer and then append them to the file list.
+ //
+ TInt position(0);
+
+ while (position < aText.Length())
+ {
+ TInt numberLength(4);
+
+ if (aText.Length() - position < 4)
+ {
+ numberLength = aText.Length() - position;
+ }
+
+ TLex8 token(aText.Mid(position, numberLength));
+ TUint value;
+ TInt ret;
+
+ ret = token.Val(value, EHex);
+ if (ret != KErrNone)
+ {
+ aFileList.Zero();
+ return(ret);
+ }
+
+ aFileList.Append(value);
+ position +=4;
+ }
+
+ return(KErrNone);
+}
+
+TInt CSimSat::ConvertTextToTBuf243(const TPtrC8& aText,
+ TBuf<243>& aFileList) const
+/**
+* Converts a text based file list (e.g. "6F3A6F3B") to a binary file list (e.g
+* {0x6f3a, 0x6f3b}).
+*
+* @param aText Text string to convert.
+* @param aFileList Returned file list.
+* @return Error code KErrNone if request completes ok. Otherwise a relevant error
+* code.
+*/
+ {
+ aFileList.Zero();
+
+ //
+ // Go through the string and take upto 4 characters at a time. Convert each set
+ // from hexidecimal to an integer and then append them to the file list.
+ //
+ TInt position(0);
+
+ while (position < aText.Length())
+ {
+ TInt numberLength(4);
+
+ if (aText.Length() - position < 4)
+ {
+ numberLength = aText.Length() - position;
+ }
+
+ TLex8 token(aText.Mid(position, numberLength));
+ TUint value;
+ TInt ret;
+
+ ret = token.Val(value, EHex);
+ if (ret != KErrNone)
+ {
+ aFileList.Zero();
+ return(ret);
+ }
+
+ aFileList.Append(value);
+ position +=4;
+ }
+
+ return(KErrNone);
+}
+
+
+TInt CSimSat::ConvertTextToTBuf254(const TPtrC8& aText,
+ TBuf<254>& aFileList) const
+/**
+* Converts a text based file list (e.g. "6F3A6F3B") to a binary file list (e.g
+* {0x6f3a, 0x6f3b}).
+*
+* @param aText Text string to convert.
+* @param aFileList Returned file list.
+* @return Error code KErrNone if request completes ok. Otherwise a relevant error
+* code.
+*/
+ {
+ aFileList.Zero();
+
+ //
+ // Go through the string and take upto 4 characters at a time. Convert each set
+ // from hexidecimal to an integer and then append them to the file list.
+ //
+ TInt position(0);
+
+ while (position < aText.Length())
+ {
+ TInt numberLength(4);
+
+ if (aText.Length() - position < 4)
+ {
+ numberLength = aText.Length() - position;
+ }
+
+ TLex8 token(aText.Mid(position, numberLength));
+ TUint value;
+ TInt ret;
+
+ ret = token.Val(value, EHex);
+ if (ret != KErrNone)
+ {
+ aFileList.Zero();
+ return(ret);
+ }
+
+ aFileList.Append(value);
+ position +=4;
+ }
+
+ return(KErrNone);
+}
+
+
+TInt CSimSat::ConvertTextToTBuf255(const TPtrC8& aText,
+ TBuf<255>& aFileList) const
+/**
+* Converts a text based file list (e.g. "6F3A6F3B") to a binary file list (e.g
+* {0x6f3a, 0x6f3b}).
+*
+* @param aText Text string to convert.
+* @param aFileList Returned file list.
+* @return Error code KErrNone if request completes ok. Otherwise a relevant error
+* code.
+*/
+ {
+ aFileList.Zero();
+
+ //
+ // Go through the string and take upto 4 characters at a time. Convert each set
+ // from hexidecimal to an integer and then append them to the file list.
+ //
+ TInt position(0);
+
+ while (position < aText.Length())
+ {
+ TInt numberLength(4);
+
+ if (aText.Length() - position < 4)
+ {
+ numberLength = aText.Length() - position;
+ }
+
+ TLex8 token(aText.Mid(position, numberLength));
+ TUint value;
+ TInt ret;
+
+ ret = token.Val(value, EHex);
+ if (ret != KErrNone)
+ {
+ aFileList.Zero();
+ return(ret);
+ }
+
+ aFileList.Append(value);
+ position +=4;
+ }
+
+ return(KErrNone);
+}
+
+
+
+TInt CSimSat::ConvertTextToTBuf4(const TPtrC8& aText,
+ TBuf8<4>& aFileList) const
+/**
+* Converts a text based file list (e.g. "6F3A6F3B") to a binary file list (e.g
+* {0x6f3a, 0x6f3b}).
+*
+* @param aText Text string to convert.
+* @param aFileList Returned file list.
+* @return Error code KErrNone if request completes ok. Otherwise a relevant error
+* code.
+*/
+ {
+ aFileList.Zero();
+
+ //
+ // Go through the string and take upto 4 characters at a time. Convert each set
+ // from hexidecimal to an integer and then append them to the file list.
+ //
+ TInt position(0);
+
+ while (position < aText.Length())
+ {
+ TInt numberLength(4);
+
+ if (aText.Length() - position < 4)
+ {
+ numberLength = aText.Length() - position;
+ }
+
+ TLex8 token(aText.Mid(position, numberLength));
+ TUint value;
+ TInt ret;
+
+ ret = token.Val(value, EHex);
+ if (ret != KErrNone)
+ {
+ aFileList.Zero();
+ return(ret);
+ }
+
+ aFileList.Append(value);
+ position +=4;
+ }
+
+ return(KErrNone);
+ }
+
+TInt CSimSat::ConvertTextToTBuf16(const TPtrC8& aText,
+ TBuf8<16>& aFileList) const
+/**
+*
+* @param aText Text string to convert.
+* @param aFileList Returned file list.
+* @return Error code KErrNone if request completes ok. Otherwise a relevant error
+* code.
+*/
+ {
+ aFileList.Zero();
+
+ //
+ // Go through the string and take upto 4 characters at a time. Convert each set
+ // from hexidecimal to an integer and then append them to the file list.
+ //
+ TInt position(0);
+
+ while (position < aText.Length())
+ {
+ TInt numberLength(4);
+
+ if (aText.Length() - position < 4)
+ {
+ numberLength = aText.Length() - position;
+ }
+
+ TLex8 token(aText.Mid(position, numberLength));
+ TUint value;
+ TInt ret;
+
+ ret = token.Val(value, EHex);
+ if (ret != KErrNone)
+ {
+ aFileList.Zero();
+ return(ret);
+ }
+
+ aFileList.Append(value);
+ position +=4;
+ }
+
+ return(KErrNone);
+ }
+
+
+/* Function that generates time(in seconds) at random for the SimTSY
+ * Maximum of ten seconds; zero seconds also included just to simulate the
+ * synchronous call scenario
+ */
+
+TInt CSimSat::randTime()
+ {
+ TInt ranT= Math::Random()%10;
+ return(ranT);
+ }
+
+
+TInt CSimSat::RetrieveMultimediaRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMRetRspV6Pckg = (RSat::TRetrieveMultimediaMessageRspV6Pckg*)aRsp;
+ RSat::TRetrieveMultimediaMessageRspV6& tMMRetRspV6 = (*tMMRetRspV6Pckg)();
+
+ if(iRetTIndex == 0 || iRetTIndex ==3 || ((iRetTIndex >=5) && (iRetTIndex <=7)))
+ {
+ if((tMMRetRspV6.iGeneralResult != RSat::KSuccess) ||
+ (tMMRetRspV6.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iRetTIndex ==1 || iRetTIndex == 2)
+ {
+ if((tMMRetRspV6.iGeneralResult != RSat::KMMSTemporaryProblem) ||
+ (tMMRetRspV6.iInfoType != RSat::KMeProblem) ||
+ (tMMRetRspV6.iAdditionalInfo.Compare(SIMTSY_MMMESSAGE_ADD_INFO_1) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iRetTIndex ==4)
+ {
+ if((tMMRetRspV6.iGeneralResult != RSat::KMMSError) ||
+ (tMMRetRspV6.iInfoType != RSat::KMeProblem) ||
+ (tMMRetRspV6.iAdditionalInfo.Compare(SIMTSY_MMMESSAGE_ADD_INFO_1) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+
+
+ iPendingTerRsp = EFalse;
+ return KErrNone;
+
+ }
+
+TInt CSimSat::SubmitMultimediaRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TSubmitMultimediaMessageRspV6Pckg *tMMSubRspV6Pckg= (RSat::TSubmitMultimediaMessageRspV6Pckg*)aRsp;
+ RSat::TSubmitMultimediaMessageRspV6& tMMSubRspV6 = (*tMMSubRspV6Pckg)();
+
+ if(iSubTIndex == 0 || iSubTIndex ==3 || iSubTIndex ==5 || iSubTIndex ==6)
+ {
+ if((tMMSubRspV6.iGeneralResult != RSat::KSuccess) ||
+ (tMMSubRspV6.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iSubTIndex ==1 || iSubTIndex ==2)
+ {
+ if((tMMSubRspV6.iGeneralResult != RSat::KMMSTemporaryProblem) ||
+ (tMMSubRspV6.iInfoType != RSat::KMeProblem) ||
+ (tMMSubRspV6.iAdditionalInfo.Compare(SIMTSY_MMMESSAGE_ADD_INFO_1) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iSubTIndex ==4)
+ {
+ if((tMMSubRspV6.iGeneralResult != RSat::KMMSError) ||
+ (tMMSubRspV6.iInfoType != RSat::KMeProblem) ||
+ (tMMSubRspV6.iAdditionalInfo.Compare(SIMTSY_MMMESSAGE_ADD_INFO_1) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+
+ iPendingTerRsp = EFalse;
+ return KErrNone;
+
+ }
+
+TInt CSimSat::DisplayMultimediaRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TDisplayMultimediaMessageRspV6Pckg *tMMDispRspV6Pckg= (RSat::TDisplayMultimediaMessageRspV6Pckg*)aRsp;
+ RSat::TDisplayMultimediaMessageRspV6& tMMDispRspV6 = (*tMMDispRspV6Pckg)();
+
+ if(iDispTIndex == 0 || iDispTIndex == 1 || iDispTIndex == 6 ||
+ ((iDispTIndex >=8) && (iDispTIndex <=10)) || iDispTIndex == 12)
+ {
+ if((tMMDispRspV6.iGeneralResult != RSat::KSuccess) ||
+ (tMMDispRspV6.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if (iDispTIndex ==2)
+ {
+ if((tMMDispRspV6.iGeneralResult != RSat::KPSessionTerminatedByUser) ||
+ (tMMDispRspV6.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if (iDispTIndex ==3)
+ {
+ if((tMMDispRspV6.iGeneralResult != RSat::KBackwardModeRequestedByUser) ||
+ (tMMDispRspV6.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if (iDispTIndex ==4)
+ {
+ if((tMMDispRspV6.iGeneralResult != RSat::KNoResponseFromUser) ||
+ (tMMDispRspV6.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if (iDispTIndex ==5)
+ {
+ if((tMMDispRspV6.iGeneralResult != RSat::KMMSError) ||
+ (tMMDispRspV6.iInfoType != RSat::KMeProblem) ||
+ (tMMDispRspV6.iAdditionalInfo.Compare(SIMTSY_MMMESSAGE_ADD_INFO_1) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if (iDispTIndex == 7 || iDispTIndex == 11 || iDispTIndex ==13)
+ {
+ if((tMMDispRspV6.iGeneralResult != RSat::KMeUnableToProcessCmd) ||
+ (tMMDispRspV6.iInfoType != RSat::KMeProblem) ||
+ (tMMDispRspV6.iAdditionalInfo.Compare(SIMTSY_MMMESSAGE_ADD_INFO_2) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+
+ iPendingTerRsp = EFalse;
+ return KErrNone;
+
+ }
+
+TInt CSimSat::SetFramesRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TSetFramesRspV6Pckg *tSetFramesV6Pckg= (RSat::TSetFramesRspV6Pckg*)aRsp;
+ RSat::TSetFramesRspV6& tSetFramesRspV6 = (*tSetFramesV6Pckg)();
+
+ if(iSetFrmsIndex == 1)
+ {
+ if((tSetFramesRspV6.iGeneralResult != RSat::KSuccess) ||
+ (tSetFramesRspV6.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if (iSetFrmsIndex ==2)
+ {
+ if((tSetFramesRspV6.iGeneralResult != RSat::KFramesError) ||
+ (tSetFramesRspV6.iInfoType != RSat::KMeProblem) ||
+ (tSetFramesRspV6.iAdditionalInfo.Compare(SIMTSY_SET_FRMS_ADD_INFO_1) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if (iSetFrmsIndex ==3)
+ {
+ if((tSetFramesRspV6.iGeneralResult != RSat::KFramesError) ||
+ (tSetFramesRspV6.iInfoType != RSat::KMeProblem) ||
+ (tSetFramesRspV6.iAdditionalInfo.Compare(SIMTSY_SET_FRMS_ADD_INFO_2) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+
+ iPendingTerRsp = EFalse;
+ return KErrNone;
+ }
+
+TInt CSimSat::ProvideLocalInfoRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TLocalInfoRspV3Pckg *tLocalInfoV3Pckg = (RSat::TLocalInfoRspV3Pckg*)aRsp;
+ RSat::TLocalInfoRspV3& tLocalInfoV3 = (*tLocalInfoV3Pckg)();
+
+ if((iLocalInfoIndex==1 || iLocalInfoIndex ==4) &&
+ ((tLocalInfoV3.iGeneralResult != RSat::KSuccess) ||
+ (tLocalInfoV3.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iLocalInfoIndex==2) && ((tLocalInfoV3.iGeneralResult != RSat::KMeUnableToProcessCmd) ||
+ (tLocalInfoV3.iInfoType != RSat::KMeProblem) ||
+ (tLocalInfoV3.iAdditionalInfo.Compare(SIMTSY_PRV_LCLINFO_ADD_INFO_1) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iLocalInfoIndex ==5) && ((tLocalInfoV3.iGeneralResult !=RSat::KSuccessLimitedService) ||
+ (tLocalInfoV3.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iLocalInfoIndex == 6) && ((tLocalInfoV3.iGeneralResult !=RSat::KMeUnableToProcessCmd) ||
+ (tLocalInfoV3.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::OpenChannelRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TOpenChannelRspV2Pckg *tOpenChnRspPckg = (RSat::TOpenChannelRspV2Pckg*)aRsp;
+ RSat::TOpenChannelRspV2 &tOpenChnRsp = (*tOpenChnRspPckg)();
+
+ if((iOpenChnIndex == 1) && ((tOpenChnRsp.iGeneralResult != RSat::KSuccess) ||
+ (tOpenChnRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iOpenChnIndex ==2) && ((tOpenChnRsp.iGeneralResult != RSat::KNetworkUnableToProcessCmd) ||
+ (tOpenChnRsp.iInfoType != RSat::KMeProblem) ||
+ (tOpenChnRsp.iAdditionalInfo.Compare(SIMTSY_MMMESSAGE_ADD_INFO_1) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iOpenChnIndex == 3) && ((tOpenChnRsp.iGeneralResult != RSat::KPerformedWithModifications) ||
+ (tOpenChnRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::PlayToneRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TPlayToneRspV1Pckg *tPlayToneRspPckg = (RSat::TPlayToneRspV1Pckg *)aRsp;
+ RSat::TPlayToneRspV1& tPlayToneRsp = (*tPlayToneRspPckg)();
+
+ if((iMiscCmdIndex == 1) && ((tPlayToneRsp.iGeneralResult != RSat::KPlayTonePerformedSuccessfully) ||
+ (tPlayToneRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iMiscCmdIndex == 2) && ((tPlayToneRsp.iGeneralResult != RSat::KPSessionTerminatedByUser) ||
+ (tPlayToneRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iMiscCmdIndex == 3) && ((tPlayToneRsp.iGeneralResult != RSat::KCmdBeyondMeCapabilities) ||
+ (tPlayToneRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::SetupCallRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TSetUpCallRspV2Pckg *tSetupCallRspPckg = (RSat::TSetUpCallRspV2Pckg*)aRsp;
+ RSat::TSetUpCallRspV2& tSetupCallRsp = (*tSetupCallRspPckg)();
+
+ if((iMiscCmdIndex == 5) && ((tSetupCallRsp.iGeneralResult != RSat::KSuccess) ||
+ (tSetupCallRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iMiscCmdIndex == 6) && ((tSetupCallRsp.iGeneralResult != RSat::KCmdBeyondMeCapabilities) ||
+ (tSetupCallRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iMiscCmdIndex == 7) && ((tSetupCallRsp.iGeneralResult != RSat::KMeUnableToProcessCmd) ||
+ (tSetupCallRsp.iInfoType != RSat::KMeProblem) ||
+ (tSetupCallRsp.iAdditionalInfo.Compare(SIMTSY_SETUPCALL_ADD_INFO_1) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iMiscCmdIndex == 8) && ((tSetupCallRsp.iGeneralResult != RSat::KNetworkUnableToProcessCmd) ||
+ (tSetupCallRsp.iInfoType != RSat::KMeProblem) ||
+ (tSetupCallRsp.iAdditionalInfo.Compare(SIMTSY_SETUPCALL_ADD_INFO_1) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::RefreshRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+ RSat::TRefreshRspV1Pckg *tRefRspPckg = (RSat::TRefreshRspV1Pckg*)aRsp;
+ RSat::TRefreshRspV1& tRefRsp = (*tRefRspPckg)();
+
+ if((iRefreshIndex ==1) && ((tRefRsp.iGeneralResult != RSat::KSuccess) ||
+ (tRefRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iRefreshIndex ==2) && ((tRefRsp.iGeneralResult != RSat::KMeUnableToProcessCmd) ||
+ (tRefRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::GetFramesStatusRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TGetFramesStatusRspV6Pckg *tGetFramesStsV6Pckg= (RSat::TGetFramesStatusRspV6Pckg*)aRsp;
+ RSat::TGetFramesStatusRspV6& tGetFramesStsV6 = (*tGetFramesStsV6Pckg)();
+
+ TInt iGetFrmsStsLocalIndex =0 ;
+
+ if((iGetFrmsStsIndex == 1) && ((tGetFramesStsV6.iGeneralResult != RSat::KSuccess) ||
+ (tGetFramesStsV6.iInfoType != RSat::KNoAdditionalInfo) ||
+ (tGetFramesStsV6.iFramesInformation.iFrameId != iGetFrmsSts->At(iGetFrmsStsLocalIndex).iFrmId ) ||
+ (tGetFramesStsV6.iFramesInformation.iFrameList.Compare(iGetFrmsSts->At(iGetFrmsStsLocalIndex).iFrmList))))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iGetFrmsStsIndex == 2) && ((tGetFramesStsV6.iGeneralResult != RSat::KFramesError) ||
+ (tGetFramesStsV6.iInfoType != RSat::KNoFrameIdentified) ||
+ (tGetFramesStsV6.iFramesInformation.iFrameId != iGetFrmsSts->At(iGetFrmsStsLocalIndex).iFrmId ) ||
+ (tGetFramesStsV6.iFramesInformation.iFrameList.Compare(iGetFrmsSts->At(iGetFrmsStsLocalIndex).iFrmList))))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ iGetFrmsStsLocalIndex++;
+ iSendRspEventDnld = ETrue;
+ return KErrNone;
+ }
+
+TInt CSimSat::SendUssdRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TSendUssdRspV1Pckg *tSendUssdRspPckg= (RSat::TSendUssdRspV1Pckg*)aRsp;
+ RSat::TSendUssdRspV1& tSendUssdRsp = (*tSendUssdRspPckg)();
+
+ if((iSendUssdIndex ==1) && ((tSendUssdRsp.iGeneralResult != RSat::KSuccess) ||
+ (tSendUssdRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iSendUssdIndex == 2) && ((tSendUssdRsp.iGeneralResult != RSat::KMeUnableToProcessCmd) ||
+ (tSendUssdRsp.iInfoType != RSat::KMeProblem) ||
+ (tSendUssdRsp.iAdditionalInfo.Compare(SIMTSY_SEND_USSD_ADD_INFO) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iSendUssdIndex == 3) && ((tSendUssdRsp.iGeneralResult != RSat::KMeUnableToProcessCmd) ||
+ (tSendUssdRsp.iInfoType != RSat::KMeProblem) ||
+ (tSendUssdRsp.iAdditionalInfo.Compare(SIMTSY_SEND_USSD_ADD_INFO_1) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::LaunchBrowserRsp(const TTsyReqHandle aTsyReqHandle,TDes8* aRsp)
+ {
+ RSat::TLaunchBrowserRspV2Pckg* tLBRspPckg= (RSat::TLaunchBrowserRspV2Pckg*)aRsp;
+ RSat::TLaunchBrowserRspV2& tLBRsp =(*tLBRspPckg)();
+
+ if((iLnchBrwsrIndex == 1) && ((tLBRsp.iGeneralResult != (iLnchBrwsr->At(iLnchBrwsrIndex-1).iTerRsp)) ||
+ (tLBRsp.iInfoType != RSat::KNoAdditionalInfo)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iLnchBrwsrIndex == 2) && ((tLBRsp.iGeneralResult != (iLnchBrwsr->At(iLnchBrwsrIndex-1).iTerRsp)) ||
+ (tLBRsp.iInfoType != RSat::KMeProblem) ||
+ (tLBRsp.iAdditionalInfo.Compare(SIMTSY_LNCH_BRWSR_ADD_INFO1) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iLnchBrwsrIndex == 3) && ((tLBRsp.iGeneralResult != (iLnchBrwsr->At(iLnchBrwsrIndex-1).iTerRsp)) ||
+ (tLBRsp.iInfoType != RSat::KMeProblem) ||
+ (tLBRsp.iAdditionalInfo.Compare(SIMTSY_LNCH_BRWSR_ADD_INFO2) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iLnchBrwsrIndex == 4) && ((tLBRsp.iGeneralResult != (iLnchBrwsr->At(iLnchBrwsrIndex-1).iTerRsp)) ||
+ (tLBRsp.iInfoType != RSat::KMeProblem) ||
+ (tLBRsp.iAdditionalInfo.Compare(SIMTSY_LNCH_BRWSR_ADD_INFO3) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else if((iLnchBrwsrIndex == 5) && ((tLBRsp.iGeneralResult != (iLnchBrwsr->At(iLnchBrwsrIndex-1).iTerRsp)) ||
+ (tLBRsp.iInfoType != RSat::KMeProblem) ||
+ (tLBRsp.iAdditionalInfo.Compare(SIMTSY_LNCH_BRWSR_ADD_INFO4) != 0)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::GetInkeyRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp)
+ {
+
+ RSat::TGetInkeyRspV2Pckg *tGetInkeyRspPckg= (RSat::TGetInkeyRspV2Pckg*)aRsp;
+ RSat::TGetInkeyRspV2& tGetInkeyRsp = (*tGetInkeyRspPckg)();
+
+ if((tGetInkeyRsp.iGeneralResult != RSat::KSuccess) ||
+ (tGetInkeyRsp.iInfoType != RSat::KNoAdditionalInfo))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::GetMeSideSatProfile(const TTsyReqHandle aTsyReqHandle, TDes8* aMeSimSatProfile)
+ {
+ RSat::TSatProfileV6Pckg* profileV6Pckg = (RSat::TSatProfileV6Pckg*)aMeSimSatProfile;
+ RSat::TSatProfileV6& profileV6 = (*profileV6Pckg)();
+
+ profileV6.iSatProfileByte22 = RSat::KCapsRetrieveMultimediaMessage | RSat::KCapsSubmitMultimediaMessage;
+
+ profileV6.iSatProfileByte23 = RSat::KCapsMmsNotificationDownload;
+
+
+ if(iLocalInfoIndex !=1)
+ {
+ profileV6.iSatProfileByte18 = RSat::KCapsProvideLocalInfoIMEISV |
+ RSat::KCapsProvideLocalInfoSearchModeChange;
+ if(iLocalInfoIndex == 3 )
+ {
+ profileV6.iSatProfileByte22 |= RSat::KCapsProvideLocalInfoUTRAN |
+ RSat::KCapsProvideLocalInfoBatteryState;
+ }
+ else
+ {
+ profileV6.iSatProfileByte22 |= RSat::KCapsProvideLocalInfoBatteryState;
+ }
+ profileV6.iSatProfileByte23 |= RSat::KCapsProvideLocalInfoMEID;
+ }
+ profileV6.iSatProfileByte25 = RSat::KCapsMmsTransferStatusEvent;
+
+ if(iMiscCmdIndex == 0 || iMiscCmdIndex == 5 || iMiscCmdIndex == 10)
+ {
+ profileV6.iSatProfileByte22 |= (RSat::KCapsPlayThemedAndMelodyTone
+ | RSat::KCapsSetUpCallMultimediaCall | RSat::KCapsRefreshGBA );
+ }
+
+ profileV6.iSatProfileByte6 = RSat::KCapsNetworkSearchModeChangeEvent;
+ profileV6.iSatProfileByte25 |= (RSat::KCapsFrameParametersChangeEvent |
+ RSat::KCapsBrowsingStatusEvent);
+
+ profileV6.iSatProfileByte4 = RSat::KCapsSendUSSD;
+
+ // The UICC is set to support the USSD Data Download by default to remove any dependencies on the test code
+ // If clients find it useful to be able to set this capability on demand, this should be made updatable
+ // via the config file
+ profileV6.iSatProfileByte23 |= RSat::KCapsUssdDataDownload;
+
+ if(iLnchBrwsrIndex != 1)
+ {
+ profileV6.iSatProfileByte21 = RSat::KCapsXHTML;
+ }
+
+ iGetMeSideProfileHandle = aTsyReqHandle;
+ ReqCompleted(aTsyReqHandle,KErrNone);
+
+ return KErrNone;
+ }
+
+TInt CSimSat::GetMeSideSatProfileCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ if(aTsyReqHandle == iGetMeSideProfileHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+TInt CSimSat::ClientSatProfileIndication(const TTsyReqHandle aTsyReqHandle, TDes8* aClientSatProfile)
+ {
+ RSat::TSatProfileV6Pckg* aClientSatProfilePckg = (RSat::TSatProfileV6Pckg*)aClientSatProfile;
+ RSat::TSatProfileV6& satProfV6 = (*aClientSatProfilePckg)();
+
+ if(iRetTIndex ==6 || iRetTIndex ==7)
+ {
+ if(!(satProfV6.iSatProfileByte22 & (RSat::KCapsRetrieveMultimediaMessage))
+ || !(satProfV6.iSatProfileByte25 & (RSat::KCapsMmsTransferStatusEvent)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+
+ else if(iSubTIndex == 5 || iSubTIndex ==6)
+ {
+ if(!(satProfV6.iSatProfileByte22 & (RSat::KCapsSubmitMultimediaMessage))
+ || !(satProfV6.iSatProfileByte25 & (RSat::KCapsMmsTransferStatusEvent)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+
+ else if(iLocalInfoIndex == 0)
+ {
+ if(!(((satProfV6.iSatProfileByte18&RSat::KCapsProvideLocalInfoIMEISV)&&
+ (satProfV6.iSatProfileByte18&RSat::KCapsProvideLocalInfoSearchModeChange)) ||
+ (satProfV6.iSatProfileByte22&RSat::KCapsProvideLocalInfoBatteryState) ||
+ (satProfV6.iSatProfileByte23&RSat::KCapsProvideLocalInfoMEID)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iLocalInfoIndex == 1)
+ {
+ if(((satProfV6.iSatProfileByte18&RSat::KCapsProvideLocalInfoIMEISV)&&
+ (satProfV6.iSatProfileByte18&RSat::KCapsProvideLocalInfoSearchModeChange)) ||
+ (satProfV6.iSatProfileByte22&RSat::KCapsProvideLocalInfoBatteryState) ||
+ (satProfV6.iSatProfileByte23&RSat::KCapsProvideLocalInfoMEID))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iLocalInfoIndex == 3)
+ {
+ if(!(((satProfV6.iSatProfileByte18&RSat::KCapsProvideLocalInfoIMEISV)&&
+ (satProfV6.iSatProfileByte18&RSat::KCapsProvideLocalInfoSearchModeChange)) ||
+ ((satProfV6.iSatProfileByte22&RSat::KCapsProvideLocalInfoUTRAN)&&
+ (satProfV6.iSatProfileByte22&RSat::KCapsProvideLocalInfoBatteryState)) ||
+ (satProfV6.iSatProfileByte23&RSat::KCapsProvideLocalInfoMEID)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iMiscCmdIndex == 0 || iMiscCmdIndex == 5 || iMiscCmdIndex == 10)
+ {
+ if(!(satProfV6.iSatProfileByte22 & RSat::KCapsPlayThemedAndMelodyTone) ||
+ !(satProfV6.iSatProfileByte22 & RSat::KCapsSetUpCallMultimediaCall) ||
+ !(satProfV6.iSatProfileByte22 & RSat::KCapsRefreshGBA) )
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iEventDnldIndex == 0)
+ {
+ if(!(satProfV6.iSatProfileByte6 & (RSat::KCapsNetworkSearchModeChangeEvent)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else if(iLnchBrwsrIndex == 1)
+ {
+ if(!(satProfV6.iSatProfileByte21 & (RSat::KCapsXHTML)))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+
+ return KErrNone;
+ }
+
+TInt CSimSat::MmsTransferStatus(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd)
+ {
+ RSat::TMmsTransferStatusV6Pckg* mMSTransferStatusV6PCmdPckg = (RSat::TMmsTransferStatusV6Pckg*)aPCmd;
+ RSat::TMmsTransferStatusV6& mMSTransferStatusV6 = (*mMSTransferStatusV6PCmdPckg)();
+
+ if(iRetTIndex ==6 || iRetTIndex ==7)
+ {
+ if((mMSTransferStatusV6.iDeviceId != RSat::KME)
+ ||(mMSTransferStatusV6.iMMSTransferFile.Compare(SIMTSY_MMS_TRF_FILE_PATH) !=0)
+ ||(mMSTransferStatusV6.iMultimediaMessageStatus.Compare(SIMTSY_MMS_MSG_BUF) !=0)
+ ||(mMSTransferStatusV6.iMultimediaMessageId.Compare(SIMTSY_MMS_MSG_ID) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+
+ else if(iSubTIndex == 5 || iSubTIndex ==6)
+ {
+ if((mMSTransferStatusV6.iDeviceId != RSat::KME)
+ ||(mMSTransferStatusV6.iMMSTransferFile.Compare(SIMTSY_MMS_TRF_FILE_PATH) !=0)
+ ||(mMSTransferStatusV6.iMultimediaMessageStatus.Compare(SIMTSY_MMS_MSG_BUF) !=0)
+ ||(mMSTransferStatusV6.iMultimediaMessageId.Compare(SIMTSY_MMS_MSG_ID) != 0))
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ }
+
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+
+ iMMSTransferStatusHandle = aTsyReqHandle;
+ return KErrNone;
+ }
+
+TInt CSimSat::MmsTransferStatusCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+
+ if(aTsyReqHandle == iMMSTransferStatusHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+
+ }
+
+TInt CSimSat::MmsNotificationDownload(const TTsyReqHandle aTsyReqHandle, TDes8* aDes)
+ {
+ // Has the config file been parsed for this functionality
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_MMSNOTIFICATIONDOWNLOAD_CMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ TInt err(KErrNone);
+ TInt count(iMmsDownloadData->Count());
+ TBool found(EFalse);
+
+ // If the config file does not contain any USSD Download related data
+ // then complete the request with KErrNotSupported
+ if(!count)
+ {
+ err = KErrNotSupported;
+ }
+ else
+ {
+ // otherwise extract the data supplied by the client
+ RSat::TMmsNotificationDownloadV6Pckg* mmsNotificationDownloadV6Pckg = (RSat::TMmsNotificationDownloadV6Pckg*)aDes;
+ RSat::TMmsNotificationDownloadV6& mmsNotificationDownloadV6 = (*mmsNotificationDownloadV6Pckg)();
+
+ for(TInt i=0; i<count; i++)
+ {
+ TMmsNotificationDownload tempMmsData = iMmsDownloadData->At(i);
+
+ // Compare the supplied data to the data retrieved from the config file
+ if((mmsNotificationDownloadV6.iDeviceId == STATIC_CAST(RSat::TDeviceId, tempMmsData.iDestn)) &&
+ (mmsNotificationDownloadV6.iMMSNotification.Compare(tempMmsData.iMMSNotfn) == 0) &&
+ (mmsNotificationDownloadV6.iLastEnvelope == tempMmsData.iLastEnv))
+ {
+ found = ETrue;
+
+ if(tempMmsData.iUICCRsp == SIMTSY_UICC_SUCC_RSP)
+ {
+ err = KErrNone;
+ }
+ else if(tempMmsData.iUICCRsp == SIMTSY_UICC_RETRY_RSP)
+ {
+ err = KErrNotReady;
+ }
+ else if(tempMmsData.iUICCRsp == SIMTSY_UICC_FLR_RSP_1 ||
+ tempMmsData.iUICCRsp == SIMTSY_UICC_FLR_RSP_2)
+ {
+ err = KErrNotSupported;
+ }
+
+ iMmsDownloadDataHandle = aTsyReqHandle;
+ break;
+ }
+ } // end for loop
+ } // end else
+
+ // the supplied data does not match the one in the config file, so complete the request with an error
+ if(!found)
+ err = KErrCorrupt;
+
+ ReqCompleted(aTsyReqHandle, err);
+ return KErrNone;
+ }
+
+TInt CSimSat::MmsNotificationDownloadCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+ if(aTsyReqHandle == iMmsDownloadDataHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+
+ }
+
+TInt CSimSat::EventDownload(const TTsyReqHandle aTsyReqHandle, RSat::TEventList* aPCmd, TDes8* aRsp)
+ {
+
+ if(!iConfigDone)
+ {
+ TInt ret = KErrNone;
+ TRAPD(err, ret = ConfigL(SIMTSY_EVENT_LIST_CMD_NUMBER));
+ if(err != KErrNone)
+ {
+ ret = err;
+ }
+
+ if(ret!= KErrNone)
+ {
+ return ret;
+ }
+ else
+ {
+ iConfigDone = ETrue;
+ }
+ }
+
+ switch(*aPCmd)
+ {
+ case RSat:: KNetworkSearchModeChange:
+ {
+ RSat::TNetworkSearchModeChangeEventV6Pckg* networkSrchPckg = (RSat::TNetworkSearchModeChangeEventV6Pckg*)aRsp;
+ RSat::TNetworkSearchModeChangeEventV6& networkSrch = (*networkSrchPckg)();
+
+ iEventDnldHandle = aTsyReqHandle;
+
+ if(iEventDnldIndex == 0 || iEventDnldIndex == 1 )
+ {
+ if(networkSrch.iNetworkSearchMode == (STATIC_CAST(RSat::TNetworkSearchMode,iEventList->At(iEventDnldIndex).iVar)))
+ {
+ iSendRspEventDnld = ETrue;
+ }
+ else
+ {
+ iSendRspEventDnld = EFalse;
+ }
+ }
+ }
+ break;
+
+ case RSat::KFramesInformationChange:
+ {
+ RSat::TFramesInformationChangedEventV6Pckg* frmsChgPckg = (RSat::TFramesInformationChangedEventV6Pckg*)aRsp;
+ RSat::TFramesInformationChangedEventV6& frmsChg = (*frmsChgPckg)();
+
+ iEventDnldHandle = aTsyReqHandle;
+
+ if(iEventDnldIndex == 4 || iEventDnldIndex == 5 )
+ {
+ if((frmsChg.iFramesInformation.iFrameId == (iEventList->At(iEventDnldIndex).iVar)) ||
+ (!(frmsChg.iFramesInformation.iFrameList.Compare(iEventList->At(iEventDnldIndex).iFrameList))))
+ {
+ iSendRspEventDnld = ETrue;
+ }
+ else
+ {
+ iSendRspEventDnld = EFalse;
+ }
+ }
+ }
+ break;
+
+ case RSat::KBrowsingStatusChange:
+ {
+ RSat::TBrowsingStatusEventV6Pckg *brwStsPckg = (RSat::TBrowsingStatusEventV6Pckg*)aRsp;
+ RSat::TBrowsingStatusEventV6& brwSts = (*brwStsPckg)();
+
+ iEventDnldHandle = aTsyReqHandle;
+
+ if(iEventDnldIndex == 2 || iEventDnldIndex == 3 )
+ {
+ if(brwSts.iBrowserStatus == (iEventList->At(iEventDnldIndex).iVar))
+ {
+ iSendRspEventDnld = ETrue;
+ }
+ else
+ {
+ iSendRspEventDnld = EFalse;
+ }
+ }
+ else if(iEventDnldIndex == 0)
+ {
+ iSendRspEventDnld = ETrue;
+ }
+ }
+ break;
+
+ default:
+ iSendRspEventDnld = EFalse;
+ break;
+ }
+
+
+ if(iEventDnldIndex < iEventList->Count())
+ {
+ iEventDnldIndex++;
+ }
+
+ return KErrNone;
+
+ }
+
+TInt CSimSat::EventDownloadCancel(const TTsyReqHandle aTsyReqHandle)
+ {
+
+ if(aTsyReqHandle == iEventDnldHandle)
+ {
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrCorrupt);
+ }
+ return KErrNone;
+ }
+
+
+TInt CSimSat::ConfigL(unsigned int aCmd)
+ {
+ LOGMISC1("CSimSat: Entered ConfigL()");
+
+ TInt dcs,terRsp,src,UICCRsp,lastEnv,duration,type,frameId,frmLayout,defFrmLayout,frameSeparator;
+ TInt immRsp,dispPrio,clrScr,utranQlfr,infoType,brType,location,destn,alphaIDSts;
+ TInt iconid,iconidqlfr,textStatus,ret=KErrNone;
+ TInt i;
+
+ TPtrC8 ussdStr,mmsNotfn,subFile,framesList,FileList,frmLayoutBuf;
+ TPtrC8 dispFile,alphaIDBuf,msgRef,rcpFile,conId,msgId,txtAttr;
+
+ const CTestConfigItem* item=NULL;
+
+
+ TMmsNotificationDownload tMmsNotificationDownload;
+ TSendUSSD tSendSS;
+ TEventDnld tEventDnld;
+ TUssdData tUssdData;
+ TSendUSSD tSendUssd;
+ TLnchBrwsr tLnchBrwsr;
+ TMMRetrieve tMMRetrieve;
+ TMiscPCmd tMiscCmd;
+ TMMSubmit tMMSubmit;
+ TSetFrms tSetFrms;
+ TMMDisplay tMMDisplay;
+ TGetFrmsSts tGetFrmsSts;
+ TLocalInfo tLocalInfo;
+ TOpenChannel tOpenChn;
+
+ TInt lnchBCount =CfgFile()->ItemCount(KLaunchBrowser);
+ TInt ussdCount =CfgFile()->ItemCount(KSendUssd);
+ TInt refCount =CfgFile()->ItemCount(KRefresh2);
+ TInt miscCount =CfgFile()->ItemCount(KMiscCmd);
+ TInt openCount =CfgFile()->ItemCount(KOpenChnl);
+ TInt localCount =CfgFile()->ItemCount(KLocalInfo);
+ TInt getFSCount =CfgFile()->ItemCount(KGetFramesStatus);
+ TInt setFCount =CfgFile()->ItemCount(KSetFrames);
+ TInt dispCount =CfgFile()->ItemCount(KMMDisplay);
+ TInt subCount =CfgFile()->ItemCount(KMMSubmit);
+ TInt retrCount =CfgFile()->ItemCount(KMMRetrieve);
+ TInt notfnDCount=CfgFile()->ItemCount(KMmsNotificationDownload);
+ TInt ussdDnCount=CfgFile()->ItemCount(KUssdDataDownload);
+ TInt eventCount =CfgFile()->ItemCount(KEventDnld);
+ TInt ssCount =CfgFile()->ItemCount(KSendSs);
+ TInt efCount =CfgFile()->ItemCount(KElemFiles);
+
+ switch(aCmd)
+ {
+ case SIMTSY_RET_MM_PCMD_NUMBER:
+ /* Retrieving the information related to the RETRIEVE MM command */
+
+ iMMRetrieve = new(ELeave) CArrayFixFlat<TMMRetrieve>(KSatGranularity);
+ for (i=0;i<retrCount;i++)
+ {
+
+ item=CfgFile()->Item(KMMRetrieve,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("destination",ret,0,&KMMRetrieve);
+ continue;
+ }
+ tMMRetrieve.iDestn = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,alphaIDSts);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("alphaIDStatus",ret,1,&KMMRetrieve);
+ continue;
+ }
+ tMMRetrieve.iAlphaStatus=alphaIDSts;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,alphaIDBuf);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("alphaIDBuf",ret,2,&KMMRetrieve);
+ continue;
+ }
+ location = alphaIDBuf.Locate('\n');
+ if(location > 0)
+ {
+ tMMRetrieve.iAlphaIDBuf.Set(alphaIDBuf.Left(location));
+ }
+ else
+ {
+ tMMRetrieve.iAlphaIDBuf.Set(alphaIDBuf);
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iconid);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("IconID Identifier",ret,3,&KMMRetrieve);
+ continue;
+ }
+ tMMRetrieve.iIconID = iconid;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iconidqlfr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("IconID qualifier",ret,4,&KMMRetrieve);
+ continue;
+ }
+ tMMRetrieve.iIconIDBuf = iconidqlfr;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,msgRef);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Message Reference",ret,5,&KMMRetrieve);
+ continue;
+ }
+ location = msgRef.Locate('\n');
+ if(location > 0)
+ {
+ tMMRetrieve.iMMMsgRef.Set(msgRef.Left(location));
+ }
+ else
+ {
+ tMMRetrieve.iMMMsgRef.Set(msgRef);
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,rcpFile);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Reception File",ret,6,&KMMRetrieve);
+ continue;
+ }
+ location = rcpFile.Locate('\n');
+ if(location > 0)
+ {
+ tMMRetrieve.iRcptnFile.Set(rcpFile.Left(location));
+ }
+ else
+ {
+ tMMRetrieve.iRcptnFile.Set(rcpFile);
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,conId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Content Identifier",ret,7,&KMMRetrieve);
+ continue;
+ }
+ location = conId.Locate('\n');
+ if(location > 0)
+ {
+ tMMRetrieve.iContentId.Set(conId.Left(location));
+ }
+ else
+ {
+ tMMRetrieve.iContentId.Set(conId);
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,msgId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Message Identifier",ret,8,&KMMRetrieve);
+ continue;
+ }
+ location = msgId.Locate('\n');
+ if(location > 0)
+ {
+ tMMRetrieve.iMsgId.Set(msgId.Left(location));
+ }
+ else
+ {
+ tMMRetrieve.iMsgId.Set(msgId);
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,textStatus);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attribute Status",ret,9,&KMMRetrieve);
+ continue;
+ }
+ tMMRetrieve.iTextAttStatus = textStatus;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,txtAttr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attribute",ret,10,&KMMRetrieve);
+ continue;
+ }
+ location = txtAttr.Locate('\n');
+ if(location > 0)
+ {
+ tMMRetrieve.iTextAttBuf.Set(txtAttr.Left(location));
+ }
+ else
+ {
+ tMMRetrieve.iTextAttBuf.Set(txtAttr);
+ }
+
+ iMMRetrieve->AppendL(tMMRetrieve);
+
+ }
+ break;
+ case SIMTSY_SUB_MM_PCMD_NUMBER:
+ /* Retrieving the information related to the SUBMIT MULTIMEDIA command */
+
+ iMMSubmit = new(ELeave) CArrayFixFlat<TMMSubmit>(KSatGranularity);
+ for(i=0;i<subCount;i++)
+ {
+ item=CfgFile()->Item(KMMSubmit,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("destination",ret,0,&KMMSubmit);
+ continue;
+ }
+ tMMSubmit.iDestn = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,alphaIDSts);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("alphaIDStatus",ret,1,&KMMSubmit);
+ continue;
+ }
+ tMMSubmit.iAlphaStatus=alphaIDSts;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,alphaIDBuf);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("alphaIDBuf",ret,2,&KMMSubmit);
+ continue;
+ }
+ location = alphaIDBuf.Locate('\n');
+ if(location > 0)
+ tMMSubmit.iAlphaIDBuf.Set(alphaIDBuf.Left(location));
+ else
+ tMMSubmit.iAlphaIDBuf.Set(alphaIDBuf);
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,iconid);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("IconID Identifier",ret,3,&KMMSubmit);
+ continue;
+ }
+ tMMSubmit.iIconID = iconid;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,iconidqlfr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("IconID qualifier",ret,4,&KMMSubmit);
+ continue;
+ }
+ tMMSubmit.iIconIDBuf = iconidqlfr;
+
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,subFile);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Submission File",ret,5,&KMMSubmit);
+ continue;
+ }
+ location = subFile.Locate('\n');
+ if(location > 0)
+ tMMSubmit.iSbmsnFile.Set(subFile.Left(location));
+ else
+ tMMSubmit.iSbmsnFile.Set(subFile);
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,msgId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Message Identifier",ret,6,&KMMSubmit);
+ continue;
+ }
+ location = msgId.Locate('\n');
+ if(location > 0)
+ tMMSubmit.iMsgId.Set(msgId.Left(location));
+ else
+ tMMSubmit.iMsgId.Set(msgId);
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,textStatus);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attribute Status",ret,7,&KMMSubmit);
+ continue;
+ }
+ tMMSubmit.iTextAttStatus = textStatus;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,txtAttr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attribute",ret,8,&KMMSubmit);
+ continue;
+ }
+ location = txtAttr.Locate('\n');
+ if(location > 0)
+ tMMSubmit.iTextAttBuf.Set(txtAttr.Left(location));
+ else
+ tMMSubmit.iTextAttBuf.Set(txtAttr);
+
+ iMMSubmit->AppendL(tMMSubmit);
+
+ }
+
+ break;
+ case SIMTSY_DISP_MM_PCMD_NUMBER:
+ /* Retrieving the information related to the DISPLAY MULTIMEDIA command */
+
+ iMMDisplay = new(ELeave) CArrayFixFlat<TMMDisplay>(KSatGranularity);
+ for(i=0;i<dispCount;i++)
+ {
+ item=CfgFile()->Item(KMMDisplay,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("destination",ret,0,&KMMDisplay);
+ continue;
+ }
+ tMMDisplay.iDestn = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,dispPrio);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Display Priority",ret,1,&KMMDisplay);
+ continue;
+ }
+ tMMDisplay.iDispPri = dispPrio;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,clrScr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("ClearScreen",ret,2,&KMMDisplay);
+ continue;
+ }
+ tMMDisplay.iClrScr = clrScr;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,dispFile);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Submission File",ret,3,&KMMDisplay);
+ continue;
+ }
+ location = dispFile.Locate('\n');
+ if(location > 0)
+ tMMDisplay.iSbmsnFile.Set(dispFile.Left(location));
+ else
+ tMMDisplay.iSbmsnFile.Set(dispFile);
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,msgId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Message Identifier",ret,4,&KMMSubmit);
+ continue;
+ }
+ location = msgId.Locate('\n');
+ if(location > 0)
+ tMMDisplay.iMsgId.Set(msgId.Left(location));
+ else
+ tMMDisplay.iMsgId.Set(msgId);
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,immRsp);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Immediate Response",ret,5,&KMMDisplay);
+ continue;
+ }
+ tMMDisplay.iImmRsp = immRsp;
+
+ iMMDisplay->AppendL(tMMDisplay);
+
+ }
+
+ break;
+ case SIMTSY_SET_FRMS_PCMD_NUMBER:
+ /* Retrieving the information related to the SET FRAMES command */
+
+ iSetFrms = new(ELeave) CArrayFixFlat<TSetFrms>(KSatGranularity);
+ for(i=0;i<setFCount;i++)
+ {
+ item=CfgFile()->Item(KSetFrames,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("destination",ret,0,&KSetFrames);
+ continue;
+ }
+ tSetFrms.iDestn = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Frame Identifier",ret,1,&KSetFrames);
+ }
+ tSetFrms.iFrmId = frameId;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,frmLayout);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Frame Layout",ret,2,&KSetFrames);
+ }
+ tSetFrms.iFrmLayout = frmLayout;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,frmLayoutBuf);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Frame Layout buffer",ret,3,&KSetFrames);
+ }
+ location = frmLayoutBuf.Locate('\n');
+ if(location > 0)
+ tSetFrms.iFrmLayoutBuf.Set(frmLayoutBuf.Left(location));
+ else
+ tSetFrms.iFrmLayoutBuf.Set(frmLayoutBuf);
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,defFrmLayout);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Default Frame Layout",ret,4,&KSetFrames);
+ }
+ tSetFrms.iDefFrmId = defFrmLayout;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,frameSeparator);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Frame Separator",ret,5,&KSetFrames);
+ }
+ tSetFrms.iFrmSeparator = frameSeparator;
+
+ iSetFrms->AppendL(tSetFrms);
+
+ }
+ break;
+ case SIMTSY_GET_FRMS_STS_PCMD_NUMBER:
+ /* Retrieving the information related to the GET FRAMES STATUS command */
+
+ iGetFrmsSts = new(ELeave) CArrayFixFlat<TGetFrmsSts>(KSatGranularity);
+ for(i=0;i<getFSCount;i++)
+ {
+ item=CfgFile()->Item(KGetFramesStatus,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("destination",ret,0,&KGetFramesStatus);
+ continue;
+ }
+ tGetFrmsSts.iDestn = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Frame Id",ret,1,&KGetFramesStatus);
+ continue;
+ }
+ tGetFrmsSts.iFrmId = frameId;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,frmLayoutBuf);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("FrameLayout Buffer",ret,1,&KGetFramesStatus);
+ continue;
+ }
+ location = frmLayoutBuf.Locate('\n');
+ if(location > 0)
+ tGetFrmsSts.iFrmList.Set(frmLayoutBuf.Left(location));
+ else
+ tGetFrmsSts.iFrmList.Set(frmLayoutBuf);
+
+ iGetFrmsSts->AppendL(tGetFrmsSts);
+
+ }
+ break;
+ case SIMTSY_PRV_LCL_INFO_PCMD_NUMBER:
+ /* Retrieving the information regarding PROVIDE LOCAL INFORMATION */
+
+ iLocalInfo = new(ELeave) CArrayFixFlat<TLocalInfo>(KSatGranularity);
+ for(i=0;i<localCount;i++)
+ {
+ item=CfgFile()->Item(KLocalInfo,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Destination",ret,0,&KLocalInfo);
+ continue;
+ }
+ tLocalInfo.iDeviceId = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,infoType);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Information Type",ret,1,&KLocalInfo);
+ continue;
+ }
+ tLocalInfo.iLocalInfoType = infoType;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,utranQlfr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("UTRAN Qlfr",ret,2,&KLocalInfo);
+ continue;
+ }
+ tLocalInfo.iUTRANQlfr = utranQlfr;
+
+ iLocalInfo->AppendL(tLocalInfo);
+
+ }
+ break;
+ case SIMTSY_OPEN_CHAN_PCMD_NUMBER:
+ /* Retrieving the information regarding OPEN CHANNEL command */
+
+ iOpenChn = new(ELeave) CArrayFixFlat<TOpenChannel>(KSatGranularity);
+ for(i=0;i<openCount;i++)
+ {
+ item=CfgFile()->Item(KOpenChnl,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,brType);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Destination",ret,0,&KOpenChnl);
+ continue;
+ }
+ tOpenChn.iBearerType = brType;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,frameId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Information Type",ret,1,&KOpenChnl);
+ continue;
+ }
+ tOpenChn.iFrameId = frameId;
+
+ iOpenChn->AppendL(tOpenChn);
+
+ }
+ break;
+ case SIMTSY_PLAY_TONE_PCMD_NUMBER:
+ case SIMTSY_SETUP_CALL_PCMD_NUMBER:
+ case SIMTSY_GET_INKEY_PCMD_NUMBER:
+ /* Retrieving the information about the miscellaneous commands */
+
+ iMiscCmd = new(ELeave) CArrayFixFlat<TMiscPCmd>(KSatGranularity);
+ for(i=0;i<miscCount;i++)
+ {
+ item=CfgFile()->Item(KMiscCmd,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,frameId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("FrameId",ret,0,&KMiscCmd);
+ continue;
+ }
+ tMiscCmd.iFrameId = frameId;
+
+ iMiscCmd->AppendL(tMiscCmd);
+
+ }
+ break;
+ case SIMTSY_REFRESH_PCMD_NUMBER:
+ /* Retrieving the information about the REFRESH command */
+
+ iRefresh = new(ELeave) CArrayFixFlat<TSatInfo>(KSatGranularity);
+ for(i=0;i<refCount;i++)
+ {
+ item=CfgFile()->Item(KRefresh2,i);
+ if(!item)
+ {
+ break;
+ }
+
+ TInt duration,type;
+ TPtrC8 applId;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("duration",ret,0,&KRefresh2);
+ continue;
+ }
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Refresh Type",ret,1,&KRefresh2);
+ continue;
+ }
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,applId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Application Id",ret,2,&KRefresh2);
+ continue;
+ }
+
+ TSatInfo satInfo;
+ satInfo.iDuration = duration;
+ satInfo.iType = type;
+
+ TInt location = applId.Locate('\n');
+ if(location > 0)
+ satInfo.iFileList.Set(applId.Left(location));
+ else
+ satInfo.iFileList.Set(applId);
+ iRefresh->AppendL(satInfo);
+
+ }
+
+ break;
+ case SIMTSY_SEND_USSD_PCMD_NUMBER:
+ /* Retrieving the information about the SEND USSD command */
+
+ iSendUssd = new(ELeave) CArrayFixFlat<TSendUSSD>(KSatGranularity);
+ for(i=0;i<ussdCount;i++)
+ {
+ item=CfgFile()->Item(KSendUssd,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret= CTestConfig::GetElement(item->Value(),KStdDelimiter,0,textStatus);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attribute Status",ret,0,&KSendUssd);
+ continue;
+ }
+ tSendUssd.iTextAttStatus = textStatus;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,txtAttr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attribute Buffer",ret,1,&KSendUssd);
+ continue;
+ }
+ TInt location = txtAttr.Locate('\n');
+ if(location > 0)
+ tSendUssd.iTextAttBuf.Set(txtAttr.Left(location));
+ else
+ tSendUssd.iTextAttBuf.Set(txtAttr);
+
+ iSendUssd->AppendL(tSendUssd);
+
+ }
+ break;
+ case SIMTSY_LNCH_BRWSR_PCMD_NUMBER:
+ /* Retrieving the information related to the LAUNCH BROWSER command */
+
+ iLnchBrwsr = new(ELeave) CArrayFixFlat<TLnchBrwsr>(KSatGranularity);
+ for(i=0;i<lnchBCount;i++)
+ {
+ item=CfgFile()->Item(KLaunchBrowser,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,frameId);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("FrameId",ret,0,&KLaunchBrowser);
+ continue;
+ }
+ tLnchBrwsr.iFrameId = frameId;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,terRsp);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Terminal Response",ret,1,&KLaunchBrowser);
+ continue;
+ }
+ tLnchBrwsr.iTerRsp = terRsp;
+
+ iLnchBrwsr->AppendL(tLnchBrwsr);
+
+ }
+ break;
+
+ case SIMTSY_USSD_CMD_NUMBER:
+ /* Retrieving the information related to the USSD DATA DOWNLOAD command */
+
+ iUssdData = new(ELeave) CArrayFixFlat<TUssdData>(KSatGranularity);
+ for(i=0;i<ussdDnCount;i++)
+ {
+ item=CfgFile()->Item(KUssdDataDownload,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,src);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Source",ret,0,&KUssdDataDownload);
+ continue;
+ }
+ tUssdData.iSrc = src;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Destination",ret,1,&KUssdDataDownload);
+ continue;
+ }
+ tUssdData.iDestn = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dcs);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Data Coding Scheme",ret,2,&KUssdDataDownload);
+ continue;
+ }
+ tUssdData.iDcs = dcs;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,ussdStr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("USSD String",ret,3,&KUssdDataDownload);
+ continue;
+ }
+ else
+ {
+ TUint16 value;
+
+ if(AsciiToNum(ussdStr, value) == KErrNone)
+ {
+ tUssdData.iUssdStr.SetLength(1);
+ tUssdData.iUssdStr[0] = value;
+ }
+ else
+ {
+ LOGPARSERR("UssdDataDownload::USSD String",KErrArgument,0,&KUssdDataDownload);
+ continue;
+ }
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,UICCRsp);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("UICC Response",ret,4,&KUssdDataDownload);
+ continue;
+ }
+ tUssdData.iUICCRsp = UICCRsp;
+
+ iUssdData->AppendL(tUssdData);
+
+ }
+
+ break;
+ case SIMTSY_EVENT_LIST_CMD_NUMBER:
+ /* Retrieving the information about the EVENT DOWNLOAD command */
+
+ iEventList = new(ELeave) CArrayFixFlat<TEventDnld>(KSatGranularity);
+ for(i=0;i<eventCount;i++)
+ {
+ item=CfgFile()->Item(KEventDnld,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret= CTestConfig::GetElement(item->Value(),KStdDelimiter,0,infoType);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Information Type",ret,0,&KEventDnld);
+ continue;
+ }
+ tEventDnld.iVar = infoType;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,framesList);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Frames List",ret,1,&KEventDnld);
+ continue;
+ }
+ TInt location = framesList.Locate('\n');
+ if(location > 0)
+ tEventDnld.iFrameList.Set(framesList.Left(location));
+ else
+ tEventDnld.iFrameList.Set(framesList);
+
+ iEventList->AppendL(tEventDnld);
+
+ }
+
+ break;
+ case SIMTSY_SENDSS_CMD_NUMBER:
+ /* Retrieving the information about the Send SS command */
+
+ iSendSS = new(ELeave) CArrayFixFlat<TSendUSSD>(KSatGranularity);
+ for(i=0;i<ssCount;i++)
+ {
+ item=CfgFile()->Item(KSendSs,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,textStatus);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attr Status",ret,0,&KSendSs);
+ continue;
+ }
+
+ tSendSS.iTextAttStatus = textStatus;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,txtAttr);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Text Attribute",ret,1,&KSendSs);
+ continue;
+ }
+
+ TInt location = txtAttr.Locate('\n');
+
+ if(location > 0)
+ tSendSS.iTextAttBuf.Set(txtAttr.Left(location));
+ else
+ tSendSS.iTextAttBuf.Set(txtAttr);
+
+ iSendSS->AppendL(tSendSS);
+
+ }
+
+ break;
+ case SIMTSY_ELEMFILES_CMD_NUMBER:
+ /* Retrieving the information about the elementary files change */
+
+ iElemFiles = new(ELeave) CArrayFixFlat<TSatInfo>(KSatGranularity);
+ for(i=0;i<efCount;i++)
+ {
+ item=CfgFile()->Item(KElemFiles,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("duration",ret,0,&KElemFiles);
+ continue;
+ }
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,type);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Refresh Type",ret,1,&KElemFiles);
+ continue;
+ }
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,FileList);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Application Id",ret,2,&KElemFiles);
+ continue;
+ }
+
+ TSatInfo satInfo;
+ satInfo.iDuration = duration;
+ satInfo.iType = type;
+
+ TInt location = FileList.Locate('\n');
+ if(location > 0)
+ satInfo.iFileList.Set(FileList.Left(location));
+ else
+ satInfo.iFileList.Set(FileList);
+ iElemFiles->AppendL(satInfo);
+
+ }
+ break;
+
+ case SIMTSY_MMSNOTIFICATIONDOWNLOAD_CMD_NUMBER:
+ /* Retrieving the information related to the MMS NOTIFICATION DOWNLOAD command */
+ iMmsDownloadData = new (ELeave) CArrayFixFlat<TMmsNotificationDownload>(KSatGranularity);
+
+ for(i=0;i<notfnDCount;i++)
+ {
+ item=CfgFile()->Item(KMmsNotificationDownload,i);
+ if(!item)
+ {
+ break;
+ }
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,src);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Source",ret,0,&KMmsNotificationDownload);
+ continue;
+ }
+ tMmsNotificationDownload.iSrc = src;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,destn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Destination",ret,1,&KMmsNotificationDownload);
+ continue;
+ }
+ tMmsNotificationDownload.iDestn = destn;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,mmsNotfn);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("MMS notification",ret,2,&KMmsNotificationDownload);
+ continue;
+ }
+ location = mmsNotfn.Locate('\n');
+
+ if(location > 0)
+ tMmsNotificationDownload.iMMSNotfn.Copy(mmsNotfn.Left(location));
+ else
+ tMmsNotificationDownload.iMMSNotfn.Copy(mmsNotfn);
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,lastEnv);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("Last envelope",ret,3,&KMmsNotificationDownload);
+ continue;
+ }
+ tMmsNotificationDownload.iLastEnv = lastEnv;
+
+ ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,UICCRsp);
+ if(ret!=KErrNone)
+ {
+ LOGPARSERR("UICC Response",ret,4,&KMmsNotificationDownload);
+ continue;
+ }
+ tMmsNotificationDownload.iUICCRsp = UICCRsp;
+
+ iMmsDownloadData->AppendL(tMmsNotificationDownload);
+ }
+ break;
+ default:
+ LOGMISC1("Unknown command to process");
+ return KErrNotSupported;
+
+ }
+ return KErrNone;
+
+
+ }
+