diff -r 000000000000 -r 3553901f7fa8 telephonyserver/etelsimtoolkit/dtsy/sattsy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserver/etelsimtoolkit/dtsy/sattsy.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,5610 @@ +// Copyright (c) 2002-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: +// Dummy Sat TSY classes implementation. +// +// + +/** + @file +*/ +#include "sattsy.h" +#include "testdef.h" +#include "Etelsat.h" +#include +#include "Dsatlog.h" +#include +#include + +#include "coretsy.h" + +/**************************************************************************/ +// +// CSatDSatTsy +// +/**************************************************************************/ + +CSatDSatTsy* CSatDSatTsy::NewL(CPhoneFactoryDummyBase* aFac) + { + CSatDSatTsy* subsession=new(ELeave) CSatDSatTsy(aFac); + CleanupStack::PushL(subsession); + subsession->ConstructL(); + CleanupStack::Pop(); + return subsession; + } + +void CSatDSatTsy::Init() + {} + +CSatDSatTsy::CSatDSatTsy(CPhoneFactoryDummyBase* aFac) + :CSubSessionExtDummyBase(aFac) + { + iTsyAsyncReqHandle=0; + iNotifyCallControlRequest=0; + iNotifyMoSmControlRequest=0; + iNotifyDisplayTextPCmd=0; + iNotifyGetInkeyPCmd=0; + iNotifyGetInputPCmd=0; + iNotifyPlayTonePCmd=0; + iNotifySetUpMenuPCmd=0; + iNotifySelectItemPCmd=0; + iNotifySendSmPCmd=0; + iNotifySendSsPCmd=0; + iNotifySendUssdPCmd=0; + iNotifySetUpCallPCmd=0; + iNotifyRefreshPCmd=0; + iNotifySetUpEventListPCmd=0; + iNotifySetUpIdleModeTextPCmd=0; + iNotifySendDtmfPCmd=0; + iGetIcon=0; + iGetImageInstance=0; + iGetClut=0; + iDisplayTextTerminalRsp=0; + iGetInkeyTerminalRsp=0; + iGetInputTerminalRsp=0; + iPlayToneTerminalRsp=0; + iSetUpMenuTerminalRsp=0; + iSelectItemTerminalRsp=0; + iSendSmTerminalRsp=0; + iSendSsTerminalRsp=0; + iSendUssdTerminalRsp=0; + iSetUpCallTerminalRsp=0; + iRefreshTerminalRsp=0; + iSetUpEventListTerminalRsp=0; + iSetUpIdleModeTextTerminalRsp=0; + iSendDtmfTerminalRsp=0; + iGetMeSideSatProfile=0; + iClientSatProfileIndication=0; + iMenuSelection=0; + iEventDownload=0; + iNotifyPerformCardApduPCmd=0; + iNotifyPowerOffCardPCmd=0; + iNotifyPowerOnCardPCmd=0; + iNotifyGetReaderStatusPCmd=0; + iNotifyRunAtCommandPCmd=0; + iNotifyLanguageNotificationPCmd=0; + iGetProvisioningRefFile=0; + iNotifyOpenChannelPCmd=0; + iNotifyCloseChannelPCmd=0; + iNotifyReceiveDataPCmd=0; + iNotifySendDataPCmd=0; + iNotifyGetChannelStatusPCmd=0; + iNotifyServiceSearchPCmd=0; + iNotifyGetServiceInfoPCmd=0; + iNotifyDeclareServicePCmd=0; + iNotifyLaunchBrowserPCmd=0; + iNotifyLaunchBrowserCount=0; + iNotifySetUpMenuTestNumber=0; + iNotifyCallControlRequestTestNumber=0; + iNotifyOpenChannelTestNumber=0; + iSendMessageNoLogging=0; + iNotifyProactiveSimSessionEnd=0; + iNotifyProactiveSimSessionStart=0; + iNotifyTimerExpiration=0; + iNotifySmsPpDownload=0; + iNotifyCbDownload=0; + iNotifyTimerManagtPCmd=0; + iNotifyLocalInfoPCmd=0; + iNotifyPollingIntervalPCmd=0; + iNotifyPollingOffPCmd=0; + iTimerMgmtTerminalRsp=0; + iLocalInfoTerminalRsp=0; + iPollingIntervalTerminalRsp=0; + iPollingOffTerminalRsp=0; + iNotifyTsyStateUpdated=0; + iNotifyRefreshRequired=0; + iRefreshAllowed=0; + iNotifyRetrieveMultimediaMsgPCmd=0; + iNotifySubmitMultimediaMsgPCmd=0; + iNotifyDisplayMultimediaMsgPCmd=0; + iNotifySetFramesPCmd=0; + iNotifyGetFramesStatusPCmd=0; + iRetrieveMultimediaMsgTerminalRsp=0; + iSubmitMultimediaMsgTerminalRsp=0; + iDisplayMultimediaMsgTerminalRsp=0; + iSetFramesTerminalRsp=0; + iGetFramesStatusTerminalRsp=0; + iMmsNotificationDownload=0; + iMmsTransferStatus=0; + iUssdDataDownload=0; + } + +void CSatDSatTsy::ConstructL() + { + LOGTEXT(_L8("CSatDSatTsy: Entered constructor")); + } + +CSatDSatTsy::~CSatDSatTsy() + { + LOGTEXT(_L8("CSatDSatTsy: Entered destructor")); + } + +CTelObject* CSatDSatTsy::OpenNewObjectByNameL(const TDesC& /*aName*/) +/** +* Opening object(s) from RSat is not supported +*/ + { + User::Leave(KErrNotSupported); + return NULL; + } + +CTelObject* CSatDSatTsy::OpenNewObjectL(TDes& /*aNewName*/) +/** +* Opening object(s) from RSat is not supported +*/ + { + User::Leave(KErrNotSupported); + return NULL; + } + +CTelObject::TReqMode CSatDSatTsy::ReqModeL(const TInt aIpc) +/** +* ReqModeL is called from the server's CTelObject::ReqAnalyserL +* in order to check the type of request it has. +* +* The following are example request types for this dummy TSY +* All TSYs do not have to have these request types but they have been given +* "sensible" values in this test code +*/ + { + CTelObject::TReqMode ret=0; + switch (aIpc) + { + case ESatNotifyProactiveSimSessionStart: + case ESatNotifyProactiveSimSessionEnd: + case ESatNotifyCallControlRequest: + case ESatNotifyMoSmControlRequest: + case ESatNotifyDisplayTextPCmd: + case ESatNotifyGetInkeyPCmd: + case ESatNotifyGetInputPCmd: + case ESatNotifyPlayTonePCmd: + case ESatNotifySetUpMenuPCmd: + case ESatNotifySelectItemPCmd: + case ESatNotifySendSmPCmd: + case ESatNotifySendSsPCmd: + case ESatNotifySendUssdPCmd: + case ESatNotifySetUpCallPCmd: + case ESatNotifyRefreshPCmd: + case ESatNotifySetUpEventListPCmd: + case ESatNotifySetUpIdleModeTextPCmd: + case ESatNotifySendDtmfPCmd: + case ESatNotifyPerformCardApduPCmd: + case ESatNotifyPowerOffCardPCmd: + case ESatNotifyPowerOnCardPCmd: + case ESatNotifyGetReaderStatusPCmd: + case ESatNotifyRunAtCommandPCmd: + case ESatNotifyLanguageNotificationPCmd: + case ESatNotifyLaunchBrowserPCmd: + case ESatNotifyOpenChannelPCmd: + case ESatNotifyCloseChannelPCmd: + case ESatNotifyReceiveDataPCmd: + case ESatNotifySendDataPCmd: + case ESatNotifyGetChannelStatusPCmd: + case ESatNotifyServiceSearchPCmd: + case ESatNotifyGetServiceInfoPCmd: + case ESatNotifyDeclareServicePCmd: + case ESatNotifyTimerExpiration: + case ESatNotifySmsPpDownload: + case ESatNotifyCbDownload: + case ESatNotifyTimerMgmtPCmd: + case ESatNotifyLocalInfoPCmd: + case ESatNotifyPollingIntervalPCmd: + case ESatNotifyPollingOffPCmd: + case ESatNotifyTsyStateUpdated: + case ESatNotifyRefreshRequired: + case ESatNotifyRefreshRequiredParam: + case ESatNotifyRetrieveMultimediaMsgPCmd: + case ESatNotifySubmitMultimediaMsgPCmd: + case ESatNotifyDisplayMultimediaMsgPCmd: + case ESatNotifySetFramesPCmd: + case ESatNotifyGetFramesStatusPCmd: + ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately; + break; + + case ESatGetIcon: + case ESatGetImageInstance: + case ESatGetClut: + case ESatTerminalRsp: + case ESatGetMeSideSatProfile: + case ESatClientSatProfileIndication: + case ESatMenuSelection: + case ESatEventDownload: + case ESatUsatClientReadyIndication: + case ESatGetProvisioningRefFile: + case ESatSendMessageNoLogging: + case ESatRefreshAllowed: + case ETestCustomIPC1: + case ESatGetOpenChannelPCmd: + case ESatMmsNotificationDownload: + case ESatMmsTransferStatus: + case ESatUssdDataDownload: + break; + + case ESatNotifyProactiveSimSessionStartCancel: + case ESatNotifyProactiveSimSessionEndCancel: + case ESatGetIconCancel: + case ESatGetImageInstanceCancel: + case ESatGetClutCancel: + case ESatTerminalRspCancel: + case ESatGetMeSideSatProfileCancel: + case ESatMenuSelectionCancel: + case ESatNotifyCallControlRequestCancel: + case ESatNotifyMoSmControlRequestCancel: + case ESatEventDownloadCancel: + case ESatNotifyDisplayTextPCmdCancel: + case ESatNotifyGetInkeyPCmdCancel: + case ESatNotifyGetInputPCmdCancel: + case ESatNotifyPlayTonePCmdCancel: + case ESatNotifySetUpMenuPCmdCancel: + case ESatNotifySelectItemPCmdCancel: + case ESatNotifySendSmPCmdCancel: + case ESatNotifySendSsPCmdCancel: + case ESatNotifySendUssdPCmdCancel: + case ESatNotifySetUpCallPCmdCancel: + case ESatNotifyRefreshPCmdCancel: + case ESatNotifySetUpEventListPCmdCancel: + case ESatNotifySetUpIdleModeTextPCmdCancel: + case ESatNotifySendDtmfPCmdCancel: + case ESatGetProvisioningRefFileCancel: + case ESatNotifyPerformCardApduPCmdCancel: + case ESatNotifyPowerOffCardPCmdCancel: + case ESatNotifyPowerOnCardPCmdCancel: + case ESatNotifyGetReaderStatusPCmdCancel: + case ESatNotifyRunAtCommandPCmdCancel: + case ESatNotifyLanguageNotificationPCmdCancel: + case ESatNotifyLaunchBrowserPCmdCancel: + case ESatNotifyOpenChannelPCmdCancel: + case ESatNotifyCloseChannelPCmdCancel: + case ESatNotifyReceiveDataPCmdCancel: + case ESatNotifySendDataPCmdCancel: + case ESatNotifyGetChannelStatusPCmdCancel: + case ESatNotifyServiceSearchPCmdCancel: + case ESatNotifyGetServiceInfoPCmdCancel: + case ESatNotifyDeclareServicePCmdCancel: + case ESatSendMessageNoLoggingCancel: + case ESatNotifyTimerExpirationCancel: + case ESatNotifySmsPpDownloadCancel: + case ESatNotifyCbDownloadCancel: + case ESatNotifyTimerMgmtPCmdCancel: + case ESatNotifyLocalInfoPCmdCancel: + case ESatNotifyPollingIntervalPCmdCancel: + case ESatNotifyPollingOffPCmdCancel: + case ESatNotifyTsyStateUpdatedCancel: + case ESatNotifyRefreshRequiredCancel: + case ESatRefreshAllowedCancel: + case ESatNotifyRefreshRequiredParamCancel: + case ESatGetOpenChannelPCmdCancel: + case ESatNotifyRetrieveMultimediaMsgPCmdCancel: + case ESatNotifySubmitMultimediaMsgPCmdCancel: + case ESatNotifyDisplayMultimediaMsgPCmdCancel: + case ESatNotifySetFramesPCmdCancel: + case ESatNotifyGetFramesStatusPCmdCancel: + case ESatMmsNotificationDownloadCancel: + case ESatMmsTransferStatusCancel: + case ESatUssdDataDownloadCancel: + // The server should not use ReqMode on Cancel requests + User::Leave(KErrNotSupported); + break; + + default: + User::Leave(KErrNotSupported); + break; + } + return ret; + } + +TInt CSatDSatTsy::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 +*/ + { + switch (aIpc) + { + case ESatNotifyProactiveSimSessionStart: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Proactive Sim Session Start")); + return KErrNone; + case ESatNotifyProactiveSimSessionEnd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Proactive Sim Session Stop")); + return KErrNone; + case ESatNotifyCallControlRequest: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Call Control Request")); + return KErrNone; + case ESatNotifyMoSmControlRequest: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - MO SM Control Request")); + return KErrNone; + case ESatNotifyDisplayTextPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Display Text PCmd")); + return KErrNone; + case ESatNotifyGetInkeyPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Get Inkey PCmd")); + return KErrNone; + case ESatNotifyGetInputPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Get Input PCmd")); + return KErrNone; + case ESatNotifyPlayTonePCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Play Tone PCmd")); + return KErrNone; + case ESatNotifySetUpMenuPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Set Up Menu PCmd")); + return KErrNone; + case ESatNotifySelectItemPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Select Item PCmd")); + return KErrNone; + case ESatNotifySendSmPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Send SM PCmd")); + return KErrNone; + case ESatNotifySendSsPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Send SS PCmd")); + return KErrNone; + case ESatNotifySendUssdPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Send USSD PCmd")); + return KErrNone; + case ESatNotifySetUpCallPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Set Up Call PCmd")); + return KErrNone; + case ESatNotifyRefreshPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Refresh PCmd")); + return KErrNone; + case ESatNotifySetUpEventListPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Set Up Event List PCmd")); + return KErrNone; + case ESatNotifySetUpIdleModeTextPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Set Up Idle Mode Text PCmd")); + return KErrNone; + case ESatNotifySendDtmfPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Send DTMF PCmd")); + return KErrNone; + case ESatNotifyPerformCardApduPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Perform Card APDU")); + return KErrNone; + case ESatNotifyPowerOffCardPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Power Off Card")); + return KErrNone; + case ESatNotifyPowerOnCardPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Power On Card")); + return KErrNone; + case ESatNotifyGetReaderStatusPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Get Reader Status")); + return KErrNone; + case ESatNotifyRunAtCommandPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Run AT Command")); + return KErrNone; + case ESatNotifyLanguageNotificationPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Language Notification")); + return KErrNone; + case ESatNotifyLaunchBrowserPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Launch Browser")); + return KErrNone; + case ESatNotifyOpenChannelPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Open Channel")); + return KErrNone; + case ESatNotifyCloseChannelPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Close Channel")); + return KErrNone; + case ESatNotifyReceiveDataPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Receive Data")); + return KErrNone; + case ESatNotifySendDataPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Send Data")); + return KErrNone; + case ESatNotifyGetChannelStatusPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Get Channel Status")); + return KErrNone; + case ESatNotifyServiceSearchPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Service Search")); + return KErrNone; + case ESatNotifyGetServiceInfoPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Get Service Info")); + return KErrNone; + case ESatNotifyDeclareServicePCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Declare Service")); + return KErrNone; + case ESatNotifyTimerExpiration: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Timer expiration")); + return KErrNone; + case ESatNotifySmsPpDownload: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Sms PP Dowmload")); + return KErrNone; + case ESatNotifyCbDownload: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - CB Download")); + return KErrNone; + case ESatNotifyTimerMgmtPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Timer Managt")); + return KErrNone; + case ESatNotifyLocalInfoPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Local Info")); + return KErrNone; + case ESatNotifyPollingIntervalPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Polling Interval")); + return KErrNone; + case ESatNotifyPollingOffPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Polling Pff")); + return KErrNone; + case ESatNotifyTsyStateUpdated: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - TSY State Updated")); + return KErrNone; + case ESatNotifyRefreshRequired: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Refresh Required")); + return KErrNone; + case ESatNotifyRefreshRequiredParam: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Refresh Required Param")); + return KErrNone; + case ESatNotifyRetrieveMultimediaMsgPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Retrieve Multimedia Message")); + return KErrNone; + case ESatNotifySubmitMultimediaMsgPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Submit Multimedia Message")); + return KErrNone; + case ESatNotifyDisplayMultimediaMsgPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Display Multimedia Message")); + return KErrNone; + case ESatNotifySetFramesPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Set Frames")); + return KErrNone; + case ESatNotifyGetFramesStatusPCmd: + LOGTEXT(_L8("CSatDSatTsy: RegisterNotification - Get Frames Status")); + return KErrNone; + default: + // Unknown or invalid IPC + LOGTEXT(_L8("CSatDSatTsy: Register error, unknown IPC")); + return KErrNotSupported; + } + } + +TInt CSatDSatTsy::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 +*/ + { + switch (aIpc) + { + case ESatNotifyProactiveSimSessionStart: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Proactive Sim Session Start")); + return KErrNone; + case ESatNotifyProactiveSimSessionEnd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Proactive Sim Session Stop")); + return KErrNone; + case ESatNotifyCallControlRequest: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Call Control Request")); + return KErrNone; + case ESatNotifyMoSmControlRequest: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - MO SM Control Request")); + return KErrNone; + case ESatNotifyDisplayTextPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Display Text PCmd")); + return KErrNone; + case ESatNotifyGetInkeyPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Get Inkey PCmd")); + return KErrNone; + case ESatNotifyGetInputPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Get Input PCmd")); + return KErrNone; + case ESatNotifyPlayTonePCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Play Tone PCmd")); + return KErrNone; + case ESatNotifySetUpMenuPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Set Up Menu PCmd")); + return KErrNone; + case ESatNotifySelectItemPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Select Item PCmd")); + return KErrNone; + case ESatNotifySendSmPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Send SM PCmd")); + return KErrNone; + case ESatNotifySendSsPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Send SS PCmd")); + return KErrNone; + case ESatNotifySendUssdPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Send USSD PCmd")); + return KErrNone; + case ESatNotifySetUpCallPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Set Up Call PCmd")); + return KErrNone; + case ESatNotifyRefreshPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Refresh PCmd")); + return KErrNone; + case ESatNotifySetUpEventListPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Set Up Event List PCmd")); + return KErrNone; + case ESatNotifySetUpIdleModeTextPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Set Up Idle Mode Text PCmd")); + return KErrNone; + case ESatNotifySendDtmfPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Send DTMF PCmd")); + return KErrNone; + case ESatNotifyPerformCardApduPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Perform Card APDU")); + return KErrNone; + case ESatNotifyPowerOffCardPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Power Off Card")); + return KErrNone; + case ESatNotifyPowerOnCardPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Power On Card")); + return KErrNone; + case ESatNotifyGetReaderStatusPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Get Reader Status")); + return KErrNone; + case ESatNotifyRunAtCommandPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Run AT Command")); + return KErrNone; + case ESatNotifyLanguageNotificationPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Language Notification")); + return KErrNone; + case ESatNotifyLaunchBrowserPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Launch Browser")); + return KErrNone; + case ESatNotifyOpenChannelPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Open Channel")); + return KErrNone; + case ESatNotifyCloseChannelPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Close Channel")); + return KErrNone; + case ESatNotifyReceiveDataPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Receive Data")); + return KErrNone; + case ESatNotifySendDataPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Send Data")); + return KErrNone; + case ESatNotifyGetChannelStatusPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Get Channel Status")); + return KErrNone; + case ESatNotifyServiceSearchPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Service Search")); + return KErrNone; + case ESatNotifyGetServiceInfoPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Get Service Info")); + return KErrNone; + case ESatNotifyDeclareServicePCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Declare Service")); + return KErrNone; + case ESatNotifyTimerExpiration: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Timer expiration")); + return KErrNone; + case ESatNotifySmsPpDownload: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Sms PP Dowmload")); + return KErrNone; + case ESatNotifyCbDownload: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - CB Download")); + return KErrNone; + case ESatNotifyTimerMgmtPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Timer Managt")); + return KErrNone; + case ESatNotifyLocalInfoPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Local Info")); + return KErrNone; + case ESatNotifyPollingIntervalPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Polling Interval")); + return KErrNone; + case ESatNotifyPollingOffPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Polling Pff")); + return KErrNone; + case ESatNotifyTsyStateUpdated: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - TSY State Updated")); + return KErrNone; + case ESatNotifyRefreshRequired: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Refresh Required")); + return KErrNone; + case ESatNotifyRefreshRequiredParam: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Refresh Required Param")); + return KErrNone; + case ESatNotifyRetrieveMultimediaMsgPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Retrieve Multimedia Message")); + return KErrNone; + case ESatNotifySubmitMultimediaMsgPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Submit Multimedia Message")); + return KErrNone; + case ESatNotifyDisplayMultimediaMsgPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Display Multimedia Message")); + return KErrNone; + case ESatNotifySetFramesPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Set Frames")); + return KErrNone; + case ESatNotifyGetFramesStatusPCmd: + LOGTEXT(_L8("CSatDSatTsy: De-registerNotification - Get Frames Status")); + return KErrNone; + default: + // Unknown or invalid IPC + LOGTEXT(_L8("CSatDSatTsy: Deregister error, unknown IPC")); + return KErrNotSupported; + } + } + +TInt CSatDSatTsy::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 +*/ + { + TInt numberOfSlots=1; + switch (aIpc) + { + case ESatNotifyProactiveSimSessionStart: + case ESatNotifyProactiveSimSessionEnd: + LOGTEXT(_L8("CSatDSatTsy: Registered with 1 slot")); + numberOfSlots=1; + break; + + case ESatNotifyCallControlRequest: + case ESatNotifyMoSmControlRequest: + case ESatNotifyDisplayTextPCmd: + case ESatNotifyGetInkeyPCmd: + case ESatNotifyGetInputPCmd: + case ESatNotifyPlayTonePCmd: + case ESatNotifySetUpMenuPCmd: + case ESatNotifySelectItemPCmd: + case ESatNotifySendSmPCmd: + case ESatNotifySendSsPCmd: + case ESatNotifySendUssdPCmd: + case ESatNotifySetUpCallPCmd: + case ESatNotifyRefreshPCmd: + case ESatNotifySetUpEventListPCmd: + case ESatNotifySetUpIdleModeTextPCmd: + case ESatNotifySendDtmfPCmd: + case ESatNotifyPerformCardApduPCmd: + case ESatNotifyPowerOffCardPCmd: + case ESatNotifyPowerOnCardPCmd: + case ESatNotifyGetReaderStatusPCmd: + case ESatNotifyRunAtCommandPCmd: + case ESatNotifyLanguageNotificationPCmd: + case ESatNotifyLaunchBrowserPCmd: + case ESatNotifyOpenChannelPCmd: + case ESatNotifyCloseChannelPCmd: + case ESatNotifyReceiveDataPCmd: + case ESatNotifySendDataPCmd: + case ESatNotifyGetChannelStatusPCmd: + case ESatNotifyServiceSearchPCmd: + case ESatNotifyGetServiceInfoPCmd: + case ESatNotifyDeclareServicePCmd: + case ESatNotifyTimerExpiration: + case ESatNotifySmsPpDownload: + case ESatNotifyCbDownload: + case ESatNotifyTimerMgmtPCmd: + case ESatNotifyLocalInfoPCmd: + case ESatNotifyPollingIntervalPCmd: + case ESatNotifyPollingOffPCmd: + case ESatNotifyTsyStateUpdated: + case ESatNotifyRefreshRequired: + case ESatNotifyRefreshRequiredParam: + case ESatNotifyRetrieveMultimediaMsgPCmd: + case ESatNotifySubmitMultimediaMsgPCmd: + case ESatNotifyDisplayMultimediaMsgPCmd: + case ESatNotifySetFramesPCmd : + case ESatNotifyGetFramesStatusPCmd: + LOGTEXT(_L8("CSatDSatTsy: Registered with 2 slot")); + numberOfSlots=2; + break; + default: + // Unknown or invalid IPC + LOGTEXT(_L8("CSatDSatTsy: Number of Slots error, unknown IPC")); + User::Leave(KErrNotSupported); + break; + } + return numberOfSlots; + } + + +TInt CSatDSatTsy::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 +*/ + { + TAny* dataPtr=aPackage.Ptr1(); + TAny* dataPtr2=aPackage.Ptr2(); + + switch (aIpc) + { + case ESatNotifyProactiveSimSessionStart: + return NotifyProactiveSimSessionStart(aTsyReqHandle); + case ESatNotifyProactiveSimSessionEnd: + return NotifyProactiveSimSessionEnd(aTsyReqHandle); + case ESatNotifyCallControlRequest: + return NotifyCallControlRequest(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyMoSmControlRequest: + return NotifyMoSmControlRequest(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyDisplayTextPCmd: + return NotifyDisplayTextPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyGetInkeyPCmd: + return NotifyGetInkeyPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyGetInputPCmd: + return NotifyGetInputPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyPlayTonePCmd: + return NotifyPlayTonePCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySetUpMenuPCmd: + return NotifySetUpMenuPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySelectItemPCmd: + return NotifySelectItemPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySendSmPCmd: + return NotifySendSmPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySendSsPCmd: + return NotifySendSsPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySendUssdPCmd: + return NotifySendUssdPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySetUpCallPCmd: + return NotifySetUpCallPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyRefreshPCmd: + return NotifyRefreshPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySetUpEventListPCmd: + return NotifySetUpEventListPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySetUpIdleModeTextPCmd: + return NotifySetUpIdleModeTextPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySendDtmfPCmd: + return NotifySendDtmfPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatGetIcon: + return GetIcon(aTsyReqHandle, + REINTERPRET_CAST(TUint8*, dataPtr), + REINTERPRET_CAST(RSat::TIcon*, dataPtr2)); + case ESatGetImageInstance: + return GetImageInstance(aTsyReqHandle, + aPackage.Des1n(), + aPackage.Des2n()); + case ESatGetClut: + return GetClut(aTsyReqHandle, + REINTERPRET_CAST(RSat::TInstanceNumberAndOffset*, dataPtr), + aPackage.Des2n()); + case ESatTerminalRsp: + return TerminalRsp(aTsyReqHandle, + REINTERPRET_CAST(RSat::TPCmd*, dataPtr),aPackage.Des2n()); + case ESatGetMeSideSatProfile: + return GetMeSideSatProfile(aTsyReqHandle, aPackage.Des1n()); + case ESatClientSatProfileIndication: + return ClientSatProfileIndication(aTsyReqHandle, aPackage.Des1n()); + case ESatMenuSelection: + return MenuSelection(aTsyReqHandle, aPackage.Des1n()); + case ESatEventDownload: + return EventDownload(aTsyReqHandle, + REINTERPRET_CAST(RSat::TEventList*, dataPtr), + aPackage.Des2n()); + case ESatRefreshAllowed: + return RefreshAllowed(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyPerformCardApduPCmd: + return NotifyPerformCardApduPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyPowerOffCardPCmd: + return NotifyPowerOffCardPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyPowerOnCardPCmd: + return NotifyPowerOnCardPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyGetReaderStatusPCmd: + return NotifyGetReaderStatusPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyRunAtCommandPCmd: + return NotifyRunAtCommandPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyLanguageNotificationPCmd: + return NotifyLanguageNotificationPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyLaunchBrowserPCmd: + return NotifyLaunchBrowserPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyOpenChannelPCmd: + return NotifyOpenChannelPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatGetOpenChannelPCmd: + return GetOpenChannelPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyCloseChannelPCmd: + return NotifyCloseChannelPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyReceiveDataPCmd: + return NotifyReceiveDataPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySendDataPCmd: + return NotifySendDataPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyGetChannelStatusPCmd: + return NotifyGetChannelStatusPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyServiceSearchPCmd: + return NotifyServiceSearchPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyGetServiceInfoPCmd: + return NotifyGetServiceInfoPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyDeclareServicePCmd: + return NotifyDeclareServicePCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatUsatClientReadyIndication: + return UsatClientReadyIndication(aTsyReqHandle); + case ESatGetProvisioningRefFile: + return GetProvisioningRefFile(aTsyReqHandle, + REINTERPRET_CAST(RSat::TProvisioningFileRef*, dataPtr), + aPackage.Des2n()); + case ESatSendMessageNoLogging: + return SendMessageNoLogging(aTsyReqHandle, + aPackage.Des1n(), + REINTERPRET_CAST(TUint16*, dataPtr2)); + case ESatNotifyTimerExpiration: + return NotifyTimerExpiration(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifySmsPpDownload: + return NotifySmsPpDownload(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyCbDownload: + return NotifyCbDownload(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyTimerMgmtPCmd: + return NotifyTimerManagtPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyLocalInfoPCmd: + return NotifyLocalInfoPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyPollingIntervalPCmd: + return NotifyPollingIntervalPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyPollingOffPCmd: + return NotifyPollingOffPCmd(aTsyReqHandle, aPackage.Des1n()); + case ESatNotifyTsyStateUpdated: + return NotifyTsyStateUpdated(aTsyReqHandle, + REINTERPRET_CAST(RSat::TPCmd*, dataPtr)); + case ESatNotifyRefreshRequired: + return NotifyRefreshRequired(aTsyReqHandle); + case ESatNotifyRefreshRequiredParam: + return NotifyRefreshRequired(aTsyReqHandle, aPackage.Des1n()); + case ETestCustomIPC1: + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + 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 ESatMmsNotificationDownload: + return MmsNotificationDownload(aTsyReqHandle, aPackage.Des1n()); + case ESatMmsTransferStatus: + return MmsTransferStatus(aTsyReqHandle, aPackage.Des1n()); + case ESatUssdDataDownload : + return UssdDataDownload(aTsyReqHandle, aPackage.Des1n()); + default: + return KErrNotSupported; + } + } + +TInt CSatDSatTsy::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. +* +* CancelService is also called when individual cancel methods are called by the client, +* who wishes to cancel an outstanding asynchronous request. +* +* This will happen if a client closes its R-class handle without cancelling outstanding +* asynchronous requests. +*/ + { + LOGTEXT(_L8("CSatDSatTsy: - CancelService called")); + switch (aIpc) + { + case ESatNotifyProactiveSimSessionEnd: + return NotifyProactiveSimSessionEndCancel(aTsyReqHandle); + case ESatNotifyProactiveSimSessionStart: + return NotifyProactiveSimSessionStartCancel(aTsyReqHandle); + case ESatGetIcon: + return GetIconCancel(aTsyReqHandle); + case ESatGetImageInstance: + return GetImageInstanceCancel(aTsyReqHandle); + case ESatGetClut: + return GetClutCancel(aTsyReqHandle); + case ESatTerminalRsp: + return TerminalRspCancel(aTsyReqHandle); + case ESatGetMeSideSatProfile: + return GetMeSideSatProfileCancel(aTsyReqHandle); + case ESatMenuSelection: + return MenuSelectionCancel(aTsyReqHandle); + case ESatRefreshAllowed: + return RefreshAllowedCancel(aTsyReqHandle); + case ESatNotifyCallControlRequest: + return NotifyCallControlRequestCancel(aTsyReqHandle); + case ESatNotifyMoSmControlRequest: + return NotifyMoSmControlRequestCancel(aTsyReqHandle); + case ESatEventDownload: + return EventDownloadCancel(aTsyReqHandle); + case ESatNotifyDisplayTextPCmd: + return NotifyDisplayTextPCmdCancel(aTsyReqHandle); + case ESatNotifyGetInkeyPCmd: + return NotifyGetInkeyPCmdCancel(aTsyReqHandle); + case ESatNotifyGetInputPCmd: + return NotifyGetInputPCmdCancel(aTsyReqHandle); + case ESatNotifyPlayTonePCmd: + return NotifyPlayTonePCmdCancel(aTsyReqHandle); + case ESatNotifySetUpMenuPCmd: + return NotifySetUpMenuPCmdCancel(aTsyReqHandle); + case ESatNotifySelectItemPCmd: + return NotifySelectItemPCmdCancel(aTsyReqHandle); + case ESatNotifySendSmPCmd: + return NotifySendSmPCmdCancel(aTsyReqHandle); + case ESatNotifySendSsPCmd: + return NotifySendSsPCmdCancel(aTsyReqHandle); + case ESatNotifySendUssdPCmd: + return NotifySendUssdPCmdCancel(aTsyReqHandle); + case ESatNotifySetUpCallPCmd: + return NotifySetUpCallPCmdCancel(aTsyReqHandle); + case ESatNotifyRefreshPCmd: + return NotifyRefreshPCmdCancel(aTsyReqHandle); + case ESatNotifySetUpEventListPCmd: + return NotifySetUpEventListPCmdCancel(aTsyReqHandle); + case ESatNotifySetUpIdleModeTextPCmd: + return NotifySetUpIdleModeTextPCmdCancel(aTsyReqHandle); + case ESatNotifySendDtmfPCmd: + return NotifySendDtmfPCmdCancel(aTsyReqHandle); + case ESatNotifyPerformCardApduPCmd: + return NotifyPerformCardApduPCmdCancel(aTsyReqHandle); + case ESatNotifyPowerOffCardPCmd: + return NotifyPowerOffCardPCmdCancel(aTsyReqHandle); + case ESatNotifyPowerOnCardPCmd: + return NotifyPowerOnCardPCmdCancel(aTsyReqHandle); + case ESatNotifyGetReaderStatusPCmd: + return NotifyGetReaderStatusPCmdCancel(aTsyReqHandle); + case ESatNotifyRunAtCommandPCmd: + return NotifyRunAtCommandPCmdCancel(aTsyReqHandle); + case ESatNotifyLanguageNotificationPCmd: + return NotifyLanguageNotificationPCmdCancel(aTsyReqHandle); + case ESatNotifyLaunchBrowserPCmd: + return NotifyLaunchBrowserPCmdCancel(aTsyReqHandle); + case ESatNotifyOpenChannelPCmd: + return NotifyOpenChannelPCmdCancel(aTsyReqHandle); + case ESatGetOpenChannelPCmd: + return GetOpenChannelPCmdCancel(aTsyReqHandle); + case ESatNotifyCloseChannelPCmd: + return NotifyCloseChannelPCmdCancel(aTsyReqHandle); + case ESatNotifyReceiveDataPCmd: + return NotifyReceiveDataPCmdCancel(aTsyReqHandle); + case ESatNotifySendDataPCmd: + return NotifySendDataPCmdCancel(aTsyReqHandle); + case ESatNotifyGetChannelStatusPCmd: + return NotifyGetChannelStatusPCmdCancel(aTsyReqHandle); + case ESatNotifyServiceSearchPCmd: + return NotifyServiceSearchPCmdCancel(aTsyReqHandle); + case ESatNotifyGetServiceInfoPCmd: + return NotifyGetServiceInfoPCmdCancel(aTsyReqHandle); + case ESatNotifyDeclareServicePCmd: + return NotifyDeclareServicePCmdCancel(aTsyReqHandle); + case ESatGetProvisioningRefFile: + return GetProvisioningRefFileCancel(aTsyReqHandle); + case ESatSendMessageNoLogging: + return SendMessageNoLoggingCancel(aTsyReqHandle); + case ESatNotifyTimerExpiration: + return NotifyTimerExpirationCancel(aTsyReqHandle); + case ESatNotifySmsPpDownload: + return NotifySmsPpDownloadCancel(aTsyReqHandle); + case ESatNotifyCbDownload: + return NotifyCbDownloadCancel(aTsyReqHandle); + case ESatNotifyTimerMgmtPCmd: + return NotifyTimerManagtPCmdCancel(aTsyReqHandle); + case ESatNotifyLocalInfoPCmd: + return NotifyLocalInfoPCmdCancel(aTsyReqHandle); + case ESatNotifyPollingIntervalPCmd: + return NotifyPollingIntervalPCmdCancel(aTsyReqHandle); + case ESatNotifyPollingOffPCmd: + return NotifyPollingOffPCmdCancel(aTsyReqHandle); + case ESatNotifyTsyStateUpdated: + return NotifyTsyStateUpdatedCancel(aTsyReqHandle); + case ESatNotifyRefreshRequired: + return NotifyRefreshRequiredCancel(aTsyReqHandle); + case ESatNotifyRefreshRequiredParam: + return NotifyRefreshRequiredCancel(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 ESatMmsNotificationDownload: + return MmsNotificationDownloadCancel(aTsyReqHandle); + case ESatMmsTransferStatus: + return MmsTransferStatusCancel(aTsyReqHandle); + case ESatUssdDataDownload: + return UssdDataDownloadCancel(aTsyReqHandle); + default: + return KErrGeneral; + } + } + + +/***********************************************************************************/ +// +// The following methods are called from ExtFunc and/or CancelService. +// Each of these will process a TSY request or cancel a TSY request +// Here, example values are returned or checked within this dummy TSY in order to ensure +// that the integrity of the data passed to/from client is maintained +// +/***********************************************************************************/ + +TInt CSatDSatTsy::GetIcon(const TTsyReqHandle aTsyReqHandle, TUint8* aRecordNumber, RSat::TIcon* aIconEf) + { + if((iGetIcon==0)||(iGetIcon==1)) + { + iGetIcon++; + LOGTEXT(_L8("CSatDSatTsy::GetIcon called")); + switch(*aRecordNumber) + { + case 1: + *aIconEf=DSATTSY_ICON_EF1; + break; + case 2: + *aIconEf=DSATTSY_ICON_EF2; + break; + default: + *aIconEf=DSATTSY_ICON_EF1; + break; + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetIconCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::GetIconCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::GetImageInstance(const TTsyReqHandle aTsyReqHandle, TDesC8* aCallParams, TDes8* aInstance) +/** +* The first time that this method is called, iGetImageInstance=0 +* The request completes - ReqCompleted is called. One of the test cases for +* aInstanceNumber can be tested. +* +* The second time that this method is called, iGetImageInstance=1 +* The request completes - ReqCompleted is called. Another one of the test cases +* for aInstanceNumber can be tested. +* +* The third time that this method is called, iGetImageInstance=2 +* The request does not complete. +* +* This mechanism prevents an infinite loop as each time a notification completes, +* it is reposted automatically by the server, which would in this test code create an +* infinite loop of posting, completing and reposting the notification. +* +* This mechanism also allows the test client to test the cancel method associated. +* +* If parameters become corrupted in either of the two tests then 'KErrCorrupt' +* and an unknown image instance returned. +*/ + { + LOGTEXT(_L8("CSatDSatTsy::GetImageInstance called")); + + TInt result=KErrNone; + + RSat::TInstanceInfoV3Pckg* paramsPckgV3 = (RSat::TInstanceInfoV3Pckg*)aCallParams; + RSat::TInstanceInfoV3& paramsV3 = (*paramsPckgV3)(); + + if((iGetImageInstance==0)||(iGetImageInstance==1)) + { + iGetImageInstance++; + + if(paramsV3.ExtensionId()== RSat::KSatV3) + { + // check that all parameters are being passed correctly + if( paramsV3.iInstanceNumber == DSATTSY_INSTANCE_NUMBER1 && + paramsV3.iLength==DSATTSY_INSTANCE_LENGTH1 && + paramsV3.iOffset==DSATTSY_INSTANCE_OFFSET1 && + paramsV3.iCoding==DSATTSY_INSTANCE_CODING_BASIC && + paramsV3.iImgWidth==DSATTSY_INSTANCE_WIDTH_1 && + paramsV3.iImgHeight==DSATTSY_INSTANCE_HEIGHT_1 && + paramsV3.iFileId==DSATTSY_INSTANCE_FILE_ID_1 ) + { + *aInstance=DSATTSY_IMG_INSTANCE1; + } + else if(paramsV3.iInstanceNumber == DSATTSY_INSTANCE_NUMBER2 && + paramsV3.iLength==DSATTSY_INSTANCE_LENGTH2 && + paramsV3.iOffset==DSATTSY_INSTANCE_OFFSET2 && + paramsV3.iCoding==DSATTSY_INSTANCE_CODING_COLOUR && + paramsV3.iImgWidth==DSATTSY_INSTANCE_WIDTH_2 && + paramsV3.iImgHeight==DSATTSY_INSTANCE_HEIGHT_2 && + paramsV3.iFileId==DSATTSY_INSTANCE_FILE_ID_2 ) + { + *aInstance=DSATTSY_IMG_INSTANCE2; + } + else + { + // parameters have been corrupted + *aInstance=DSATTSY_IMG_INSTANCE_UNKNOWN; + result=KErrCorrupt; + } + } + ReqCompleted(aTsyReqHandle,result); + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return result; + } + + +TInt CSatDSatTsy::GetImageInstanceCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::GetImageInstanceCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::GetClut(const TTsyReqHandle aTsyReqHandle, RSat::TInstanceNumberAndOffset* aClutInfo, TDes8* aClut) + { + LOGTEXT(_L8("CSatDSatTsy::GetClut called")); + + if((aClutInfo->iInstanceNumber!=DSATTSY_INSTANCE_NUMBER1) + ||(aClutInfo->iOffset!=DSATTSY_CLUT_OFFSET)) + ReqCompleted(aTsyReqHandle,KErrCorrupt); + + if(iGetClut==0) + { + iGetClut++; + *aClut= DSATTSY_CLUT1; + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetClutCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::GetClutCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::DisplayTextTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TDisplayTextRspV1Pckg* aRspPckg = (RSat::TDisplayTextRspV1Pckg*)aRsp; + RSat::TDisplayTextRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.PCmdNumber()!=DSATTSY_DISPLAY_TEXT_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iDisplayTextTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetInkeyTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TGetInkeyRspV1Pckg* aRspPckg = (RSat::TGetInkeyRspV1Pckg*)aRsp; + RSat::TGetInkeyRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_TEXT_STRING) + ||(rspV1.iRspFormat!=DSATTSY_USER_RSP_FORMAT) + ||(rspV1.iAdditionalInfo!=DSATTSY_USER_TEXT_INPUT) + ||(rspV1.PCmdNumber()!=DSATTSY_GET_INKEY_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iGetInkeyTerminalRsp++) + { + if(rspV1.ExtensionId()==RSat::KSatV2) + { + RSat::TGetInkeyRspV2Pckg* aV2RspPckg = (RSat::TGetInkeyRspV2Pckg*)aRsp; + RSat::TGetInkeyRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iDuration.iTimeUnit!=DSATTSY_TIME_UNIT) + || (rspV2.iDuration.iNumOfUnits!=DSATTSY_NUM_OF_UNITS)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetInputTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TGetInputRspV1Pckg* aRspPckg = (RSat::TGetInputRspV1Pckg*)aRsp; + RSat::TGetInputRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_TEXT_STRING) + ||(rspV1.iRspFormat!=DSATTSY_GET_INPUT_RSP_FORMAT) + ||(rspV1.iAdditionalInfo!=DSATTSY_USER_TEXT_INPUT) + ||(rspV1.PCmdNumber()!=DSATTSY_GET_INPUT_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iGetInputTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::PlayToneTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TPlayToneRspV1Pckg* aRspPckg = (RSat::TPlayToneRspV1Pckg*)aRsp; + RSat::TPlayToneRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_PLAY_TONE_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iPlayToneTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SetUpMenuRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSetUpMenuRspV1Pckg* aRspPckg = (RSat::TSetUpMenuRspV1Pckg*)aRsp; + RSat::TSetUpMenuRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_SET_UP_MENU_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSetUpMenuTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SelectItemTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSelectItemRspV1Pckg* aRspPckg = (RSat::TSelectItemRspV1Pckg*)aRsp; + RSat::TSelectItemRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_ITEM_ID) + ||(rspV1.iAdditionalInfo!=DSATTSY_RSP_ITEM_ID) + ||(rspV1.PCmdNumber()!=DSATTSY_SELECT_ITEM_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSelectItemTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SendSmTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSendSmRspV1Pckg* aRspPckg = (RSat::TSendSmRspV1Pckg*)aRsp; + RSat::TSendSmRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_SEND_SM_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSendSmTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SendSSTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSendSsRspV1Pckg* aRspPckg = (RSat::TSendSsRspV1Pckg*)aRsp; + RSat::TSendSsRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_SEND_SS_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + RSat::TControlResult ccResult; + rspV1.iCcRequestedAction.GetCcGeneralResult(ccResult); + + RSat::TCallControlType ccType; + rspV1.iCcRequestedAction.GetCallControlType(ccType); + + RSat::TCallSetUpParams address; + rspV1.iCcRequestedAction.GetCallSetUpDetails(address); + + RSat::TAlphaIdValidity validity; + RSat::TAlphaId alphaId; + rspV1.iCcRequestedAction.GetAlphaId(validity, alphaId); + + RSat::TBCRepeatIndicator indicator; + rspV1.iCcRequestedAction.GetBCRepeatIndicator(indicator); + + if ( (ccResult!=DSATTSY_CC_RESULT) || (ccType!=RSat::ECcAddress) + || (address.iCcp1!=DSATTSY_CCP1) + ||(address.iSubAddress!=DSATTSY_SUBADDRESS) + || (address.iCcp2!=DSATTSY_CCP2) + || (address.iAddress.iTypeOfNumber!=DSATTSY_TON) + || (address.iAddress.iNumberPlan!=DSATTSY_NPI) + || (address.iAddress.iTelNumber!=DSATTSY_TEL_NUMBER) + || (validity!=DSATTSY_NO_ALPHAID) + || (alphaId.iAlphaId!=DSATTSY_NULL_BUF) + || (alphaId.iStatus!=DSATTSY_ALPHAID_STATUS) + || (indicator != DSATTSY_BC_REPEAT_INDICATOR_SEQUENTIAL)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + else if((rspV1.iGeneralResult2!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType2!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo2!=DSATTSY_NULL_BUF)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + else if(!iSendSsTerminalRsp++) + { + if(rspV1.ExtensionId()==RSat::KSatV2) + { + RSat::TSendSsRspV2Pckg* aV2RspPckg = (RSat::TSendSsRspV2Pckg*)aRsp; + RSat::TSendSsRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iUssdString.iUssdString != DSATTSY_DEFAULT_TEXT) + || (rspV2.iUssdString.iDcs != DSATTSY_DCS)) + ReqCompleted(aTsyReqHandle,KErrCorrupt); + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SendUssdTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSendUssdRspV1Pckg* aRspPckg = (RSat::TSendUssdRspV1Pckg*)aRsp; + RSat::TSendUssdRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_TEXT_STRING) + ||(rspV1.iAdditionalInfo!=DSATTSY_NETWORK_TEXT_STRING) + ||(rspV1.PCmdNumber()!=DSATTSY_SEND_USSD_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + RSat::TControlResult ccResult; + rspV1.iCcRequestedAction.GetCcGeneralResult(ccResult); + RSat::TCallControlType ccType; + rspV1.iCcRequestedAction.GetCallControlType(ccType); + + RSat::TCallSetUpParams address; + rspV1.iCcRequestedAction.GetCallSetUpDetails(address); + + RSat::TAlphaIdValidity validity; + RSat::TAlphaId alphaId; + rspV1.iCcRequestedAction.GetAlphaId(validity, alphaId); + + RSat::TBCRepeatIndicator indicator; + rspV1.iCcRequestedAction.GetBCRepeatIndicator(indicator); + + if ( (ccResult!=DSATTSY_CC_RESULT) || (ccType!=RSat::ECcAddress) + || (address.iCcp1!=DSATTSY_CCP1) + ||(address.iSubAddress!=DSATTSY_SUBADDRESS) + || (address.iCcp2!=DSATTSY_CCP2) + || (address.iAddress.iTypeOfNumber!=DSATTSY_TON) + || (address.iAddress.iNumberPlan!=DSATTSY_NPI) + || (address.iAddress.iTelNumber!=DSATTSY_TEL_NUMBER) + || (validity!=DSATTSY_NO_ALPHAID) + || (alphaId.iAlphaId!=DSATTSY_NULL_BUF) + || (alphaId.iStatus!=DSATTSY_ALPHAID_STATUS + || indicator != DSATTSY_BC_REPEAT_INDICATOR_SEQUENTIAL)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + else if((rspV1.iGeneralResult2!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType2!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo2!=DSATTSY_NULL_BUF)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + else if(!iSendUssdTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SetUpCallTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSetUpCallRspV1Pckg* aRspPckg = (RSat::TSetUpCallRspV1Pckg*)aRsp; + RSat::TSetUpCallRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_SET_UP_CALL_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + if(rspV1.ExtensionId()==RSat::KSatV2) + { + RSat::TSetUpCallRspV2Pckg* aRspV2Pckg = (RSat::TSetUpCallRspV2Pckg*)aRsp; + RSat::TSetUpCallRspV2& rspV2 = (*aRspV2Pckg)(); + + if((rspV2.iUssdString.iUssdString != DSATTSY_DEFAULT_TEXT) + || (rspV2.iUssdString.iDcs != DSATTSY_DCS)) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + RSat::TControlResult ccResult; + rspV1.iCcRequestedAction.GetCcGeneralResult(ccResult); + + RSat::TCallControlType ccType; + rspV1.iCcRequestedAction.GetCallControlType(ccType); + + RSat::TCallSetUpParams address; + rspV1.iCcRequestedAction.GetCallSetUpDetails(address); + + RSat::TAlphaIdValidity validity; + RSat::TAlphaId alphaId; + rspV1.iCcRequestedAction.GetAlphaId(validity, alphaId); + + RSat::TBCRepeatIndicator indicator; + rspV1.iCcRequestedAction.GetBCRepeatIndicator(indicator); + + if ( (ccResult!=DSATTSY_CC_RESULT) || (ccType!=RSat::ECcAddress) + || (address.iCcp1!=DSATTSY_CCP1) + || (address.iSubAddress!=DSATTSY_SUBADDRESS) + || (address.iCcp2!=DSATTSY_CCP2) + || (address.iAddress.iTypeOfNumber!=DSATTSY_TON) + || (address.iAddress.iNumberPlan!=DSATTSY_NPI) + || (address.iAddress.iTelNumber!=DSATTSY_TEL_NUMBER) + || (validity!=DSATTSY_NO_ALPHAID) + || (alphaId.iAlphaId!=DSATTSY_NULL_BUF) + || (alphaId.iStatus!=DSATTSY_ALPHAID_STATUS) + || (indicator != DSATTSY_BC_REPEAT_INDICATOR_ALTERNATE)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + else if((rspV1.iGeneralResult2!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType2!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo2!=DSATTSY_NULL_BUF)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSetUpCallTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::RefreshTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TRefreshRspV1Pckg* aRspPckg = (RSat::TRefreshRspV1Pckg*)aRsp; + RSat::TRefreshRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_REFRESH_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iRefreshTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SetUpEventListTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSetUpEventListRspV1Pckg* aRspPckg = (RSat::TSetUpEventListRspV1Pckg*)aRsp; + RSat::TSetUpEventListRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_SET_UP_EVENT_LIST_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSetUpEventListTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SetUpIdleModeTextTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSetUpIdleModeTextRspV1Pckg* aRspPckg = (RSat::TSetUpIdleModeTextRspV1Pckg*)aRsp; + RSat::TSetUpIdleModeTextRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSetUpIdleModeTextTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SendDtmfTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSendDtmfRspV1Pckg* aRspPckg = (RSat::TSendDtmfRspV1Pckg*)aRsp; + RSat::TSendDtmfRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV1.PCmdNumber()!=DSATTSY_SEND_DTMF_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSendDtmfTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::PerformCardApduTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TPerformCardApduRspV2Pckg* aV2RspPckg = (RSat::TPerformCardApduRspV2Pckg*)aRsp; + RSat::TPerformCardApduRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_PERFORM_CARD_APDU_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iPerformCardApduTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::PowerOffCardTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TPowerOffCardRspV2Pckg* aV2RspPckg = (RSat::TPowerOffCardRspV2Pckg*)aRsp; + RSat::TPowerOffCardRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_POWER_OFF_CARD_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iPowerOffCardTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::PowerOnCardTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TPowerOnCardRspV2Pckg* aV2RspPckg = (RSat::TPowerOnCardRspV2Pckg*)aRsp; + RSat::TPowerOnCardRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_POWER_ON_CARD_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iPowerOnCardTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetReaderStatusTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TGetReaderStatusRspV2Pckg* aV2RspPckg = (RSat::TGetReaderStatusRspV2Pckg*)aRsp; + RSat::TGetReaderStatusRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_GET_READER_STATUS_NUMBER) + ||(rspV2.iMode!=DSATTSY_GET_READER_STATUS_MODE)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iGetReaderStatusTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::RunAtCommandTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TRunAtCommandRspV2Pckg* aV2RspPckg = (RSat::TRunAtCommandRspV2Pckg*)aRsp; + RSat::TRunAtCommandRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_RUN_AT_COMMAND_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iRunAtCommandTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::LanguageNotificationTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TLanguageNotificationRspV2Pckg* aV2RspPckg = (RSat::TLanguageNotificationRspV2Pckg*)aRsp; + RSat::TLanguageNotificationRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_LANGUAGE_NOTIFICATION_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iLanguageNotificationTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::LaunchBrowserTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TLaunchBrowserRspV2Pckg* aV2RspPckg = (RSat::TLaunchBrowserRspV2Pckg*)aRsp; + RSat::TLaunchBrowserRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_LAUNCH_BROWSER_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iLaunchBrowserTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::OpenChannelTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TOpenChannelRspV2Pckg* aV2RspPckg = (RSat::TOpenChannelRspV2Pckg*)aRsp; + RSat::TOpenChannelRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_OPEN_CHANNEL_NUMBER) + ||(rspV2.iBearer.iType!=DSATTSY_CSD_BEARER_TYPE) + ||(rspV2.iBearer.iParams!=DSATTSY_BEARER_PARAMS) + ||(rspV2.iBufferSize!=DSATTSY_BUFFER_SIZE)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iOpenChannelTerminalRsp++) + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::CloseChannelTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TCloseChannelRspV2Pckg* aV2RspPckg = (RSat::TCloseChannelRspV2Pckg*)aRsp; + RSat::TCloseChannelRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_CLOSE_CHANNEL_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iCloseChannelTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::ReceiveDataTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TReceiveDataRspV2Pckg* aV2RspPckg = (RSat::TReceiveDataRspV2Pckg*)aRsp; + RSat::TReceiveDataRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_RECEIVE_DATA_NUMBER) + ||(rspV2.iChannelDataLength!=DSATTSY_DATA_LENGTH)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iReceiveDataTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SendDataTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TSendDataRspV2Pckg* aV2RspPckg = (RSat::TSendDataRspV2Pckg*)aRsp; + RSat::TSendDataRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_SEND_DATA_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iSendDataTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetChannelStatusTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TGetChannelStatusRspV2Pckg* aV2RspPckg = (RSat::TGetChannelStatusRspV2Pckg*)aRsp; + RSat::TGetChannelStatusRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_GET_CHANNEL_STATUS_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iGetChannelStatusTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetServiceInfoTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TGetServiceInfoRspV2Pckg* aV2RspPckg = (RSat::TGetServiceInfoRspV2Pckg*)aRsp; + RSat::TGetServiceInfoRspV2& rspV2 = (*aV2RspPckg)(); + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_GET_SERVICE_INFO_NUMBER) + ||(rspV2.iRecordInfo.iBearerId!=DSATTSY_BEARER_NOT_PRESENT) + ||(rspV2.iRecordInfo.iServiceId!=DSATTSY_NULL_BEARER_ID) + ||(rspV2.iRecordInfo.iRecord!=DSATTSY_NULL_NARROW_BUF)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iGetServiceInfoTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::DeclareServiceTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TDeclareServiceRspV2Pckg* aV2RspPckg = (RSat::TDeclareServiceRspV2Pckg*)aRsp; + RSat::TDeclareServiceRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_DECLARE_SERVICE_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iDeclareServiceTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::ServiceSearchTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TServiceSearchRspV2Pckg* aV2RspPckg = (RSat::TServiceSearchRspV2Pckg*)aRsp; + RSat::TServiceSearchRspV2& rspV2 = (*aV2RspPckg)(); + + if((rspV2.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV2.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV2.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV2.PCmdNumber()!=DSATTSY_SERVICE_SEARCH_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iServiceSearchTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::TimerMgmtTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TTimerMgmtRspV3Pckg* aV3RspPckg = (RSat::TTimerMgmtRspV3Pckg*)aRsp; + RSat::TTimerMgmtRspV3& rspV3 = (*aV3RspPckg)(); + + if((rspV3.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV3.iInfoType!=DSATTSY_INFO_TYPE) + ||(rspV3.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV3.PCmdNumber()!=DSATTSY_TIMER_MNGT_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iTimerMgmtTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::LocalInfoTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TLocalInfoRspV3Pckg* aV3RspPckg = (RSat::TLocalInfoRspV3Pckg*)aRsp; + RSat::TLocalInfoRspV3& rspV3 = (*aV3RspPckg)(); + + if((rspV3.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV3.iInfoType!=DSATTSY_INFO_TYPE) + ||(rspV3.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV3.PCmdNumber()!=DSATTSY_LOCAL_INFO_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iLocalInfoTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + + +TInt CSatDSatTsy::PollingIntvTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TPollingIntervalRspV3Pckg* aV3RspPckg = (RSat::TPollingIntervalRspV3Pckg*)aRsp; + RSat::TPollingIntervalRspV3& rspV3 = (*aV3RspPckg)(); + + if((rspV3.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV3.iInfoType!=DSATTSY_INFO_TYPE) + ||(rspV3.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV3.PCmdNumber()!=DSATTSY_POLLING_INTERVAL_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iPollingIntervalTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::PollingOffTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aRsp) + { + RSat::TPollingOffRspV3Pckg* aV3RspPckg = (RSat::TPollingOffRspV3Pckg*)aRsp; + RSat::TPollingOffRspV3& rspV3 = (*aV3RspPckg)(); + + if((rspV3.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV3.iInfoType!=DSATTSY_INFO_TYPE) + ||(rspV3.iAdditionalInfo!=DSATTSY_NULL_BUF) + ||(rspV3.PCmdNumber()!=DSATTSY_POLLING_OFF_NUMBER)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iPollingOffTerminalRsp++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::RetrieveMultimediaMsgTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iRetrieveMultimediaMsgTerminalRsp++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRetrieveMultimediaMsgPCmd called")); + RSat::TRetrieveMultimediaMessageRspV6Pckg* retrieveMmRspV6PCmdPckg = (RSat::TRetrieveMultimediaMessageRspV6Pckg*)aPCmd; + RSat::TRetrieveMultimediaMessageRspV6& retrieveMmRspV6 = (*retrieveMmRspV6PCmdPckg)(); + + if((retrieveMmRspV6.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) || + (retrieveMmRspV6.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) || + (retrieveMmRspV6.PCmdNumber()!=DSATTSY_RETRIEVE_MULTIMEDIA_MESSAGE)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + + +TInt CSatDSatTsy::SubmitMultimediaMsgTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iSubmitMultimediaMsgTerminalRsp++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySubmitMultimediaMsgPCmd called")); + RSat::TSubmitMultimediaMessageRspV6Pckg* submitMMRspV6PCmdPckg = (RSat::TSubmitMultimediaMessageRspV6Pckg*)aPCmd; + RSat::TSubmitMultimediaMessageRspV6& submitMMRspV6 = (*submitMMRspV6PCmdPckg)(); + + if((submitMMRspV6.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) || + (submitMMRspV6.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) || + (submitMMRspV6.PCmdNumber()!=DSATTSY_SUBMIT_MULTIMEDIA_MESSAGE)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::DisplayMultimediaMsgTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iDisplayMultimediaMsgTerminalRsp++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyDisplayMultimediaMsgPCmd called")); + RSat::TDisplayMultimediaMessageRspV6Pckg* displayMMRspV6PCmdPckg = (RSat::TDisplayMultimediaMessageRspV6Pckg*)aPCmd; + RSat::TDisplayMultimediaMessageRspV6& displayMMRspV6 = (*displayMMRspV6PCmdPckg)(); + + if((displayMMRspV6.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) || + (displayMMRspV6.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) || + (displayMMRspV6.PCmdNumber()!=DSATTSY_DISPLAY_MULTIMEDIA_MESSAGE)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SetFramesTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iSetFramesTerminalRsp++) + { + LOGTEXT(_L8("CSatDSatTsy::SetFramesTerminalRsp called")); + RSat::TSetFramesRspV6Pckg* setFramesRspV6PCmdPckg = (RSat::TSetFramesRspV6Pckg*)aPCmd; + RSat::TSetFramesRspV6& setFramesRspV6 = (*setFramesRspV6PCmdPckg)(); + + if((setFramesRspV6.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) || + (setFramesRspV6.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) || + (setFramesRspV6.PCmdNumber()!=DSATTSY_SET_FRAMES) || + (setFramesRspV6.iFramesInformation.iFrameId!=DSATTSY_FRAMES_INFORMATION_FRAMEID) || + (setFramesRspV6.iFramesInformation.iFrameList!=DSATTSY_FRAMES_INFORMATION_FRAME_LIST )) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetFramesStatusTerminalRsp(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iGetFramesStatusTerminalRsp++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetFramesStatusPCmd called")); + RSat::TGetFramesStatusRspV6Pckg* getFramesStatusRspV6PCmdPckg = (RSat::TGetFramesStatusRspV6Pckg*)aPCmd; + RSat::TGetFramesStatusRspV6& getFramesStatusRspV6 = (*getFramesStatusRspV6PCmdPckg)(); + + if((getFramesStatusRspV6.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(getFramesStatusRspV6.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(getFramesStatusRspV6.PCmdNumber()!=DSATTSY_GET_FRAMES_STATUS) + ||(getFramesStatusRspV6.iFramesInformation.iFrameId!=DSATTSY_FRAMES_INFORMATION_FRAMEID) + ||(getFramesStatusRspV6.iFramesInformation.iFrameList!=DSATTSY_FRAMES_INFORMATION_FRAME_LIST )) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + + + +TInt CSatDSatTsy::TerminalRsp(const TTsyReqHandle aTsyReqHandle, RSat::TPCmd* aPCmd, TDes8* aRsp) + { + LOGTEXT(_L8("CSatDSatTsy::TerminalRsp called")); + switch (*aPCmd) + { + case RSat::EDisplayText: + return DisplayTextTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EGetInkey: + return GetInkeyTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EGetInput: + return GetInputTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EPlayTone: + return PlayToneTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESetUpMenu: + return SetUpMenuRsp(aTsyReqHandle, aRsp); + case RSat::ESelectItem: + return SelectItemTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESendSm: + return SendSmTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESendSs: + return SendSSTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESendUssd: + return SendUssdTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESetUpCall: + return SetUpCallTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ERefresh: + return RefreshTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESetUpEventList: + return SetUpEventListTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESetUpIdleModeText: + return SetUpIdleModeTextTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESendDtmf: + return SendDtmfTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EPerformCardApdu: + return PerformCardApduTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EPowerOffCard: + return PowerOffCardTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EPowerOnCard: + return PowerOnCardTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EGetReaderStatus: + return GetReaderStatusTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ERunAtCommand: + return RunAtCommandTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ELanguageNotification: + return LanguageNotificationTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ELaunchBrowser: + return LaunchBrowserTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EOpenChannelCs: + case RSat::EOpenChannelGprs: + case RSat::EOpenChannelLocal: + case RSat::EOpenChannelUiccServerMode: + return OpenChannelTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ECloseChannel: + return CloseChannelTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EReceiveData: + return ReceiveDataTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESendData: + return SendDataTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EGetChannelStatus: + return GetChannelStatusTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EDeclareService: + return DeclareServiceTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EServiceSearch: + return ServiceSearchTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EGetServiceInformation: + return GetServiceInfoTerminalRsp(aTsyReqHandle,aRsp); + case RSat::ETimerMngt: + return TimerMgmtTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ELocalInfo: + return LocalInfoTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EPollingInterval: + return PollingIntvTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EPollingOff: + return PollingOffTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ERetrieveMultimediaMsg: + return RetrieveMultimediaMsgTerminalRsp(aTsyReqHandle,aRsp); + case RSat::ESubmitMultimediaMsg: + return SubmitMultimediaMsgTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EDisplayMultimediaMsg: + return DisplayMultimediaMsgTerminalRsp(aTsyReqHandle, aRsp); + case RSat::ESetFrames: + return SetFramesTerminalRsp(aTsyReqHandle, aRsp); + case RSat::EGetFramesStatus: + return GetFramesStatusTerminalRsp(aTsyReqHandle, aRsp); + default: + return KErrGeneral; + } + } + +TInt CSatDSatTsy::TerminalRspCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::TerminalRspCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::GetMeSideSatProfile(const TTsyReqHandle aTsyReqHandle, TDes8* aMeSimSatProfile) + { + // First call by test code is RSat::GetMeSideSatProfile() with V2 param. + // Second call is RSat::GetMeSideSatProfile() followed by Cancel + // Third call is RSat::GetMeSideSatProfile() with V5 param. + if((iGetMeSideSatProfile == 0) || (iGetMeSideSatProfile == 2)) + { + LOGTEXT(_L8("CSatDSatTsy::GetMeSideSatProfile called")); + RSat::TSatProfileV1Pckg* aProfilePckg = (RSat::TSatProfileV1Pckg*)aMeSimSatProfile; + RSat::TSatProfileV1& profileV1 = (*aProfilePckg)(); + + profileV1.iSatProfileByte1=0x01; + profileV1.iSatProfileByte2=0x02; + profileV1.iSatProfileByte3=0x03; + profileV1.iSatProfileByte4=0x04; + profileV1.iSatProfileByte5=0x05; + profileV1.iSatProfileByte6=0x06; + profileV1.iSatProfileByte7=0x07; + profileV1.iSatProfileByte8=0x08; + profileV1.iSatProfileByte9=0x09; + + if ((profileV1.ExtensionId() == RSat::KSatV2) || + (profileV1.ExtensionId() == RSat::KSatV5) || + (profileV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSatProfileV2Pckg* v2ProfilePckg = (RSat::TSatProfileV2Pckg*)aMeSimSatProfile; + RSat::TSatProfileV2& profileV2 = (*v2ProfilePckg)(); + + profileV2.iSatProfileByte10=0x0A; + profileV2.iSatProfileByte11=0x0B; + profileV2.iSatProfileByte12=0x0C; + profileV2.iSatProfileByte13=0x0D; + profileV2.iSatProfileByte14=0x0E; + profileV2.iSatProfileByte15=0x0F; + profileV2.iSatProfileByte16=0x10; + profileV2.iSatProfileByte17=0x20; + profileV2.iSatProfileByte18=0x30; + profileV2.iNumOfChannels=DSATTSY_NUMBER_OF_CHANNELS; + profileV2.iScreenHeight=DSATTSY_SCREEN_HEIGHT; + profileV2.iScreenWidth=DSATTSY_SCREEN_WIDTH; + profileV2.iTiaEiaProtoVersion=DSATTSY_PROTO_VERSION; + profileV2.iWidthReduction=DSATTSY_WIDTH_REDUCTION; + } + + if ((profileV1.ExtensionId() == RSat::KSatV5) || + (profileV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSatProfileV5Pckg* profileV5Pckg = (RSat::TSatProfileV5Pckg*)aMeSimSatProfile; + RSat::TSatProfileV5& profileV5 = (*profileV5Pckg)(); + + // Set profileV5.iSatProfileByte28 to: + // (KCapsTextAttributeAlignmentLeft | KCapsTextAttributeAlignmentCentre | + // KCapsTextAttributeAlignmentRight | KCapsTextAttributeFontSizeNormal | + // KCapsTextAttributeFontSizeLarge | KCapsTextAttributeFontSizeSmall) + profileV5.iSatProfileByte28 = 0x3F; + // Set profileV5.iSatProfileByte29 to + // (KCapsTextAttributeStyleNormal | KCapsTextAttributeStyleBold | + // KCapsTextAttributeStyleItalic | KCapsTextAttributeStyleUnderline | + // KCapsTextAttributeStyleStrikethrough | KCapsTextAttributeStyleForeground | + // KCapsTextAttributeStyleBackground) + profileV5.iSatProfileByte29 = 0x7F; + } + if (profileV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSatProfileV6Pckg* profileV6Pckg = (RSat::TSatProfileV6Pckg*)aMeSimSatProfile; + RSat::TSatProfileV6& profileV6 = (*profileV6Pckg)(); + + // Set profileV6.iSatProfileByte21 to: + //(KCapsWML | KCapsXHTML | + // KCapsHTML | KCapsCHTML ) + profileV6.iSatProfileByte21 = 0x0F; + // Set profileV6.iSatProfileByte22 to: + //(KCapsProvideLocalInfoUTRAN | KCapsProvideLocalInfoBatteryState | + // KCapsPlayThemedAndMelodyTone | KCapsSetUpCallMultimediaCall | + // KCapsRefreshGBA | KCapsRetrieveMultimediaMessage | + // KCapsSubmitMultimediaMessage | KCapsDisplayMultimediaMesage) + profileV6.iSatProfileByte22 = 0xFF; + // Set profileV6.iSatProfileByte23 to: + //(KCapsSetFrames | KCapsGetFramesStatus | + // KCapsMmsNotificationDownload | KCapsProvideLocalInfoMEID | + // KCapsProvideLocalInfoNmrUTRAN | KCapsUssdDataDownload) + profileV6.iSatProfileByte23 = 0xE7; + // Set profileV6.iSatProfileByte24 to: + //(KCapsMaxNumFramesBit1 | KCapsMaxNumFramesBit2 | + // KCapsMaxNumFramesBit3 | KCapsMaxNumFramesBit4) + profileV6.iSatProfileByte24 = 0x0F; + // Set profileV6.iSatProfileByte25 to: + // (KCapsBrowsingStatusEvent | KCapsMmsTransferStatusEvent | + // KCapsFrameParametersChangeEvent) + profileV6.iSatProfileByte25 = 0x07; + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + iGetMeSideSatProfile++; + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetMeSideSatProfileCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::GetMeSideSatProfileCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::ClientSatProfileIndication(const TTsyReqHandle aTsyReqHandle, TDes8* aClientSatProfile) + { + + // First call by test code is with version 2 parameter + // Second call is with version 5 parameter + if (iClientSatProfileIndication<2) + { + LOGTEXT(_L8("CSatDSatTsy::ClientSatProfileIndication called")); + + RSat::TSatProfileV1Pckg* aClientSatProfilePckg = (RSat::TSatProfileV1Pckg*)aClientSatProfile; + RSat::TSatProfileV1& satProfileV1 = (*aClientSatProfilePckg)(); + + // Check version 1 parameters + if ((satProfileV1.iSatProfileByte1!=0x01) + ||(satProfileV1.iSatProfileByte2!=0x02) + ||(satProfileV1.iSatProfileByte3!=0x03) + ||(satProfileV1.iSatProfileByte4!=0x04) + ||(satProfileV1.iSatProfileByte5!=0x05) + ||(satProfileV1.iSatProfileByte6!=0x06) + ||(satProfileV1.iSatProfileByte7!=0x07) + ||(satProfileV1.iSatProfileByte8!=0x08) + ||(satProfileV1.iSatProfileByte9!=0x09)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + // Check version 2 parameters + if( (satProfileV1.ExtensionId()==RSat::KSatV2) || + (satProfileV1.ExtensionId()==RSat::KSatV5) || + (satProfileV1.ExtensionId()==RSat::KSatV6)) + { + RSat::TSatProfileV2Pckg* aV2ClientSatProfilePckg = (RSat::TSatProfileV2Pckg*)aClientSatProfile; + RSat::TSatProfileV2& satProfileV2 = (*aV2ClientSatProfilePckg)(); + + if ((satProfileV2.iSatProfileByte10!=0x0A) + ||(satProfileV2.iSatProfileByte11!=0x0B) + ||(satProfileV2.iSatProfileByte12!=0x0C) + ||(satProfileV2.iSatProfileByte13!=0x0D) + ||(satProfileV2.iSatProfileByte14!=0x0E) + ||(satProfileV2.iSatProfileByte15!=0x0F) + ||(satProfileV2.iSatProfileByte16!=0x10) + ||(satProfileV2.iSatProfileByte17!=0x20) + ||(satProfileV2.iSatProfileByte18!=0x30) + ||(satProfileV2.iNumOfChannels!=DSATTSY_NUMBER_OF_CHANNELS) + ||(satProfileV2.iScreenHeight!=DSATTSY_SCREEN_HEIGHT) + ||(satProfileV2.iScreenWidth!=DSATTSY_SCREEN_WIDTH) + ||(satProfileV2.iTiaEiaProtoVersion!=DSATTSY_PROTO_VERSION) + ||(satProfileV2.iWidthReduction!=DSATTSY_WIDTH_REDUCTION)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + } + + // Check version 5 parameters + if ((satProfileV1.ExtensionId() == RSat::KSatV5) || + (satProfileV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSatProfileV5Pckg* clientSatProfilePckgV5 = (RSat::TSatProfileV5Pckg*) aClientSatProfile; + RSat::TSatProfileV5& satProfileV5 = (*clientSatProfilePckgV5)(); + + if ((satProfileV5.iSatProfileByte28 != 0x3F) || + (satProfileV5.iSatProfileByte29 != 0x7F)) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + } + + // Check version 6 parameters + if (satProfileV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSatProfileV6Pckg* clientSatProfilePckgV6 = (RSat::TSatProfileV6Pckg*) aClientSatProfile; + RSat::TSatProfileV6& satProfileV6 = (*clientSatProfilePckgV6)(); + + if ((satProfileV6.iSatProfileByte21 != 0x0F) || + (satProfileV6.iSatProfileByte22 != 0xFF) || + (satProfileV6.iSatProfileByte23 != 0xE7) || + (satProfileV6.iSatProfileByte24 != 0x0F) || + (satProfileV6.iSatProfileByte25 != 0x07)) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iClientSatProfileIndication++; + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::MenuSelection(const TTsyReqHandle aTsyReqHandle, TDes8* aSelection) + { + LOGTEXT(_L8("CSatDSatTsy::MenuSelection called")); + RSat::TMenuSelectionV1Pckg* aSelectionPckg = (RSat::TMenuSelectionV1Pckg*)aSelection; + RSat::TMenuSelectionV1& menuSelectionV1 = (*aSelectionPckg)(); + + if ((menuSelectionV1.iItemId!=DSATTSY_ITEM_ID) + ||(menuSelectionV1.iHelp!=DSATTSY_HELP_REQUESTED)) + ReqCompleted(aTsyReqHandle,KErrCorrupt); + else + if(!iMenuSelection++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::MenuSelectionCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::MenuSelectionCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::NotifyCallControlRequest(const TTsyReqHandle aTsyReqHandle, TDes8* aCallControlDetails) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyCallControlRequest called")); + if(!iNotifyCallControlRequest++) + { + RSat::TAlphaId nullBuf; + nullBuf.iAlphaId=DSATTSY_NULL_BUF; + nullBuf.iStatus=DSATTSY_ALPHAID_STATUS; + if(iNotifyCallControlRequestTestNumber==0) + { + RSat::TCallControlV1Pckg* cmdPckg = (RSat::TCallControlV1Pckg*)aCallControlDetails; + RSat::TCallControlV1& cmdV1 = (*cmdPckg)(); + + RSat::TCallSetUpParams aParams; + aParams.iCcp1 =DSATTSY_CCP1; + aParams.iSubAddress =DSATTSY_SUBADDRESS; + aParams.iCcp2 =DSATTSY_CCP2; + aParams.iAddress.iTypeOfNumber =DSATTSY_TON; + aParams.iAddress.iNumberPlan =DSATTSY_NPI; + aParams.iAddress.iTelNumber =DSATTSY_TEL_NUMBER; + + cmdV1.SetCcGeneralResult(DSATTSY_CC_RESULT); + + cmdV1.SetAlphaId(DSATTSY_NO_ALPHAID, nullBuf); + cmdV1.SetCallSetUpDetails(aParams); + cmdV1.SetBCRepeatIndicator(RSat::EBCSequentialMode); + + iNotifyCallControlRequestTestNumber++; + + if (cmdV1.ExtensionId() == RSat::KSatV2) + { + RSat::TCallControlV2Pckg* aV2PCmdPckg = (RSat::TCallControlV2Pckg*)aCallControlDetails; + RSat::TCallControlV2& callControlV2 = (*aV2PCmdPckg)(); + + callControlV2.SetCallName(DSATTSY_CALL_NAME); + callControlV2.SetActionOriginator(DSATTSY_ACTION_ORIGINATOR); + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + else if (iNotifyCallControlRequestTestNumber==1) + { + RSat::TCallControlV1Pckg* cmdPckg = (RSat::TCallControlV1Pckg*)aCallControlDetails; + RSat::TCallControlV1& cmdV1 = (*cmdPckg)(); + + RSat::TSsString ssString; + ssString.iTypeOfNumber = DSATTSY_TON; + ssString.iNumberPlan = DSATTSY_NPI; + ssString.iSsString = DSATTSY_SS_STRING; + + cmdV1.SetCcGeneralResult(DSATTSY_CC_RESULT); + cmdV1.SetAlphaId(DSATTSY_NO_ALPHAID, nullBuf); + cmdV1.SetBCRepeatIndicator(RSat::EBCSequentialMode); + cmdV1.SetSendSsDetails(ssString); + + iNotifyCallControlRequestTestNumber++; + + if (cmdV1.ExtensionId() == RSat::KSatV2) + { + RSat::TCallControlV2Pckg* aV2PCmdPckg = (RSat::TCallControlV2Pckg*)aCallControlDetails; + RSat::TCallControlV2& callControlV2 = (*aV2PCmdPckg)(); + + callControlV2.SetCallName(DSATTSY_CALL_NAME); + callControlV2.SetActionOriginator(DSATTSY_ACTION_ORIGINATOR); + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + else if (iNotifyCallControlRequestTestNumber==2) + { + RSat::TCallControlV1Pckg* cmdPckg = (RSat::TCallControlV1Pckg*)aCallControlDetails; + RSat::TCallControlV1& cmdV1 = (*cmdPckg)(); + + RSat::TUssdString ussdString; + ussdString.iDcs=DSATTSY_DCS; + ussdString.iUssdString=DSATTSY_USSD_STRING; + + cmdV1.SetCcGeneralResult(DSATTSY_CC_RESULT); + cmdV1.SetAlphaId(DSATTSY_NO_ALPHAID, nullBuf); + cmdV1.SetBCRepeatIndicator(RSat::EBCSequentialMode); + cmdV1.SetSendUssdDetails(ussdString); + + iNotifyCallControlRequestTestNumber++; + + if (cmdV1.ExtensionId() == RSat::KSatV2) + { + RSat::TCallControlV2Pckg* aV2PCmdPckg = (RSat::TCallControlV2Pckg*)aCallControlDetails; + RSat::TCallControlV2& callControlV2 = (*aV2PCmdPckg)(); + + callControlV2.SetCallName(DSATTSY_CALL_NAME); + callControlV2.SetActionOriginator(DSATTSY_ACTION_ORIGINATOR); + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + else if (iNotifyCallControlRequestTestNumber==3) + { + RSat::TCallControlV5Pckg* cmdPckg = (RSat::TCallControlV5Pckg*)aCallControlDetails; + RSat::TCallControlV5& cmd = (*cmdPckg)(); + + cmd.SetCcGeneralResult(DSATTSY_CC_RESULT); + cmd.SetAlphaId(DSATTSY_NO_ALPHAID, nullBuf); + cmd.SetBCRepeatIndicator(DSATTSY_BC_REPEAT_INDICATOR_FALLBACK); + TPdpParameters pdpParams(DSATTSY_PDP_PARAMETERS); + cmd.SetPdpParameters(pdpParams); + + iNotifyCallControlRequestTestNumber++; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + else if (iNotifyCallControlRequestTestNumber==4) + { + RSat::TCallControlV5Pckg* cmdPckg = (RSat::TCallControlV5Pckg*)aCallControlDetails; + RSat::TCallControlV5& cmd = (*cmdPckg)(); + + cmd.SetCcGeneralResult(DSATTSY_CC_RESULT); + cmd.SetAlphaId(DSATTSY_NO_ALPHAID, nullBuf); + TPdpParameters pdpParams(DSATTSY_PDP_PARAMETERS2); + cmd.SetPdpParameters(pdpParams); + cmd.SetBCRepeatIndicator(DSATTSY_BC_REPEAT_INDICATOR_SERVICECHANGEANDFALLBACK); + + iNotifyCallControlRequestTestNumber++; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + else if (iNotifyCallControlRequestTestNumber==5) + { + RSat::TCallControlV6Pckg* cmdPckg = (RSat::TCallControlV6Pckg*)aCallControlDetails; + RSat::TCallControlV6& cmd = (*cmdPckg)(); + + cmd.SetCcGeneralResult(DSATTSY_CC_RESULT); + TPdpParameters pdpParams(DSATTSY_PDP_PARAMETERS2); + cmd.SetPdpParameters(pdpParams); + cmd.SetBCRepeatIndicator(DSATTSY_BC_REPEAT_INDICATOR_SERVICECHANGEANDFALLBACK); + cmd.SetCallParamOrigin(DSATTSY_CC_CALL_PARAM_ORIGIN); + + iNotifyCallControlRequestTestNumber++; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyCallControlRequestCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyCallControlCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyCallControlRequest=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyMoSmControlRequest(const TTsyReqHandle aTsyReqHandle, TDes8* aMoSmDetails) + { + if(!iNotifyMoSmControlRequest++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyMoSmControlRequest called")); + RSat::TMoSmControlV1Pckg* cmdPckg = (RSat::TMoSmControlV1Pckg*)aMoSmDetails; + RSat::TMoSmControlV1& cmdV1 = (*cmdPckg)(); + + cmdV1.iRpAddress.iTypeOfNumber =DSATTSY_TON; + cmdV1.iRpAddress.iNumberPlan =DSATTSY_NPI; + cmdV1.iRpAddress.iTelNumber =DSATTSY_TEL_NUMBER; + cmdV1.iTpAddress.iTypeOfNumber =DSATTSY_TON; + cmdV1.iTpAddress.iNumberPlan =DSATTSY_NPI; + cmdV1.iTpAddress.iTelNumber =DSATTSY_TEL_NUMBER; + cmdV1.iResult =DSATTSY_CONTROL_RESULT; + cmdV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + cmdV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyMoSmControlRequestCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyMoSmControlRequestCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::EventDownload(const TTsyReqHandle aTsyReqHandle, RSat::TEventList* aSingleEvent, TDes8* aEventInfo) + { + LOGTEXT(_L8("CSatDSatTsy::Event Download called")); + + RSat::TEventDownloadBaseV2Pckg* eventBaseV2Pckg = (RSat::TEventDownloadBaseV2Pckg*)aEventInfo; + RSat::TEventDownloadBaseV2& eventBaseV2 = (*eventBaseV2Pckg)(); + + if (!iEventDownload++) + { + switch( *aSingleEvent ) + { + case RSat::KUserActivity: // Allow KuserActivity to fall through to KidleScreenAvailable + case RSat::KIdleScreenAvailable: + // Don't expect any data for these events + if (eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + ReqCompleted(aTsyReqHandle, KErrNone); + break; + + case RSat::KCardReaderStatus: + // Expect TCardReaderStatusEventV2 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TCardReaderStatusEventV2Pckg* cardReaderEventV2Pckg = (RSat::TCardReaderStatusEventV2Pckg *)aEventInfo; + RSat::TCardReaderStatusEventV2& cardReaderEventV2 = (*cardReaderEventV2Pckg)(); + + if (cardReaderEventV2.iCardReaderStatus != DSATTSY_EVENT_CARD_READER_STATUS) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KLanguageSelection: + // Expect TLanguageSelectionEventV2 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TLanguageSelectionEventV2Pckg* languageV2Pckg = (RSat::TLanguageSelectionEventV2Pckg *)aEventInfo; + RSat::TLanguageSelectionEventV2& languageV2 = (*languageV2Pckg)(); + + if (languageV2.iLanguage != DSATTSY_EVENT_LANGUAGE_SELECTION) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KBrowserTermination: + // Expect TBrowserTerminationEventV2 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TBrowserTerminationEventV2Pckg* terminationV2Pckg = (RSat::TBrowserTerminationEventV2Pckg *)aEventInfo; + RSat::TBrowserTerminationEventV2& terminationV2 = (*terminationV2Pckg)(); + + if (terminationV2.iCause != DSATTSY_EVENT_BROWSER_TERMINATION_CAUSE) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KDataAvailable: + // Expect TDataAvailableEventV2 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TDataAvailableEventV2Pckg* dataV2Pckg = (RSat::TDataAvailableEventV2Pckg *)aEventInfo; + RSat::TDataAvailableEventV2& dataV2 = (*dataV2Pckg)(); + + if ((dataV2.iStatus != DSATTSY_EVENT_DATA_AVAILABLE_STATUS) + || (dataV2.iLength != DSATTSY_EVENT_DATA_AVAILABLE_LENGTH)) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KChannelStatus: + // Expect TChannelStatusEventV2 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TChannelStatusEventV2Pckg* channelV2Pckg = (RSat::TChannelStatusEventV2Pckg *)aEventInfo; + RSat::TChannelStatusEventV2& channelV2 = (*channelV2Pckg)(); + + if (channelV2.iStatus != DSATTSY_EVENT_CHANNEL_STATUS) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KDisplayParamsChanges: + // Expect TDisplayParamsEventV2 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TDisplayParamsEventV2Pckg* displayV2Pckg = (RSat::TDisplayParamsEventV2Pckg *)aEventInfo; + RSat::TDisplayParamsEventV2& displayV2 = (*displayV2Pckg)(); + + if ((displayV2.iSatProfileByte14 != DSATTSY_EVENT_DISPLAY_PROF14) + || (displayV2.iScreenHeight != DSATTSY_SCREEN_HEIGHT) + || (displayV2.iSatProfileByte15 != DSATTSY_EVENT_DISPLAY_PROF15) + || (displayV2.iScreenWidth != DSATTSY_SCREEN_WIDTH) + || (displayV2.iSatProfileByte16 != DSATTSY_EVENT_DISPLAY_PROF16) + || (displayV2.iWidthReduction != DSATTSY_WIDTH_REDUCTION)) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KLocalConnection: + // Expect TLocalConnectionEventV2 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TLocalConnectionEventV2Pckg* localV2Pckg = (RSat::TLocalConnectionEventV2Pckg *)aEventInfo; + RSat::TLocalConnectionEventV2& localV2 = (*localV2Pckg)(); + + if ((localV2.iRecord.iBearerId != DSATTSY_EVENT_LOCAL_BEARER_ID) + || (localV2.iRecord.iServiceId != DSATTSY_EVENT_LOCAL_SERVICE_ID) + || (localV2.iRecord.iRecord != DSATTSY_EVENT_LOCAL_SERVICE_RECORD) + || (localV2.iAddress.iCoding != DSATTSY_EVENT_LOCAL_ADDR_CODING) + || (localV2.iAddress.iAddress != DSATTSY_EVENT_LOCAL_ADDRESS)) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KNetworkSearchModeChange: + // Expect TNetworkSearchModeChangeV6 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TNetworkSearchModeChangeEventV6Pckg* networkSearchV6Pckg = (RSat::TNetworkSearchModeChangeEventV6Pckg *)aEventInfo; + RSat::TNetworkSearchModeChangeEventV6& networkSearchV6 = (*networkSearchV6Pckg)(); + + if (networkSearchV6.iNetworkSearchMode != DSATTSY_NETWORK_SEARCH_MODE1) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KBrowsingStatusChange: + // Expect TBrowsingStatusEventV6 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TBrowsingStatusEventV6Pckg* browsingStatusEventV6Pckg = (RSat::TBrowsingStatusEventV6Pckg *)aEventInfo; + RSat::TBrowsingStatusEventV6& browsingStatusEventV6 = (*browsingStatusEventV6Pckg)(); + + if (browsingStatusEventV6.iBrowserStatus != DSATTSY_BROWSING_STATUS1) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + case RSat::KFramesInformationChange: + // Expect TFramesInformationChangeV6 + if (!eventBaseV2.iDataAvailable) + ReqCompleted(aTsyReqHandle, KErrCorrupt); + else + { + RSat::TFramesInformationChangedEventV6Pckg* framesInfoChangedEventV6Pckg = (RSat::TFramesInformationChangedEventV6Pckg *)aEventInfo; + RSat::TFramesInformationChangedEventV6& framesInfoChangedEventV6 = (*framesInfoChangedEventV6Pckg)(); + + if ((framesInfoChangedEventV6.iFramesInformation.iFrameId != DSATTSY_FRAMES_INFORMATION_FRAMEID ) + || (framesInfoChangedEventV6.iFramesInformation.iFrameList != DSATTSY_FRAMES_INFORMATION_FRAME_LIST )) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + else + ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + + default: + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::EventDownloadCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::EventDownloadCancel called")); + + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + + iEventDownload = 0; + + return KErrNone; + } + + +TInt CSatDSatTsy::NotifyDisplayTextPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyDisplayTextPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyDisplayTextPCmd called")); + RSat::TDisplayTextV1Pckg* aPCmdPckg = (RSat::TDisplayTextV1Pckg*)aPCmd; + RSat::TDisplayTextV1& displayTextV1 = (*aPCmdPckg)(); + + displayTextV1.SetPCmdNumber(DSATTSY_DISPLAY_TEXT_NUMBER); + displayTextV1.iPriority =DSATTSY_TEXT_PRIORITY; + displayTextV1.iClearScreenTrigger =DSATTSY_CLEAR_SCREEN_TRIGGER; + displayTextV1.iText =DSATTSY_TEXT_TO_DISPLAY; + displayTextV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + displayTextV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + displayTextV1.iImmediateRsp =DSATTSY_IMMEDIATE_RSP; + + if ((displayTextV1.ExtensionId() == RSat::KSatV2) || + (displayTextV1.ExtensionId() == RSat::KSatV5) || (displayTextV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TDisplayTextV2Pckg* aV2PCmdPckg = (RSat::TDisplayTextV2Pckg*)aPCmd; + RSat::TDisplayTextV2& displayTextV2 = (*aV2PCmdPckg)(); + + displayTextV2.iDuration.iTimeUnit=DSATTSY_TIME_UNIT; + displayTextV2.iDuration.iNumOfUnits=DSATTSY_NUM_OF_UNITS; + } + + if ((displayTextV1.ExtensionId() == RSat::KSatV5) || (displayTextV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TDisplayTextV5Pckg* aV5PCmdPckg = (RSat::TDisplayTextV5Pckg*)aPCmd; + RSat::TDisplayTextV5& displayTextV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + displayTextV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + displayTextV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (displayTextV1.ExtensionId() == RSat::KSatV6) + { + RSat::TDisplayTextV6Pckg* displayTextV6PCmdPckg = (RSat::TDisplayTextV6Pckg*)aPCmd; + RSat::TDisplayTextV6& displayTextV6 = (*displayTextV6PCmdPckg)(); + + displayTextV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyDisplayTextPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyDisplayTextPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyDisplayTextPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetInkeyPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyGetInkeyPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetInkeyPCmd called")); + RSat::TGetInkeyV1Pckg* aPCmdPckg = (RSat::TGetInkeyV1Pckg*)aPCmd; + RSat::TGetInkeyV1& getInkeyV1 = (*aPCmdPckg)(); + + getInkeyV1.SetPCmdNumber(DSATTSY_GET_INKEY_NUMBER); + + getInkeyV1.iRspFormat =DSATTSY_USER_RSP_FORMAT; + getInkeyV1.iText =DSATTSY_TEXT_TO_DISPLAY; + getInkeyV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + getInkeyV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + getInkeyV1.iHelp =DSATTSY_HELP; + + if ((getInkeyV1.ExtensionId() == RSat::KSatV2) || + (getInkeyV1.ExtensionId() == RSat::KSatV5) || + (getInkeyV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TGetInkeyV2Pckg* aV2PCmdPckg = (RSat::TGetInkeyV2Pckg*)aPCmd; + RSat::TGetInkeyV2& getInkeyV2 = (*aV2PCmdPckg)(); + + getInkeyV2.iDuration.iTimeUnit=DSATTSY_TIME_UNIT; + getInkeyV2.iDuration.iNumOfUnits=DSATTSY_NUM_OF_UNITS; + getInkeyV2.iMode=DSATTSY_GET_INKEY_RSP_MODE; + } + + if ((getInkeyV1.ExtensionId() == RSat::KSatV5) || + (getInkeyV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TGetInkeyV5Pckg* aV5PCmdPckg = (RSat::TGetInkeyV5Pckg*)aPCmd; + RSat::TGetInkeyV5& getInkeyV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + getInkeyV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + getInkeyV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (getInkeyV1.ExtensionId() == RSat::KSatV6) + { + RSat::TGetInkeyV6Pckg* getInkeyV6PCmdPckg = (RSat::TGetInkeyV6Pckg*)aPCmd; + RSat::TGetInkeyV6& getInkeyV6 = (*getInkeyV6PCmdPckg)(); + + getInkeyV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetInkeyPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetInkeyPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyGetInkeyPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetInputPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyGetInputPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetInputPCmd called")); + RSat::TGetInputV1Pckg* aPCmdPckg = (RSat::TGetInputV1Pckg*)aPCmd; + RSat::TGetInputV1& getInputV1 = (*aPCmdPckg)(); + + getInputV1.SetPCmdNumber(DSATTSY_GET_INPUT_NUMBER); + + getInputV1.iInputDisplayOption =DSATTSY_INPUT_DISPLAY_OPTION; + getInputV1.iRspFormat =DSATTSY_GET_INPUT_RSP_FORMAT; + getInputV1.iText =DSATTSY_TEXT_TO_DISPLAY; + getInputV1.iRspLength.iMinRspLength =DSATTSY_MIN_RSP_LENGTH; + getInputV1.iRspLength.iMaxRspLength =DSATTSY_MAX_RSP_LENGTH; + getInputV1.iDefaultText =DSATTSY_DEFAULT_TEXT; + getInputV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + getInputV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + getInputV1.iHelp =DSATTSY_HELP; + + if ((getInputV1.ExtensionId() == RSat::KSatV5) || + (getInputV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TGetInputV5Pckg* aV5PCmdPckg = (RSat::TGetInputV5Pckg*)aPCmd; + RSat::TGetInputV5& getInputV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + getInputV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + getInputV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (getInputV1.ExtensionId() == RSat::KSatV6) + { + RSat::TGetInputV6Pckg* getInputV6PCmdPckg = (RSat::TGetInputV6Pckg*)aPCmd; + RSat::TGetInputV6& getInputV6 = (*getInputV6PCmdPckg)(); + + getInputV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1 ; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetInputPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetInputPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyGetInputPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPlayTonePCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyPlayTonePCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPlayTonePCmd called")); + RSat::TPlayToneV1Pckg* aPCmdPckg = (RSat::TPlayToneV1Pckg*)aPCmd; + RSat::TPlayToneV1& playToneV1 = (*aPCmdPckg)(); + + playToneV1.SetPCmdNumber(DSATTSY_PLAY_TONE_NUMBER); + + playToneV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + playToneV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + playToneV1.iTone =DSATTSY_TONE; + playToneV1.iDuration.iTimeUnit =DSATTSY_TIME_UNIT; + playToneV1.iDuration.iNumOfUnits =DSATTSY_NUM_OF_UNITS; + + if ((playToneV1.ExtensionId() == RSat::KSatV2) || + (playToneV1.ExtensionId() == RSat::KSatV5) || (playToneV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TPlayToneV2Pckg* aV2PCmdPckg = (RSat::TPlayToneV2Pckg*)aPCmd; + RSat::TPlayToneV2& playToneV2 = (*aV2PCmdPckg)(); + + playToneV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + playToneV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + } + + if ((playToneV1.ExtensionId() == RSat::KSatV5) || + (playToneV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TPlayToneV5Pckg* aV5PCmdPckg = (RSat::TPlayToneV5Pckg*)aPCmd; + RSat::TPlayToneV5& playToneV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + playToneV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + playToneV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (playToneV1.ExtensionId() == RSat::KSatV6) + { + RSat::TPlayToneV6Pckg* playToneV6PCmdPckg = (RSat::TPlayToneV6Pckg*)aPCmd; + RSat::TPlayToneV6& playToneV6 = (*playToneV6PCmdPckg)(); + + playToneV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1 ; + playToneV6.iTone=DSATTSY_TONEV6; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPlayTonePCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPlayTonePCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyPlayTonePCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpMenuPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + RSat::TItem item1, item2, item3, item4; + TUint action1=0x01, action2=0x02, action3=0x03, action4=0x04; + TUint iconId1=0x01, iconId2=0x02, iconId3=0x03, iconId4=0x04; + + RSat::TTextAttribute textAttribute1, textAttribute2, textAttribute3, textAttribute4; + + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpMenuPCmd called")); + RSat::TSetUpMenuV1Pckg* aPCmdPckg = (RSat::TSetUpMenuV1Pckg*)aPCmd; + RSat::TSetUpMenuV1& setUpMenuV1 = (*aPCmdPckg)(); + + item1.iItemId=0x01; + item1.iItemString=DSATTSY_ITEM1; + item2.iItemId=0x02; + item2.iItemString=DSATTSY_ITEM2; + item3.iItemId=0x03; + item3.iItemString=DSATTSY_ITEM3; + item4.iItemId=0x04; + item4.iItemString=DSATTSY_ITEM4; + + textAttribute1.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + textAttribute1.iTextAttributeData.Append(textAttributeData, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + textAttribute2.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS2; + const TUint8 textAttributeData2[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA2; + textAttribute2.iTextAttributeData.Append(textAttributeData2, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + textAttribute3.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS3; + const TUint8 textAttributeData3[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA3; + textAttribute3.iTextAttributeData.Append(textAttributeData3, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + textAttribute4.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS4; + const TUint8 textAttributeData4[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA4; + textAttribute4.iTextAttributeData.Append(textAttributeData4, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + setUpMenuV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + setUpMenuV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + setUpMenuV1.iHelp =DSATTSY_HELP; + setUpMenuV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + setUpMenuV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + setUpMenuV1.iIconListQualifier =DSATTSY_ICON_QUALIFIER2; + + setUpMenuV1.SetPCmdNumber(DSATTSY_SET_UP_MENU_NUMBER); + + if( (setUpMenuV1.ExtensionId() == RSat::KSatV2) || + (setUpMenuV1.ExtensionId() == RSat::KSatV5)) + { + RSat::TSetUpMenuV2Pckg* aV2PCmdPckg = (RSat::TSetUpMenuV2Pckg*)aPCmd; + RSat::TSetUpMenuV2& setUpMenuV2 = (*aV2PCmdPckg)(); + + setUpMenuV2.iPreference=DSATTSY_SELECTION_PREFERENCE; + } + + if(!iNotifySetUpMenuPCmd++) + { + switch (iNotifySetUpMenuTestNumber) + { + case 0: + setUpMenuV1.AddItem(item1); + setUpMenuV1.AddItem(item2); + setUpMenuV1.AddItem(item3); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + + break; + case 1: + setUpMenuV1.AddItem(item1, action1); + setUpMenuV1.AddItem(item2, action2); + setUpMenuV1.AddItem(item3, action3); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + + break; + case 2: + setUpMenuV1.AddItemIcon(item1, iconId1); + setUpMenuV1.AddItemIcon(item2, iconId2); + setUpMenuV1.AddItemIcon(item3, iconId3); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + + break; + case 3: + setUpMenuV1.AddItem(item1, action1, iconId1); + setUpMenuV1.AddItem(item2, action2, iconId2); + setUpMenuV1.AddItem(item3, action3, iconId3); + setUpMenuV1.AddItem(item4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + + break; + case 4: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV5.AddItem(item1, textAttribute1); + setUpMenuV5.AddItem(item2, textAttribute2); + setUpMenuV5.AddItem(item3, textAttribute3); + setUpMenuV5.AddItem(item4, textAttribute4); + + setUpMenuV5.iTextAttribute.iStatus = textAttribute1.iStatus; + setUpMenuV5.iTextAttribute.iTextAttributeData = textAttribute1.iTextAttributeData; + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + break; + case 5: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV5.AddItem(item1, textAttribute1, action1); + setUpMenuV5.AddItem(item2, textAttribute2, action2); + setUpMenuV5.AddItem(item3, textAttribute3, action3); + setUpMenuV5.AddItem(item4, textAttribute4, action4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + break; + case 6: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV5.AddItemIcon(item1, textAttribute1, iconId1); + setUpMenuV5.AddItemIcon(item2, textAttribute2, iconId2); + setUpMenuV5.AddItemIcon(item3, textAttribute3, iconId3); + setUpMenuV5.AddItemIcon(item4, textAttribute4, iconId4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + break; + case 7: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV5.AddItem(item1, textAttribute1, action1, iconId1); + setUpMenuV5.AddItem(item2, textAttribute2, action2, iconId2); + setUpMenuV5.AddItem(item3, textAttribute3, action3, iconId3); + setUpMenuV5.AddItem(item4, textAttribute4, action4, iconId4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + break; + case 8: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV5.AddItem(item1); + setUpMenuV5.AddItem(item2); + setUpMenuV5.AddItem(item3); + setUpMenuV5.AddItem(item4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + break; + case 9: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV5.AddItem(item1, action1); + setUpMenuV5.AddItem(item2, action2); + setUpMenuV5.AddItem(item3, action3); + setUpMenuV5.AddItem(item4, action4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + break; + case 10: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV1.AddItemIcon(item1, iconId1); + setUpMenuV1.AddItemIcon(item2, iconId2); + setUpMenuV1.AddItemIcon(item3, iconId3); + setUpMenuV1.AddItemIcon(item4, iconId4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + break; + case 11: + if(setUpMenuV1.ExtensionId() == RSat::KSatV5) + { + RSat::TSetUpMenuV5Pckg* aV5PCmdPckg = (RSat::TSetUpMenuV5Pckg*)aPCmd; + RSat::TSetUpMenuV5& setUpMenuV5 = (*aV5PCmdPckg)(); + + setUpMenuV5.AddItem(item1, action1, iconId1); + setUpMenuV5.AddItem(item2, action2, iconId2); + setUpMenuV5.AddItem(item3, action3, iconId3); + setUpMenuV5.AddItem(item4, action4, iconId4); + + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + } + else + { + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + break; + case 12: + iNotifySetUpMenuTestNumber ++; + ReqCompleted(aTsyReqHandle,KErrNone); + break; + default: + break; + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpMenuPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpMenuPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySetUpMenuPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySelectItemPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySelectItemPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySelectItemPCmd called")); + RSat::TSelectItemV1Pckg* aPCmdPckg = (RSat::TSelectItemV1Pckg*)aPCmd; + RSat::TSelectItemV1& selectItemV1 = (*aPCmdPckg)(); + + TUint action1=0x01, action2=0x02, action3=0x03; + RSat::TItem item1, item2, item3; + TUint iconId1=0x01, iconId2=0x02, iconId3=0x03; + + item1.iItemId=0x01; + item1.iItemString=DSATTSY_ITEM1; + item2.iItemId=0x02; + item2.iItemString=DSATTSY_ITEM2; + item3.iItemId=0x03; + item3.iItemString=DSATTSY_ITEM3; + + selectItemV1.SetPCmdNumber(DSATTSY_SELECT_ITEM_NUMBER); + + selectItemV1.iPresentationType =DSATTSY_PRESENTATION_TYPE; + selectItemV1.iHelp =DSATTSY_HELP; + selectItemV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + selectItemV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + selectItemV1.iDefaultItemId =DSATTSY_DEFAULT_ITEM; + selectItemV1.iIconId.iIdentifier=DSATTSY_ICON_ID1; + selectItemV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + selectItemV1.iIconListQualifier =DSATTSY_ICON_QUALIFIER2; + + if ((selectItemV1.ExtensionId() == RSat::KSatV1) || + (selectItemV1.ExtensionId() == RSat::KSatV2)) + { + selectItemV1.AddItem(item1, action1, iconId1); + selectItemV1.AddItem(item2, action2, iconId2); + selectItemV1.AddItem(item3, action3, iconId3); + } + + if ((selectItemV1.ExtensionId() == RSat::KSatV2) || + (selectItemV1.ExtensionId() == RSat::KSatV5) || (selectItemV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSelectItemV2Pckg* aV2PCmdPckg = (RSat::TSelectItemV2Pckg*)aPCmd; + RSat::TSelectItemV2& selectItemV2 = (*aV2PCmdPckg)(); + + selectItemV2.iPreference=DSATTSY_SELECTION_PREFERENCE; + } + + if ((selectItemV1.ExtensionId() == RSat::KSatV5) || + (selectItemV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSelectItemV5Pckg* aV5PCmdPckg = (RSat::TSelectItemV5Pckg*)aPCmd; + RSat::TSelectItemV5& selectItemV5 = (*aV5PCmdPckg)(); + + RSat::TTextAttribute textAttribute1, textAttribute2, textAttribute3; + + textAttribute1.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + textAttribute1.iTextAttributeData.Append(textAttributeData, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + textAttribute2.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS2; + const TUint8 textAttributeData2[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA2; + textAttribute2.iTextAttributeData.Append(textAttributeData2, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + textAttribute3.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS3; + const TUint8 textAttributeData3[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA3; + textAttribute3.iTextAttributeData.Append(textAttributeData3, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + selectItemV5.AddItem(item1, textAttribute1, action1, iconId1); + selectItemV5.AddItem(item2, textAttribute2, action2, iconId2); + selectItemV5.AddItem(item3, textAttribute3, action3, iconId3); + + selectItemV5.iTextAttribute = textAttribute1; + } + + if (selectItemV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSelectItemV6Pckg* selectItemV6PCmdPckg = (RSat::TSelectItemV6Pckg*)aPCmd; + RSat::TSelectItemV6& selectItemV6 = (*selectItemV6PCmdPckg)(); + + selectItemV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySelectItemPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySelectItemPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySelectItemPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendSmPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySendSmPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendSmPCmd called")); + RSat::TSendSmV1Pckg* aPCmdPckg = (RSat::TSendSmV1Pckg*)aPCmd; + RSat::TSendSmV1& sendSmV1 = (*aPCmdPckg)(); + + sendSmV1.SetPCmdNumber(DSATTSY_SEND_SM_NUMBER); + + sendSmV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + sendSmV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + sendSmV1.iAddress.iTypeOfNumber =DSATTSY_TON; + sendSmV1.iAddress.iNumberPlan =DSATTSY_NPI; + sendSmV1.iAddress.iTelNumber =DSATTSY_TEL_NUMBER; + sendSmV1.iSmsTpdu =DSATTSY_SMS_TPDU; + sendSmV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + sendSmV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + + if ((sendSmV1.ExtensionId() == RSat::KSatV5) || + (sendSmV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSendSmV5Pckg* aV5PCmdPckg = (RSat::TSendSmV5Pckg*)aPCmd; + RSat::TSendSmV5& sendSmV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + sendSmV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + sendSmV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (sendSmV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSendSmV6Pckg* sendSmV6PCmdPckg = (RSat::TSendSmV6Pckg*)aPCmd; + RSat::TSendSmV6& sendSmV6 = (*sendSmV6PCmdPckg)(); + + sendSmV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendSmPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendSmPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySendSmPCmd=0; + return KErrNone; + } + + +TInt CSatDSatTsy::SendMessageNoLogging(const TTsyReqHandle aTsyReqHandle, const TDesC8* aMsg, TUint16* aMsgRef) + { + LOGTEXT(_L8("CSatDSatTsy::SendMessageNoLogging called")); + RSat::TSatSmsV1Pckg* aMsgPckg = (RSat::TSatSmsV1Pckg*)aMsg; + RSat::TSatSmsV1& msgV1 = (*aMsgPckg)(); + + *aMsgRef=DSATTSY_SMS_REF; + + if ((msgV1.iServiceCenter.iNumberPlan!=DSATTSY_NPI) + ||(msgV1.iServiceCenter.iTypeOfNumber!=DSATTSY_TON) + ||(msgV1.iServiceCenter.iTelNumber!=DSATTSY_TEL_NUMBER) + ||(msgV1.iBuf!=DSATTSY_SMS_TPDU)) + ReqCompleted(aTsyReqHandle,KErrCorrupt); + else + if(!iSendMessageNoLogging++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::SendMessageNoLoggingCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::SendMessageNoLoggingCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendSsPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySendSsPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendSsPCmd called")); + RSat::TSendSsV1Pckg* aPCmdPckg = (RSat::TSendSsV1Pckg*)aPCmd; + RSat::TSendSsV1& sendSsV1 = (*aPCmdPckg)(); + + sendSsV1.SetPCmdNumber(DSATTSY_SEND_SS_NUMBER); + + sendSsV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + sendSsV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + sendSsV1.iSsString.iTypeOfNumber =DSATTSY_TON; + sendSsV1.iSsString.iNumberPlan =DSATTSY_NPI; + sendSsV1.iSsString.iSsString =DSATTSY_SS_STRING; + sendSsV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + sendSsV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + + if (sendSsV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSendSsV6Pckg* sendSsV6PCmdPckg = (RSat::TSendSsV6Pckg*)aPCmd; + RSat::TSendSsV6& sendSsV6 = (*sendSsV6PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + sendSsV6.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + sendSsV6.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendSsPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendSsPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySendSsPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendUssdPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySendUssdPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendUssdPCmd called")); + RSat::TSendUssdV1Pckg* aPCmdPckg = (RSat::TSendUssdV1Pckg*)aPCmd; + RSat::TSendUssdV1& sendUssdV1 = (*aPCmdPckg)(); + + sendUssdV1.SetPCmdNumber(DSATTSY_SEND_USSD_NUMBER); + + sendUssdV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + sendUssdV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + sendUssdV1.iUssdString.iDcs =DSATTSY_DCS; + sendUssdV1.iUssdString.iUssdString =DSATTSY_USSD_STRING; + sendUssdV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + sendUssdV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + + if (sendUssdV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSendUssdV6Pckg* sendUssdV6PCmdPckg = (RSat::TSendUssdV6Pckg*)aPCmd; + RSat::TSendUssdV6& sendUssdV6 = (*sendUssdV6PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + sendUssdV6.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + sendUssdV6.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendUssdPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendUssdPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySendUssdPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpCallPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySetUpCallPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpCallPCmd called")); + RSat::TSetUpCallV1Pckg* aPCmdPckg = (RSat::TSetUpCallV1Pckg*)aPCmd; + RSat::TSetUpCallV1& setUpCallV1 = (*aPCmdPckg)(); + + setUpCallV1.SetPCmdNumber(DSATTSY_SET_UP_CALL_NUMBER); + + setUpCallV1.iType =DSATTSY_SET_UP_CALL_TYPE; + setUpCallV1.iAlphaIdConfirmationPhase.iAlphaId =DSATTSY_ALPHA_ID1; + setUpCallV1.iAlphaIdConfirmationPhase.iStatus =DSATTSY_ALPHA_ID1_STATUS; + setUpCallV1.iIconIdConfirmationPhase.iIdentifier=DSATTSY_ICON_ID1; + setUpCallV1.iIconIdConfirmationPhase.iQualifier =DSATTSY_ICON_QUALIFIER1; + setUpCallV1.iAddress.iTypeOfNumber =DSATTSY_TON; + setUpCallV1.iAddress.iNumberPlan =DSATTSY_NPI; + setUpCallV1.iAddress.iTelNumber =DSATTSY_TEL_NUMBER; + setUpCallV1.iCapabilityConfigParams =DSATTSY_CCP1; + setUpCallV1.iSubAddress =DSATTSY_SUBADDRESS; + setUpCallV1.iDuration.iTimeUnit =DSATTSY_TIME_UNIT; + setUpCallV1.iDuration.iNumOfUnits =DSATTSY_NUM_OF_UNITS; + setUpCallV1.iAlphaIdCallSetUpPhase.iAlphaId =DSATTSY_ALPHA_ID2; + setUpCallV1.iAlphaIdCallSetUpPhase.iStatus =DSATTSY_ALPHA_ID2_STATUS; + setUpCallV1.iIconIdCallSetUpPhase.iIdentifier =DSATTSY_ICON_ID2; + setUpCallV1.iIconIdCallSetUpPhase.iQualifier =DSATTSY_ICON_QUALIFIER2; + + if ((setUpCallV1.ExtensionId() == RSat::KSatV5) || + (setUpCallV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSetUpCallV5Pckg* aV5PCmdPckg = (RSat::TSetUpCallV5Pckg*)aPCmd; + RSat::TSetUpCallV5& setUpCallV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + setUpCallV5.iTextAttributeConfirmationPhase.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + setUpCallV5.iTextAttributeConfirmationPhase.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + setUpCallV5.iTextAttributeCallSetUpPhase.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + setUpCallV5.iTextAttributeCallSetUpPhase.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (setUpCallV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSetUpCallV6Pckg* setUpCallV6PCmdPckg = (RSat::TSetUpCallV6Pckg*)aPCmd; + RSat::TSetUpCallV6& setUpCallV6 = (*setUpCallV6PCmdPckg)(); + + setUpCallV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1 ; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpCallPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpCallPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySetUpCallPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRefreshPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyRefreshPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRefreshPCmd called")); + RSat::TRefreshV1Pckg* aPCmdPckg = (RSat::TRefreshV1Pckg*)aPCmd; + RSat::TRefreshV1& refreshV1 = (*aPCmdPckg)(); + + refreshV1.SetPCmdNumber(DSATTSY_REFRESH_NUMBER); + + refreshV1.iType = DSATTSY_REFRESH_TYPE; + refreshV1.iFileList.Append(DSATTSY_REFRESH_ADN_EF); + refreshV1.iFileList.Append(DSATTSY_REFRESH_FDN_EF); + + + if (refreshV1.ExtensionId()==RSat::KSatV2) + { + RSat::TRefreshV2Pckg* aV2PCmdPckg = (RSat::TRefreshV2Pckg*)aPCmd; + RSat::TRefreshV2& refreshV2 = (*aV2PCmdPckg)(); + + refreshV2.iAid=DSATTSY_AID; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRefreshPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRefreshPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyRefreshPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpEventListPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySetUpEventListPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpEventListPCmd called")); + RSat::TSetUpEventListV1Pckg* aPCmdPckg = (RSat::TSetUpEventListV1Pckg*)aPCmd; + RSat::TSetUpEventListV1& setUpEventListV1 = (*aPCmdPckg)(); + + setUpEventListV1.SetPCmdNumber(DSATTSY_SET_UP_EVENT_LIST_NUMBER); + + setUpEventListV1.iType =DSATTSY_SET_UP_EVENT_LIST_TYPE; + setUpEventListV1.iEvents =DSATTSY_EVENTS; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpEventListPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpEventListPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySetUpEventListPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpIdleModeTextPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySetUpIdleModeTextPCmd++) + { + // First Request: set idle text mode to max length Unicode string + if (iSetUpIdleModeTextCommandCount++ == 0) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpIdleModeTextPCmd called")); + RSat::TSetUpIdleModeTextV1Pckg* aPCmdPckg = (RSat::TSetUpIdleModeTextV1Pckg*)aPCmd; + RSat::TSetUpIdleModeTextV1& setUpIdleModeTextV1 = (*aPCmdPckg)(); + + setUpIdleModeTextV1.SetPCmdNumber(DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER); + + setUpIdleModeTextV1.iType =DSATTSY_IDLE_MODE_TXT_TYPE; + setUpIdleModeTextV1.iText =DSATTSY_IDLE_MODE_TEXT; + setUpIdleModeTextV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + setUpIdleModeTextV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + + setUpIdleModeTextV1.iCodingScheme =DSATTSY_TEXT_ENCODING_SCHEME; + + if ((setUpIdleModeTextV1.ExtensionId() == RSat::KSatV5)|| + (setUpIdleModeTextV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSetUpIdleModeTextV5Pckg* aV5PCmdPckg = (RSat::TSetUpIdleModeTextV5Pckg*)aPCmd; + RSat::TSetUpIdleModeTextV5& setUpIdleModeTextV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + setUpIdleModeTextV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + setUpIdleModeTextV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (setUpIdleModeTextV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSetUpIdleModeTextV6Pckg* setUpIdleModeTextV6PCmdPckg = (RSat::TSetUpIdleModeTextV6Pckg*)aPCmd; + RSat::TSetUpIdleModeTextV6& setUpIdleModeTextV6 = (*setUpIdleModeTextV6PCmdPckg)(); + + setUpIdleModeTextV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + else // second request: set idle text mode to max length 8-bit string + { + // reset command count + iSetUpIdleModeTextCommandCount = 0; + + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpIdleModeTextPCmd called")); + RSat::TSetUpIdleModeTextV1Pckg* aPCmdPckg = (RSat::TSetUpIdleModeTextV1Pckg*)aPCmd; + RSat::TSetUpIdleModeTextV1& setUpIdleModeTextV1 = (*aPCmdPckg)(); + + setUpIdleModeTextV1.SetPCmdNumber(DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER); + + setUpIdleModeTextV1.iType =DSATTSY_IDLE_MODE_TXT_TYPE; + CnvUtfConverter::ConvertToUnicodeFromUtf8(setUpIdleModeTextV1.iText,DSATTSY_IDLE_MODE_TEXT_8BIT); + setUpIdleModeTextV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + setUpIdleModeTextV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + + setUpIdleModeTextV1.iCodingScheme =DSATTSY_TEXT_ENCODING_SCHEME_8; + + if ((setUpIdleModeTextV1.ExtensionId() == RSat::KSatV5) || + (setUpIdleModeTextV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSetUpIdleModeTextV5Pckg* aV5PCmdPckg = (RSat::TSetUpIdleModeTextV5Pckg*)aPCmd; + RSat::TSetUpIdleModeTextV5& setUpIdleModeTextV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + setUpIdleModeTextV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + setUpIdleModeTextV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (setUpIdleModeTextV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSetUpIdleModeTextV6Pckg* setUpIdleModeTextV6PCmdPckg = (RSat::TSetUpIdleModeTextV6Pckg*)aPCmd; + RSat::TSetUpIdleModeTextV6& setUpIdleModeTextV6 = (*setUpIdleModeTextV6PCmdPckg)(); + + setUpIdleModeTextV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetUpIdleModeTextPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetUpIdleModeTextPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySetUpIdleModeTextPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendDtmfPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySendDtmfPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendDtmfPCmd called")); + RSat::TSendDtmfV1Pckg* aPCmdPckg = (RSat::TSendDtmfV1Pckg*)aPCmd; + RSat::TSendDtmfV1& sendDtmfV1 = (*aPCmdPckg)(); + + sendDtmfV1.SetPCmdNumber(DSATTSY_SEND_DTMF_NUMBER); + + sendDtmfV1.iAlphaId.iAlphaId =DSATTSY_ALPHA_ID1; + sendDtmfV1.iAlphaId.iStatus =DSATTSY_ALPHA_ID1_STATUS; + sendDtmfV1.iDtmfString =DSATTSY_DTMF_STRING; + sendDtmfV1.iIconId.iIdentifier =DSATTSY_ICON_ID1; + sendDtmfV1.iIconId.iQualifier =DSATTSY_ICON_QUALIFIER1; + + if ((sendDtmfV1.ExtensionId() == RSat::KSatV5) || + (sendDtmfV1.ExtensionId() == RSat::KSatV6)) + { + RSat::TSendDtmfV5Pckg* aV5PCmdPckg = (RSat::TSendDtmfV5Pckg*)aPCmd; + RSat::TSendDtmfV5& sendDtmfV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + sendDtmfV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + sendDtmfV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (sendDtmfV1.ExtensionId() == RSat::KSatV6) + { + RSat::TSendDtmfV6Pckg* sendDtmfV6PCmdPckg = (RSat::TSendDtmfV6Pckg*)aPCmd; + RSat::TSendDtmfV6& sendDtmfV6 = (*sendDtmfV6PCmdPckg)(); + + sendDtmfV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendDtmfPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendDtmfPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySendDtmfPCmd=0; + return KErrNone; + } + +// +// New Typhoon and Jetstream API +// + +TInt CSatDSatTsy::UsatClientReadyIndication(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::UsatClientReadyIndication called")); + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPerformCardApduPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyPerformCardApduPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPerformCardApduPCmd called")); + RSat::TPerformCardApduV2Pckg* aV2PCmdPckg = (RSat::TPerformCardApduV2Pckg*)aPCmd; + RSat::TPerformCardApduV2& performCardApduV2 = (*aV2PCmdPckg)(); + + performCardApduV2.SetPCmdNumber(DSATTSY_PERFORM_CARD_APDU_NUMBER); + + performCardApduV2.iDestination=DSATTSY_CARD_READER_1; + performCardApduV2.iCApdu.iCla=DSATTSY_CLA; + performCardApduV2.iCApdu.iIns=DSATTSY_INS; + performCardApduV2.iCApdu.iLc=DSATTSY_LC; + performCardApduV2.iCApdu.iLe=DSATTSY_LE; + performCardApduV2.iCApdu.iP1=DSATTSY_P1; + performCardApduV2.iCApdu.iP2=DSATTSY_P2; + performCardApduV2.iCApdu.iData=DSATTSY_CAPDU; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPerformCardApduPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPerformCardApduPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyPerformCardApduPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPowerOffCardPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyPowerOffCardPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPowerOffCardPCmd called")); + RSat::TPowerOffCardV2Pckg* aV2PCmdPckg = (RSat::TPowerOffCardV2Pckg*)aPCmd; + RSat::TPowerOffCardV2& powerOffCardV2 = (*aV2PCmdPckg)(); + + powerOffCardV2.SetPCmdNumber(DSATTSY_POWER_OFF_CARD_NUMBER); + powerOffCardV2.iDestination=DSATTSY_CARD_READER_1; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPowerOffCardPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPowerOffCardPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyPowerOffCardPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPowerOnCardPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyPowerOnCardPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPowerOnCardPCmd called")); + RSat::TPowerOnCardV2Pckg* aV2PCmdPckg = (RSat::TPowerOnCardV2Pckg*)aPCmd; + RSat::TPowerOnCardV2& powerOnCardV2 = (*aV2PCmdPckg)(); + + powerOnCardV2.SetPCmdNumber(DSATTSY_POWER_ON_CARD_NUMBER); + powerOnCardV2.iDestination=DSATTSY_CARD_READER_1; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPowerOnCardPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPowerOnCardPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyPowerOnCardPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetReaderStatusPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyGetReaderStatusPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetReaderStatusPCmd called")); + RSat::TGetReaderStatusV2Pckg* aV2PCmdPckg = (RSat::TGetReaderStatusV2Pckg*)aPCmd; + RSat::TGetReaderStatusV2& getReaderStatusV2 = (*aV2PCmdPckg)(); + + getReaderStatusV2.SetPCmdNumber(DSATTSY_GET_READER_STATUS_NUMBER); + getReaderStatusV2.iDestination=DSATTSY_CARD_READER_1; + getReaderStatusV2.iMode=DSATTSY_GET_READER_STATUS_MODE; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetReaderStatusPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetReaderStatusPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyGetReaderStatusPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRunAtCommandPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyRunAtCommandPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRunAtCommandPCmd called")); + RSat::TRunAtCommandV2Pckg* aV2PCmdPckg = (RSat::TRunAtCommandV2Pckg*)aPCmd; + RSat::TRunAtCommandV2& runAtCmdV2 = (*aV2PCmdPckg)(); + + runAtCmdV2.SetPCmdNumber(DSATTSY_RUN_AT_COMMAND_NUMBER); + runAtCmdV2.iAlphaId.iStatus=DSATTSY_ALPHA_ID1_STATUS; + runAtCmdV2.iAlphaId.iAlphaId=DSATTSY_ALPHA_ID1; + runAtCmdV2.iAtCommand=DSATTSY_AT_COMMAND; + runAtCmdV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + runAtCmdV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + + if ((runAtCmdV2.ExtensionId() == RSat::KSatV5) || + (runAtCmdV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TRunAtCommandV5Pckg* aV5PCmdPckg = (RSat::TRunAtCommandV5Pckg*)aPCmd; + RSat::TRunAtCommandV5& runAtCmdV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + runAtCmdV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + runAtCmdV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (runAtCmdV2.ExtensionId() == RSat::KSatV6) + { + RSat::TRunAtCommandV6Pckg* runAtCmdV6PCmdPckg = (RSat::TRunAtCommandV6Pckg*)aPCmd; + RSat::TRunAtCommandV6& runAtCmdV6 = (*runAtCmdV6PCmdPckg)(); + + runAtCmdV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRunAtCommandPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRunAtCommandPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyRunAtCommandPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyLanguageNotificationPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyLanguageNotificationPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyLanguageNotificationPCmd called")); + RSat::TLanguageNotificationV2Pckg* aV2PCmdPckg = (RSat::TLanguageNotificationV2Pckg*)aPCmd; + RSat::TLanguageNotificationV2& languageNotificationV2 = (*aV2PCmdPckg)(); + + languageNotificationV2.SetPCmdNumber(DSATTSY_LANGUAGE_NOTIFICATION_NUMBER); + languageNotificationV2.iNotificationType=DSATTSY_SPECIFIC_LANGUAGE; + languageNotificationV2.iLanguage=DSATTSY_FRENCH; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyLanguageNotificationPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyLanguageNotificationPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyLanguageNotificationPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::GetProvisioningRefFile(const TTsyReqHandle aTsyReqHandle, const RSat::TProvisioningFileRef* aFileRef, TDes8* aFile) +/** +* GetProviosioningRefFile is called to ask the ICC to return a file name +* that corresponds to a given file reference. +* +* This test code can only return 2 files - it distinguishes between them based on +* the length of the file reference passed. Any 1 byte ref will return file1, any +* 128 byte ref will return file2. Any other length will return "not found". +*/ + { + if(!iGetProvisioningRefFile++) + { + LOGTEXT(_L8("CSatDSatTsy::GetProvisioningRefFile called")); + + // We only understand 2 references (at the moment) - use the simple minded approach and select by length + + TInt len = aFileRef->Length(); + + switch (len) + { + case 1: + *aFile = DSATTSY_FILE1; + ReqCompleted(aTsyReqHandle,KErrNone); + break; + + case 128: + *aFile = DSATTSY_FILE2; + ReqCompleted(aTsyReqHandle,KErrNone); + break; + + default: + ReqCompleted(aTsyReqHandle,KErrNotFound); + break; + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetProvisioningRefFileCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::GetProvisioningRefFileCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + + iGetProvisioningRefFile = 0; + + return KErrNone; + } + +TInt CSatDSatTsy::NotifyLaunchBrowserPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyLaunchBrowserPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyLaunchBrowserPCmd called")); + RSat::TLaunchBrowserV2Pckg* aV2PCmdPckg = (RSat::TLaunchBrowserV2Pckg*)aPCmd; + RSat::TLaunchBrowserV2& launchBrowserV2 = (*aV2PCmdPckg)(); + + launchBrowserV2.SetPCmdNumber(DSATTSY_LAUNCH_BROWSER_NUMBER); + + launchBrowserV2.iBrowserSel = DSATTSY_BROWSER_SELECTION_MODE; + launchBrowserV2.iBrowserId = DSATTSY_BROWSER_ID; + launchBrowserV2.iUrl = DSATTSY_URL; + launchBrowserV2.iBearerList = DSATTSY_BEARER_LIST; + launchBrowserV2.iText = DSATTSY_PROXY_NAME; + launchBrowserV2.iAlphaId.iStatus = DSATTSY_ALPHA_ID1_STATUS; + launchBrowserV2.iAlphaId.iAlphaId = DSATTSY_ALPHA_ID1; + launchBrowserV2.iIconId.iIdentifier = DSATTSY_ICON_ID1; + launchBrowserV2.iIconId.iQualifier = DSATTSY_ICON_QUALIFIER1; + + if ((launchBrowserV2.ExtensionId() == RSat::KSatV5) || (launchBrowserV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TLaunchBrowserV5Pckg* aV5PCmdPckg = (RSat::TLaunchBrowserV5Pckg*)aPCmd; + RSat::TLaunchBrowserV5& launchBrowserV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + launchBrowserV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + launchBrowserV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (launchBrowserV2.ExtensionId() == RSat::KSatV6) + { + RSat::TLaunchBrowserV6Pckg* launchBrowserV6PCmdPckg = (RSat::TLaunchBrowserV6Pckg*)aPCmd; + RSat::TLaunchBrowserV6& launchBrowserV6 = (*launchBrowserV6PCmdPckg)(); + + launchBrowserV6.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + RSat::TProvisioningFileRef file; + + switch(iNotifyLaunchBrowserCount++) + { + case 0: // Return 1 file ref of 1 byte length + launchBrowserV2.ResetFileRef(); + file = DSATTSY_FILE_REF_DATA_1; + launchBrowserV2.AddFileRef( file ); + ReqCompleted(aTsyReqHandle,KErrNone); + break; + + case 1: // Return 1 file ref of 128 byte length + launchBrowserV2.ResetFileRef(); + file = DSATTSY_FILE_REF_DATA_128; + launchBrowserV2.AddFileRef( file ); + ReqCompleted(aTsyReqHandle,KErrNone); + break; + + case 2: // Return 2 files refs of 1 byte length (each) + launchBrowserV2.ResetFileRef(); + file = DSATTSY_FILE_REF_DATA_1; + launchBrowserV2.AddFileRef( file ); + launchBrowserV2.AddFileRef( file ); + ReqCompleted(aTsyReqHandle,KErrNone); + break; + + case 3: // Partial failure, try to add 2 file refs of 128 bytes each, + // Second add should fail with KErrOverflow as combined length + // is bigger than buffer + // - actually returns 1 file ref of 128 bytes unless unexpected result from add + { + launchBrowserV2.ResetFileRef(); + file = DSATTSY_FILE_REF_DATA_128; + launchBrowserV2.AddFileRef( file ); + TInt status = launchBrowserV2.AddFileRef( file ); // Expect to fail on this one + if (status != KErrOverflow) + ReqCompleted(aTsyReqHandle, status); + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + break; + + case 4: // Fall through to default case from case 4 + default: // Return 2 file refs, 1st=128 bytes long, 2nd=1 byte long + iNotifyLaunchBrowserCount = 0; // Reset selection count - next time through will use case 0 + + launchBrowserV2.ResetFileRef(); + file = DSATTSY_FILE_REF_DATA_128; + launchBrowserV2.AddFileRef( file ); + file = DSATTSY_FILE_REF_DATA_1; + launchBrowserV2.AddFileRef( file ); + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyLaunchBrowserPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyLaunchBrowserPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyLaunchBrowserPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyOpenChannelPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) +/** +* If this function is called with PCmd type of RSat::EAnyBearer then the code will +* return a type of RSat::ECsBearer. Subsequent calls will return the sequence +* RSat::EGprsBearer, RSat::ELocalLinksBearer, RSat::EPCmdTypeNotSet. The +* sequence then restarts with RSat::ECsBearer. +*/ + { + if(!iNotifyOpenChannelPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyOpenChannelPCmd called")); + RSat::TOpenChannelBaseV2Pckg* aV2PCmdPckg = (RSat::TOpenChannelBaseV2Pckg*)aPCmd; + RSat::TOpenChannelBaseV2& openChannelBaseV2 = (*aV2PCmdPckg)(); + + openChannelBaseV2.SetPCmdNumber(DSATTSY_OPEN_CHANNEL_NUMBER); + + openChannelBaseV2.iLinkEst=DSATTSY_ON_DEMAND_ESTABLISHMENT; + openChannelBaseV2.iReconnectionMode=DSATTSY_AUTO_RECONNECTION; + openChannelBaseV2.iAlphaId.iStatus=DSATTSY_ALPHA_ID1_STATUS; + openChannelBaseV2.iAlphaId.iAlphaId=DSATTSY_ALPHA_ID1; + openChannelBaseV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + openChannelBaseV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + openChannelBaseV2.iBearer.iType=DSATTSY_CSD_BEARER_TYPE; + openChannelBaseV2.iBearer.iParams=DSATTSY_BEARER_PARAMS; + openChannelBaseV2.iBufferSize=DSATTSY_BUFFER_SIZE; + openChannelBaseV2.iSimMeInterface.iPrtNumber=DSATTSY_PORT_1; + openChannelBaseV2.iSimMeInterface.iTransportProto=DSATTSY_TCP_PROTO; + openChannelBaseV2.iDestinationAddress.iType=DSATTSY_IPV4_TYPE; + openChannelBaseV2.iDestinationAddress.iAddress=DSATTSY_ADDRESS; + + switch (openChannelBaseV2.iPCmdType) + { + case RSat::EPCmdTypeNotSet: + ReqCompleted(aTsyReqHandle,KErrArgument); + break; + case RSat::ECsBearer: + { + RSat::TOpenCsChannelV2Pckg* aV2CsPCmdPckg = (RSat::TOpenCsChannelV2Pckg*)aPCmd; + RSat::TOpenCsChannelV2& openCsChannelV2 = (*aV2CsPCmdPckg)(); + + openCsChannelV2.iAddress.iTypeOfNumber=DSATTSY_TON; + openCsChannelV2.iAddress.iNumberPlan=DSATTSY_NPI; + openCsChannelV2.iAddress.iTelNumber=DSATTSY_TEL_NUMBER; + openCsChannelV2.iSubAddress=DSATTSY_SUBADDRESS; + openCsChannelV2.iDuration1.iTimeUnit=DSATTSY_TIME_UNIT; + openCsChannelV2.iDuration1.iNumOfUnits=DSATTSY_NUM_OF_UNITS; + openCsChannelV2.iDuration2.iTimeUnit=DSATTSY_TIME_UNIT; + openCsChannelV2.iDuration2.iNumOfUnits=DSATTSY_TIME_UNIT; + openCsChannelV2.iLocalAddress.iType=DSATTSY_IPV4_TYPE; + openCsChannelV2.iLocalAddress.iAddress=DSATTSY_ADDRESS; + openCsChannelV2.iUserLogin=DSATTSY_LOGIN; + openCsChannelV2.iUserPassword=DSATTSY_PASSWORD; + + if ((openCsChannelV2.ExtensionId() == RSat::KSatV5) + || (openCsChannelV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TOpenCsChannelV5Pckg* aV5PCmdPckg = (RSat::TOpenCsChannelV5Pckg*)aPCmd; + RSat::TOpenCsChannelV5& openCsChannelV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + openCsChannelV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + openCsChannelV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (openCsChannelV2.ExtensionId() == RSat::KSatV6) + { + RSat::TOpenCsChannelV6Pckg* csV6PCmdPckg = (RSat::TOpenCsChannelV6Pckg*)aPCmd; + RSat::TOpenCsChannelV6& openCsChannelV6 = (*csV6PCmdPckg)(); + + openCsChannelV6.iFrameId = DSATTSYV6_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case RSat::EGprsBearer: + { + RSat::TOpenGprsChannelV2Pckg* aV2GprsPCmdPckg = (RSat::TOpenGprsChannelV2Pckg*)aPCmd; + RSat::TOpenGprsChannelV2& openGprsChannelV2 = (*aV2GprsPCmdPckg)(); + + openGprsChannelV2.iAccessName=DSATTSY_ACCESS_NAME; + openGprsChannelV2.iLocalAddress.iType=DSATTSY_IPV4_TYPE; + openGprsChannelV2.iLocalAddress.iAddress=DSATTSY_ADDRESS; + + if ((openGprsChannelV2.ExtensionId() == RSat::KSatV4) + || (openGprsChannelV2.ExtensionId() == RSat::KSatV5) + || (openGprsChannelV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TOpenGprsChannelV4Pckg* aV4GprsPCmdPckg = reinterpret_cast(aPCmd); + RSat::TOpenGprsChannelV4& openGprsChannelV4 = (*aV4GprsPCmdPckg)(); + + openGprsChannelV4.iUserLogin=DSATTSY_LOGIN; + openGprsChannelV4.iUserPassword=DSATTSY_PASSWORD; + } + + if ((openGprsChannelV2.ExtensionId() == RSat::KSatV5) + || (openGprsChannelV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TOpenGprsChannelV5Pckg* aV5PCmdPckg = (RSat::TOpenGprsChannelV5Pckg*)aPCmd; + RSat::TOpenGprsChannelV5& openGprsChannelV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + openGprsChannelV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + openGprsChannelV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (openGprsChannelV2.ExtensionId() == RSat::KSatV6) + { + RSat::TOpenGprsChannelV6Pckg* gprsV6PCmdPckg = (RSat::TOpenGprsChannelV6Pckg*)aPCmd; + RSat::TOpenGprsChannelV6& openGprsChannelV6 = (*gprsV6PCmdPckg)(); + + openGprsChannelV6.iFrameId = DSATTSYV6_FRAME_IDENTIFIER1; + openGprsChannelV6.iBearer.iType=DSATTSYV6_GPRS_BEARER_TYPE1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case RSat::ELocalLinksBearer: + { + RSat::TOpenLocalLinksChannelV2Pckg* aV2LocalPCmdPckg = (RSat::TOpenLocalLinksChannelV2Pckg*)aPCmd; + RSat::TOpenLocalLinksChannelV2& openLocalChannelV2 = (*aV2LocalPCmdPckg)(); + + openLocalChannelV2.iDuration1.iTimeUnit=DSATTSY_TIME_UNIT; + openLocalChannelV2.iDuration1.iNumOfUnits=DSATTSY_TIME_UNIT; + openLocalChannelV2.iDuration2.iTimeUnit=DSATTSY_TIME_UNIT; + openLocalChannelV2.iDuration2.iNumOfUnits=DSATTSY_TIME_UNIT; + openLocalChannelV2.iRemoteAddress.iCoding=DSATTSY_CODING; + openLocalChannelV2.iRemoteAddress.iAddress=DSATTSY_ADDRESS; + openLocalChannelV2.iUserPassword=DSATTSY_PASSWORD; + + if ((openLocalChannelV2.ExtensionId() == RSat::KSatV5) + || (openLocalChannelV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TOpenLocalLinksChannelV5Pckg* aV5PCmdPckg = (RSat::TOpenLocalLinksChannelV5Pckg*)aPCmd; + RSat::TOpenLocalLinksChannelV5& openLocalChannelV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + openLocalChannelV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + openLocalChannelV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (openLocalChannelV2.ExtensionId() == RSat::KSatV6) + { + RSat::TOpenLocalLinksChannelV6Pckg* localV6PCmdPckg = (RSat::TOpenLocalLinksChannelV6Pckg*)aPCmd; + RSat::TOpenLocalLinksChannelV6& openLocalChannelV6 = (*localV6PCmdPckg)(); + + openLocalChannelV6.iFrameId = DSATTSYV6_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case RSat::EUiccServerMode: + { + RSat::TOpenUiccServerModeChannelV7Pckg* aV7PCmdPckg = (RSat::TOpenUiccServerModeChannelV7Pckg*)aPCmd; + RSat::TOpenUiccServerModeChannelV7& uiccServerModeChannelV7 = (*aV7PCmdPckg)(); + + uiccServerModeChannelV7.iPCmdType = DSATTSY_UICC_SERVER_MODE; + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + uiccServerModeChannelV7.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + uiccServerModeChannelV7.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + uiccServerModeChannelV7.iFrameId=DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case RSat::EAnyBearer: + { + // Monitor all kind of open channel PCmd + + // Select type of channel PCmd that has 'opened' + + switch(iNotifyAnyBearerCount++) + { + case 0: + { + // This iteration set bearer type to "CS" + + RSat::TOpenCsChannelV2Pckg* aV2CsPCmdPckg = (RSat::TOpenCsChannelV2Pckg*)aPCmd; + RSat::TOpenCsChannelV2& openCsChannelV2 = (*aV2CsPCmdPckg)(); + + openCsChannelV2.iPCmdType = RSat::ECsBearer; + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case 1: + { + // This iteration set bearer type to "GPRS" + + RSat::TOpenGprsChannelV2Pckg* aV2GprsPCmdPckg = (RSat::TOpenGprsChannelV2Pckg*)aPCmd; + RSat::TOpenGprsChannelV2& openGprsChannelV2 = (*aV2GprsPCmdPckg)(); + + openGprsChannelV2.iPCmdType = RSat::EGprsBearer; + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case 2: + { + // This iteration set bearer type to "Local Link" + + RSat::TOpenLocalLinksChannelV2Pckg* aV2LocalPCmdPckg = (RSat::TOpenLocalLinksChannelV2Pckg*)aPCmd; + RSat::TOpenLocalLinksChannelV2& openLocalChannelV2 = (*aV2LocalPCmdPckg)(); + + openLocalChannelV2.iPCmdType = RSat::ELocalLinksBearer; + + ReqCompleted(aTsyReqHandle, KErrNone); + + break; + } + default: + { + // Next iteration bearer will be "CS" + + iNotifyAnyBearerCount = 0; + + // Current iteration will return a failure ("type not set") in base channel + + openChannelBaseV2.iPCmdType = RSat::EPCmdTypeNotSet; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + } + default: + ReqCompleted(aTsyReqHandle,KErrArgument); + } + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::GetOpenChannelPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + /** + * This function should be called with PCmd type set to RSat::ECsBearer, + * RSat::EGprsBearer or RSat::ELocalLinksBearer. + */ + LOGTEXT(_L8("CSatDSatTsy::GetOpenChannelPCmd called")); + RSat::TOpenChannelBaseV2Pckg* aV2PCmdPckg = (RSat::TOpenChannelBaseV2Pckg*)aPCmd; + RSat::TOpenChannelBaseV2& openChannelV2 = (*aV2PCmdPckg)(); + + switch (openChannelV2.iPCmdType) + { + case RSat::EPCmdTypeNotSet: + ReqCompleted(aTsyReqHandle,KErrArgument); + break; + case RSat::ECsBearer: + { + RSat::TOpenCsChannelV2Pckg* aV2CsPCmdPckg = (RSat::TOpenCsChannelV2Pckg*)aPCmd; + RSat::TOpenCsChannelV2& openCsChannelV2 = (*aV2CsPCmdPckg)(); + + openCsChannelV2.iAddress.iTypeOfNumber=DSATTSY_TON; + openCsChannelV2.iAddress.iNumberPlan=DSATTSY_NPI; + openCsChannelV2.iAddress.iTelNumber=DSATTSY_TEL_NUMBER; + openCsChannelV2.iSubAddress=DSATTSY_SUBADDRESS; + openCsChannelV2.iDuration1.iTimeUnit=DSATTSY_TIME_UNIT; + openCsChannelV2.iDuration1.iNumOfUnits=DSATTSY_NUM_OF_UNITS; + openCsChannelV2.iDuration2.iTimeUnit=DSATTSY_TIME_UNIT; + openCsChannelV2.iDuration2.iNumOfUnits=DSATTSY_TIME_UNIT; + openCsChannelV2.iLocalAddress.iType=DSATTSY_IPV4_TYPE; + openCsChannelV2.iLocalAddress.iAddress=DSATTSY_ADDRESS; + openCsChannelV2.iUserLogin=DSATTSY_LOGIN; + openCsChannelV2.iUserPassword=DSATTSY_PASSWORD; + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case RSat::EGprsBearer: + { + RSat::TOpenGprsChannelV2Pckg* aV2GprsPCmdPckg = (RSat::TOpenGprsChannelV2Pckg*)aPCmd; + RSat::TOpenGprsChannelV2& openGprsChannelV2 = (*aV2GprsPCmdPckg)(); + + openGprsChannelV2.iAccessName=DSATTSY_ACCESS_NAME; + openGprsChannelV2.iLocalAddress.iType=DSATTSY_IPV4_TYPE; + openGprsChannelV2.iLocalAddress.iAddress=DSATTSY_ADDRESS; + + if (openGprsChannelV2.ExtensionId() == RSat::KSatV4) + { + RSat::TOpenGprsChannelV4Pckg* aV4GprsPCmdPckg = reinterpret_cast(aPCmd); + RSat::TOpenGprsChannelV4& openGprsChannelV4 = (*aV4GprsPCmdPckg)(); + + openGprsChannelV4.iUserLogin=DSATTSY_LOGIN; + openGprsChannelV4.iUserPassword=DSATTSY_PASSWORD; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case RSat::ELocalLinksBearer: + { + RSat::TOpenLocalLinksChannelV2Pckg* aV2LocalPCmdPckg = (RSat::TOpenLocalLinksChannelV2Pckg*)aPCmd; + RSat::TOpenLocalLinksChannelV2& openLocalChannelV2 = (*aV2LocalPCmdPckg)(); + + openLocalChannelV2.iDuration1.iTimeUnit=DSATTSY_TIME_UNIT; + openLocalChannelV2.iDuration1.iNumOfUnits=DSATTSY_TIME_UNIT; + openLocalChannelV2.iDuration2.iTimeUnit=DSATTSY_TIME_UNIT; + openLocalChannelV2.iDuration2.iNumOfUnits=DSATTSY_TIME_UNIT; + openLocalChannelV2.iRemoteAddress.iCoding=DSATTSY_CODING; + openLocalChannelV2.iRemoteAddress.iAddress=DSATTSY_ADDRESS; + openLocalChannelV2.iUserPassword=DSATTSY_PASSWORD; + + ReqCompleted(aTsyReqHandle,KErrNone); + break; + } + case RSat::EAnyBearer: + { + ReqCompleted(aTsyReqHandle,KErrArgument); + break; + } + default: + ReqCompleted(aTsyReqHandle,KErrArgument); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyOpenChannelPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyOpenChannelPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyOpenChannelPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::GetOpenChannelPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::GetOpenChannelPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::NotifyCloseChannelPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyCloseChannelPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyCloseChannelPCmd called")); + RSat::TCloseChannelV2Pckg* aV2PCmdPckg = (RSat::TCloseChannelV2Pckg*)aPCmd; + RSat::TCloseChannelV2& closeChannelV2 = (*aV2PCmdPckg)(); + + closeChannelV2.SetPCmdNumber(DSATTSY_CLOSE_CHANNEL_NUMBER); + + closeChannelV2.iDestination=DSATTSY_CARD_READER_1; + closeChannelV2.iAlphaId.iStatus=DSATTSY_ALPHA_ID1_STATUS; + closeChannelV2.iAlphaId.iAlphaId=DSATTSY_ALPHA_ID1; + closeChannelV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + closeChannelV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + + if ((closeChannelV2.ExtensionId() == RSat::KSatV5) || + (closeChannelV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TCloseChannelV5Pckg* aV5PCmdPckg = (RSat::TCloseChannelV5Pckg*)aPCmd; + RSat::TCloseChannelV5& closeChannelV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + closeChannelV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + closeChannelV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (closeChannelV2.ExtensionId() == RSat::KSatV6) + { + RSat::TCloseChannelV6Pckg* closeChannelV6PCmdPckg = (RSat::TCloseChannelV6Pckg*)aPCmd; + RSat::TCloseChannelV6& closeChannelV6 = (*closeChannelV6PCmdPckg)(); + + closeChannelV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyCloseChannelPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyCloseChannelPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyCloseChannelPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyReceiveDataPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyReceiveDataPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyReceiveDataPCmd called")); + RSat::TReceiveDataV2Pckg* aV2PCmdPckg = (RSat::TReceiveDataV2Pckg*)aPCmd; + RSat::TReceiveDataV2& receiveDataV2 = (*aV2PCmdPckg)(); + + receiveDataV2.SetPCmdNumber(DSATTSY_RECEIVE_DATA_NUMBER); + + receiveDataV2.iDestination=DSATTSY_CARD_READER_1; + receiveDataV2.iAlphaId.iStatus=DSATTSY_ALPHA_ID1_STATUS; + receiveDataV2.iAlphaId.iAlphaId=DSATTSY_ALPHA_ID1; + receiveDataV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + receiveDataV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + receiveDataV2.iChannelDataLength=DSATTSY_DATA_LENGTH; + + if ((receiveDataV2.ExtensionId() == RSat::KSatV5) || + (receiveDataV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TReceiveDataV5Pckg* aV5PCmdPckg = (RSat::TReceiveDataV5Pckg*)aPCmd; + RSat::TReceiveDataV5& receiveDataV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + receiveDataV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + receiveDataV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (receiveDataV2.ExtensionId() == RSat::KSatV6) + { + RSat::TReceiveDataV6Pckg* receiveDataV6PCmdPckg = (RSat::TReceiveDataV6Pckg*)aPCmd; + RSat::TReceiveDataV6& receiveDataV6 = (*receiveDataV6PCmdPckg)(); + + receiveDataV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyReceiveDataPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyReceiveDataPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyReceiveDataPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendDataPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySendDataPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendDataPCmd called")); + RSat::TSendDataV2Pckg* aV2PCmdPckg = (RSat::TSendDataV2Pckg*)aPCmd; + RSat::TSendDataV2& sendDataV2 = (*aV2PCmdPckg)(); + + sendDataV2.SetPCmdNumber(DSATTSY_SEND_DATA_NUMBER); + + sendDataV2.iDestination=DSATTSY_CARD_READER_1; + sendDataV2.iMode=DSATTSY_SEND_DATA_MODE; + sendDataV2.iAlphaId.iStatus=DSATTSY_ALPHA_ID1_STATUS; + sendDataV2.iAlphaId.iAlphaId=DSATTSY_ALPHA_ID1; + sendDataV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + sendDataV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + sendDataV2.iChannelData=DSATTSY_CHANNEL_DATA; + + if ((sendDataV2.ExtensionId() == RSat::KSatV5) || + (sendDataV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TSendDataV5Pckg* aV5PCmdPckg = (RSat::TSendDataV5Pckg*)aPCmd; + RSat::TSendDataV5& sendDataV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + sendDataV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + sendDataV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (sendDataV2.ExtensionId() == RSat::KSatV6) + { + RSat::TSendDataV6Pckg* sendDataV6PCmdPckg = (RSat::TSendDataV6Pckg*)aPCmd; + RSat::TSendDataV6& sendDataV6 = (*sendDataV6PCmdPckg)(); + + sendDataV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySendDataPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySendDataPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySendDataPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetChannelStatusPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyGetChannelStatusPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetChannelStatusPCmd called")); + RSat::TGetChannelStatusV2Pckg* aV2PCmdPckg = (RSat::TGetChannelStatusV2Pckg*)aPCmd; + RSat::TGetChannelStatusV2& getStatusV2 = (*aV2PCmdPckg)(); + + getStatusV2.SetPCmdNumber(DSATTSY_GET_CHANNEL_STATUS_NUMBER); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetChannelStatusPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetChannelStatusPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyGetChannelStatusPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyServiceSearchPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyServiceSearchPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyServiceSearchPCmd called")); + RSat::TServiceSearchV2Pckg* aV2PCmdPckg = (RSat::TServiceSearchV2Pckg*)aPCmd; + RSat::TServiceSearchV2& serviceSearchV2 = (*aV2PCmdPckg)(); + + serviceSearchV2.SetPCmdNumber(DSATTSY_SERVICE_SEARCH_NUMBER); + + serviceSearchV2.iAlphaId.iStatus=DSATTSY_ALPHA_ID1_STATUS; + serviceSearchV2.iAlphaId.iAlphaId=DSATTSY_ALPHA_ID1; + serviceSearchV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + serviceSearchV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + serviceSearchV2.iSearch.iBearerId=DSATTSY_BEARER_TECH_INDEPENDENT; + serviceSearchV2.iSearch.iSearchParam=DSATTSY_SERVICE_SEARCH_PARAMS; + serviceSearchV2.iFilter.iBearerId=DSATTSY_BEARER_TECH_INDEPENDENT; + serviceSearchV2.iFilter.iDeviceFilter=DSATTSY_FILTER_INFO; + + if ((serviceSearchV2.ExtensionId() == RSat::KSatV5) || + (serviceSearchV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TServiceSearchV5Pckg* aV5PCmdPckg = (RSat::TServiceSearchV5Pckg*)aPCmd; + RSat::TServiceSearchV5& serviceSearchV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + serviceSearchV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + serviceSearchV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (serviceSearchV2.ExtensionId() == RSat::KSatV6) + { + RSat::TServiceSearchV6Pckg* serviceSearchV6PCmdPckg = (RSat::TServiceSearchV6Pckg*)aPCmd; + RSat::TServiceSearchV6& serviceSearchV6 = (*serviceSearchV6PCmdPckg)(); + + serviceSearchV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyServiceSearchPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyServiceSearchPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyServiceSearchPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetServiceInfoPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyGetServiceInfoPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetServiceInfoPCmd called")); + RSat::TGetServiceInfoV2Pckg* aV2PCmdPckg = (RSat::TGetServiceInfoV2Pckg*)aPCmd; + RSat::TGetServiceInfoV2& getServiceInfoV2 = (*aV2PCmdPckg)(); + + getServiceInfoV2.SetPCmdNumber(DSATTSY_GET_SERVICE_INFO_NUMBER); + + getServiceInfoV2.iAlphaId.iStatus=DSATTSY_ALPHA_ID1_STATUS; + getServiceInfoV2.iAlphaId.iAlphaId=DSATTSY_ALPHA_ID1; + getServiceInfoV2.iIconId.iIdentifier=DSATTSY_ICON_ID1; + getServiceInfoV2.iIconId.iQualifier=DSATTSY_ICON_QUALIFIER1; + getServiceInfoV2.iAttributeInfo.iBearerId=DSATTSY_BEARER_TECH_INDEPENDENT; + getServiceInfoV2.iAttributeInfo.iAttributeInfo=DSATTSY_ATTRIBUTE_INFO; + + if ((getServiceInfoV2.ExtensionId() == RSat::KSatV5) || + (getServiceInfoV2.ExtensionId() == RSat::KSatV6)) + { + RSat::TGetServiceInfoV5Pckg* aV5PCmdPckg = (RSat::TGetServiceInfoV5Pckg*)aPCmd; + RSat::TGetServiceInfoV5& getServiceInfoV5 = (*aV5PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + + getServiceInfoV5.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + getServiceInfoV5.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + } + + if (getServiceInfoV2.ExtensionId() == RSat::KSatV6) + { + RSat::TGetServiceInfoV6Pckg* getServiceInfoV6PCmdPckg = (RSat::TGetServiceInfoV6Pckg*)aPCmd; + RSat::TGetServiceInfoV6& getServiceInfoV6 = (*getServiceInfoV6PCmdPckg)(); + + getServiceInfoV6.iFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetServiceInfoPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetServiceInfoPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyGetServiceInfoPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyDeclareServicePCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyDeclareServicePCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyDeclareServicePCmd called")); + RSat::TDeclareServiceV2Pckg* aV2PCmdPckg = (RSat::TDeclareServiceV2Pckg*)aPCmd; + RSat::TDeclareServiceV2& declareServiceV2 = (*aV2PCmdPckg)(); + + declareServiceV2.SetPCmdNumber(DSATTSY_DECLARE_SERVICE_NUMBER); + + declareServiceV2.iType=DSATTSY_DECLARE_SERVICE_TYPE; + declareServiceV2.iServiceRecord.iBearerId=DSATTSY_BEARER_NOT_PRESENT; + declareServiceV2.iServiceRecord.iServiceId=DSATTSY_NULL_BEARER_ID; + declareServiceV2.iServiceRecord.iRecord=DSATTSY_NULL_NARROW_BUF; + declareServiceV2.iInterface.iPrtNumber=DSATTSY_PORT_1; + declareServiceV2.iInterface.iTransportProto=DSATTSY_TCP_PROTO; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyDeclareServicePCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyDeclareServicePCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyDeclareServicePCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyProactiveSimSessionStart(const TTsyReqHandle aTsyReqHandle) + { + if(!iNotifyProactiveSimSessionStart++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyProactiveSimSessionStart called")); + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyProactiveSimSessionStartCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyProactiveSimSessionStartCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyProactiveSimSessionStart=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyProactiveSimSessionEnd(const TTsyReqHandle aTsyReqHandle) + { + if(!iNotifyProactiveSimSessionEnd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyProactiveSimSessionEnd called")); + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyProactiveSimSessionEndCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyProactiveSimSessionEndCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyProactiveSimSessionEnd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyTimerExpiration(const TTsyReqHandle aTsyReqHandle, TDes8* aTimerDetails) + { + if(!iNotifyTimerExpiration++) + { + LOGTEXT(_L8("CSatDSatTsy::Notify Timer expiration called")); + RSat::TTimerExpirationV3Pckg* cmdPckg = (RSat::TTimerExpirationV3Pckg*)aTimerDetails; + RSat::TTimerExpirationV3& cmdV3 = (*cmdPckg)(); + + cmdV3.iTimerId = RSat::KTimer1; + cmdV3.iTimerValue.iTimeUnit = RSat::ESeconds; + cmdV3.iTimerValue.iNumOfUnits = 10; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyTimerExpirationCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyTimerExpirationCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyTimerExpiration=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySmsPpDownload(const TTsyReqHandle aTsyReqHandle, TDes8* aSmsPpDownloadDetails) + { + if(!iNotifySmsPpDownload++) + { + LOGTEXT(_L8("CSatDSatTsy::Notify Sms Pp Download called")); + RSat::TSmsPpDownloadV3Pckg* cmdPckg = (RSat::TSmsPpDownloadV3Pckg*)aSmsPpDownloadDetails; + RSat::TSmsPpDownloadV3& cmdV3 = (*cmdPckg)(); + + cmdV3.iDeviceId=RSat::KEarPiece; + cmdV3.iRpAddress.iTypeOfNumber =DSATTSY_TON; + cmdV3.iRpAddress.iNumberPlan =DSATTSY_NPI; + cmdV3.iRpAddress.iTelNumber =DSATTSY_TEL_NUMBER; + cmdV3.iPdu=DSATTSY_SMS_TPDU; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyTsyStateUpdated(const TTsyReqHandle aTsyReqHandle,RSat::TPCmd* aPCmd) + { + if(!iNotifyTsyStateUpdated++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyTsyStateUpdated called")); + *aPCmd = DSATTSY_SENDSS; + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyTsyStateUpdatedCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyTsyStateUpdatedCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRefreshRequired(const TTsyReqHandle aTsyReqHandle) + { + if(!iNotifyRefreshRequired++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRefreshRequired called")); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRefreshRequired(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyRefreshRequired++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRefreshRequired called (with param)")); + + RSat::TRefreshV1Pckg* refreshPckg = (RSat::TRefreshV1Pckg*)aPCmd; + RSat::TRefreshV1& refreshV1 = (*refreshPckg)(); + + refreshV1.SetPCmdNumber(DSATTSY_REFRESH_NUMBER); + + refreshV1.iType = DSATTSY_REFRESH_TYPE; + refreshV1.iFileList.Append(DSATTSY_REFRESH_FDN_EF); + refreshV1.iFileList.Append(DSATTSY_REFRESH_ADN_EF); + + if (refreshV1.ExtensionId()==RSat::KSatV2) + { + RSat::TRefreshV2Pckg* aV2PCmdPckg = (RSat::TRefreshV2Pckg*)aPCmd; + RSat::TRefreshV2& refreshV2 = (*aV2PCmdPckg)(); + + refreshV2.iAid=DSATTSY_AID; + } + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRefreshRequiredCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRefreshRequiredCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyRefreshRequired=0; + return KErrNone; + } + +TInt CSatDSatTsy::RefreshAllowed(const TTsyReqHandle aTsyReqHandle, TDes8* aRefreshAllowedRsp) + { + RSat::TRefreshRspV1Pckg* aRspPckg = (RSat::TRefreshRspV1Pckg*)aRefreshAllowedRsp; + RSat::TRefreshRspV1& rspV1 = (*aRspPckg)(); + + if((rspV1.iGeneralResult!=DSATTSY_PCMD_RESULT_SUCCESS) + ||(rspV1.iInfoType!=DSATTSY_PCMD_RSP_NO_INFO) + ||(rspV1.iAdditionalInfo!=DSATTSY_NULL_BUF)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iRefreshAllowed++) + ReqCompleted(aTsyReqHandle,KErrNone); + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::RefreshAllowedCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::RefreshAllowedCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyRefreshRequired=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySmsPpDownloadCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySmsPpDownloadCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySmsPpDownload=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyCbDownload(const TTsyReqHandle aTsyReqHandle, TDes8* aCbDownloadDetails) + { + if(!iNotifyCbDownload++) + { + LOGTEXT(_L8("CSatDSatTsy::Notify CB Download called")); + RSat::TCbDownloadV3Pckg* cmdPckg = (RSat::TCbDownloadV3Pckg*)aCbDownloadDetails; + RSat::TCbDownloadV3& cmdV3 = (*cmdPckg)(); + + cmdV3.iDeviceId=RSat::KEarPiece; + cmdV3.iPdu= DSATTSY_CB_PDU; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyCbDownloadCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyCbDownloadCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyCbDownload=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyTimerManagtPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyTimerManagtPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyTimerManagtPCmd called")); + RSat::TTimerMgmtV3Pckg* aV3PCmdPckg = (RSat::TTimerMgmtV3Pckg*)aPCmd; + RSat::TTimerMgmtV3& timerMngtV3 = (*aV3PCmdPckg)(); + + timerMngtV3.iTimerId = RSat::KTimer1; + timerMngtV3.iTimerValue.iTimeUnit = RSat::ESeconds; + timerMngtV3.iTimerValue.iNumOfUnits = 10; + timerMngtV3.iOperation = RSat::EStartTimer; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyTimerManagtPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyTmerManagtPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyTimerManagtPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyLocalInfoPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyLocalInfoPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyLocalInfoPCmd called")); + RSat::TLocalInfoV3Pckg* aV3PCmdPckg = (RSat::TLocalInfoV3Pckg*)aPCmd; + RSat::TLocalInfoV3& localInfoV3 = (*aV3PCmdPckg)(); + + localInfoV3.iDevideId = RSat::KKeypad; + localInfoV3.iInfoType = RSat::KProvideLocalInfo; + if(localInfoV3.ExtensionId()== RSat::KSatV6) + { + RSat::TLocalInfoV6Pckg* localInfoV6PCmdPckg = (RSat::TLocalInfoV6Pckg*)aPCmd; + RSat::TLocalInfoV6& localInfoV6 = (*localInfoV6PCmdPckg)(); + localInfoV6.iUtranMeasurementQualifier=DSATTSYV6_LOCAL_INFOV6; + localInfoV6.iInfoType = RSat::KProvideLocalInfoSearchMode; + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyLocalInfoPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyLocalInfoPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyLocalInfoPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPollingIntervalPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyPollingIntervalPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPollingIntervalPCmd called")); + RSat::TPollingIntervalV3Pckg* aV3PCmdPckg = (RSat::TPollingIntervalV3Pckg*)aPCmd; + RSat::TPollingIntervalV3& pollingIntvV3 = (*aV3PCmdPckg)(); + + pollingIntvV3.iIntv.iTimeUnit = RSat::ESeconds; + pollingIntvV3.iIntv.iNumOfUnits = DSATTSY_NUM_OF_UNITS; + pollingIntvV3.iDestination=RSat::KEarPiece; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + + +TInt CSatDSatTsy::NotifyPollingIntervalPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + + LOGTEXT(_L8("CSatDSatTsy::NotifyPollingIntervalPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyPollingIntervalPCmd=0; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPollingOffPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyPollingOffPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyPollingOffPCmd called")); + RSat::TPollingOffV3Pckg* aV3PCmdPckg = (RSat::TPollingOffV3Pckg*)aPCmd; + RSat::TPollingOffV3& pollingIntvV3 = (*aV3PCmdPckg)(); + + pollingIntvV3.iIntv.iTimeUnit = RSat::ESeconds; + pollingIntvV3.iIntv.iNumOfUnits = 20; + pollingIntvV3.iDestination=RSat::KNetwork; + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyPollingOffPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + + LOGTEXT(_L8("CSatDSatTsy::NotifyPollingOffPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyPollingOffPCmd=0; + return KErrNone; + } + + + +TInt CSatDSatTsy::NotifyRetrieveMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyRetrieveMultimediaMsgPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRetrieveMultimediaMsgPCmd called")); + RSat::TRetrieveMultimediaMessageV6Pckg* retrieveMmV6PCmdPckg = (RSat::TRetrieveMultimediaMessageV6Pckg*)aPCmd; + RSat::TRetrieveMultimediaMessageV6& retrieveMMV6 = (*retrieveMmV6PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + retrieveMMV6.SetPCmdNumber(DSATTSY_RETRIEVE_MULTIMEDIA_MESSAGE); + retrieveMMV6.iDestination = DSATTSYV6_DEVICE_ID1; + retrieveMMV6.iAlphaId.iAlphaId= DSATTSYV6_ALPHAID1; + retrieveMMV6.iAlphaId.iStatus = DSATTSYV6_ALPHAID_STATUS2; + retrieveMMV6.iIconId.iIdentifier = DSATTSYV6_ICON_ID1; + retrieveMMV6.iIconId.iQualifier = DSATTSYV6_ICON_QUALIFIER3; + retrieveMMV6.iMultimediaContentId = DSATTSYV6_MULTIMEDIA_CONTENT_ID1; + retrieveMMV6.iMultimediaMessageRef = DSATTSYV6_MULTIMEDIA_MESSAGE_REF1; + retrieveMMV6.iMultimediaMessageId = DSATTSYV6_MULTIMEDIA_MESSAGE_ID1; + retrieveMMV6.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + retrieveMMV6.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyRetrieveMultimediaMsgPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyRetrieveMultimediaMsgPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyRetrieveMultimediaMsgPCmd=0; + return KErrNone; + } + + + +TInt CSatDSatTsy::NotifySubmitMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySubmitMultimediaMsgPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySubmitMultimediaMsgPCmd called")); + RSat::TSubmitMultimediaMessageV6Pckg* submitMMV6PCmdPckg = (RSat::TSubmitMultimediaMessageV6Pckg*)aPCmd; + RSat::TSubmitMultimediaMessageV6& submitMMV6 = (*submitMMV6PCmdPckg)(); + + const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA; + submitMMV6.SetPCmdNumber(DSATTSY_SUBMIT_MULTIMEDIA_MESSAGE); + submitMMV6.iDestination = DSATTSYV6_DEVICE_ID1; + submitMMV6.iAlphaId.iAlphaId= DSATTSYV6_ALPHAID1; + submitMMV6.iAlphaId.iStatus = DSATTSYV6_ALPHAID_STATUS2; + submitMMV6.iIconId.iIdentifier = DSATTSYV6_ICON_ID1; + submitMMV6.iIconId.iQualifier = DSATTSYV6_ICON_QUALIFIER3; + submitMMV6.iSubmissionFile = DSATTSYV6_SUBMISSION_FILE1; + submitMMV6.iTextAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS; + submitMMV6.iMultimediaMessageId = DSATTSYV6_MULTIMEDIA_MESSAGE_ID1; + submitMMV6.iTextAttribute.iTextAttributeData.Append(textAttributeData,DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySubmitMultimediaMsgPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySubmitMultimediaMsgPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySubmitMultimediaMsgPCmd=0; + return KErrNone; + } + + + +TInt CSatDSatTsy::NotifyDisplayMultimediaMsgPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyDisplayMultimediaMsgPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyDisplayMultimediaMsgPCmd called")); + RSat::TDisplayMultimediaMessageV6Pckg* displayMMV6PCmdPckg = (RSat::TDisplayMultimediaMessageV6Pckg*)aPCmd; + RSat::TDisplayMultimediaMessageV6& displayMMV6 = (*displayMMV6PCmdPckg)(); + + displayMMV6.SetPCmdNumber(DSATTSY_DISPLAY_MULTIMEDIA_MESSAGE); + displayMMV6.iDestination = DSATTSYV6_DEVICE_ID3; + displayMMV6.iDisplayPriority = DSATTSYV6_DISPLAY_PRIORITY1; + displayMMV6.iSubmissionFile = DSATTSYV6_SUBMISSION_FILE1; + displayMMV6.iMultimediaMessageId = DSATTSYV6_MULTIMEDIA_MESSAGE_ID1; + displayMMV6.iImmediateRsp = DSATTSYV6_IMMEDIATE_RESPONSE1; + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyDisplayMultimediaMsgPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyDisplayMultimediaMsgPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyDisplayMultimediaMsgPCmd=0; + return KErrNone; + } + + +TInt CSatDSatTsy::NotifySetFramesPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifySetFramesPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifySetFramesPCmd called")); + RSat::TSetFramesV6Pckg* setFramesV6PCmdPckg = (RSat::TSetFramesV6Pckg*)aPCmd; + RSat::TSetFramesV6& setFramesV6 = (*setFramesV6PCmdPckg)(); + + setFramesV6.SetPCmdNumber(DSATTSY_SET_FRAMES); + setFramesV6.iDestination = DSATTSYV6_DEVICE_ID1; + setFramesV6.iDefaultFrameId = DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1; + setFramesV6.iFrameId = DSATTSYV6_FRAME_IDENTIFIER1; + setFramesV6.iFrameLayout.iFramesLayout = DSATTSYV6_FRAME_LAYOUT_FORMAT1; + setFramesV6.iFrameLayout.iFrameLayoutBuf = DSATTSYV6_FRAME_LAYOUT1; + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifySetFramesPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::SetFramesPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifySetFramesPCmd=0; + return KErrNone; + } + + +TInt CSatDSatTsy::NotifyGetFramesStatusPCmd(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + if(!iNotifyGetFramesStatusPCmd++) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetFramesStatusPCmd called")); + RSat::TGetFramesStatusV6Pckg* getFramesStatusV6PCmdPckg = (RSat::TGetFramesStatusV6Pckg*)aPCmd; + RSat::TGetFramesStatusV6& getFramesStatusV6 = (*getFramesStatusV6PCmdPckg)(); + + getFramesStatusV6.SetPCmdNumber(DSATTSY_GET_FRAMES_STATUS); + getFramesStatusV6.iDestination = DSATTSYV6_DEVICE_ID1; + ReqCompleted(aTsyReqHandle,KErrNone); + } + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::NotifyGetFramesStatusPCmdCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::NotifyGetFramesStatusPCmdCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iNotifyGetFramesStatusPCmd=0; + return KErrNone; + } + + + +TInt CSatDSatTsy::MmsNotificationDownload(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + LOGTEXT(_L8("CSatDSatTsy::MmsNotificationDownload called")); + RSat::TMmsNotificationDownloadV6Pckg* mMSNotificationDownloadV6PCmdPckg = (RSat::TMmsNotificationDownloadV6Pckg*)aPCmd; + RSat::TMmsNotificationDownloadV6& mMSNotificationDownloadV6 = (*mMSNotificationDownloadV6PCmdPckg)(); + + if((mMSNotificationDownloadV6.iDeviceId != DSATTSYV6_DEVICE_ID1) || + (mMSNotificationDownloadV6.iLastEnvelope != DSATTSYV6_LAST_ENVELOPE1) || + (mMSNotificationDownloadV6.iMMSNotification != DSATTSYV6_MMS_NOTIFICATION1)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iMmsNotificationDownload++) + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::MmsNotificationDownloadCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::MmsNotificationDownloadCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iMmsNotificationDownload=0; + return KErrNone; + } + + + +TInt CSatDSatTsy::MmsTransferStatus(const TTsyReqHandle aTsyReqHandle, TDes8* aPCmd) + { + LOGTEXT(_L8("CSatDSatTsy::MmsTransferStatus called")); + RSat::TMmsTransferStatusV6Pckg* mMSTransferStatusV6PCmdPckg = (RSat::TMmsTransferStatusV6Pckg*)aPCmd; + RSat::TMmsTransferStatusV6& mMSTransferStatusV6 = (*mMSTransferStatusV6PCmdPckg)(); + + if((mMSTransferStatusV6.iDeviceId != DSATTSYV6_DEVICE_ID3) || + (mMSTransferStatusV6.iMultimediaMessageId !=DSATTSYV6_MULTIMEDIA_MESSAGE_ID1) || + (mMSTransferStatusV6.iMultimediaMessageStatus !=DSATTSYV6_MULTIMEDIA_MESSAGE_STATUS)) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + else if(!iMmsTransferStatus++) + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::MmsTransferStatusCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::MMTransferStatusCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iMmsTransferStatus=0; + return KErrNone; + } + + + +TInt CSatDSatTsy::UssdDataDownload(const TTsyReqHandle aTsyReqHandle, TDes8* aUssdDataDownload) + { + LOGTEXT(_L8("CSatDSatTsy::UssdDataDownload called")); + RSat::TUssdDataDownloadV6Pckg* ussdDataDownloadPckg = (RSat::TUssdDataDownloadV6Pckg*)aUssdDataDownload; + RSat::TUssdDataDownloadV6& ussdDataDownloadV6 = (*ussdDataDownloadPckg)(); + + if((ussdDataDownloadV6.iDeviceId != DSATTSYV6_DEVICE_ID1) || + (ussdDataDownloadV6.iUssdString.iUssdString != DSATTSY_USSD_STRING)) + { + ReqCompleted(aTsyReqHandle, KErrCorrupt); + } + else if(!iUssdDataDownload++) + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + + iTsyAsyncReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSatDSatTsy::UssdDataDownloadCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGTEXT(_L8("CSatDSatTsy::UssdDataDownloadCancel called")); + if(aTsyReqHandle == iTsyAsyncReqHandle) + ReqCompleted(aTsyReqHandle,KErrCancel); + else + ReqCompleted(aTsyReqHandle,KErrCorrupt); + iUssdDataDownload=0; + return KErrNone; + } + + + +TSecurityPolicy CSatDSatTsy::GetRequiredPlatSecCaps(const TInt aIpc) + { + switch(aIpc) + { + case ETestCustomIPC1: + return TSecurityPolicy(ECapabilityNetworkServices); + default: + //For any non-Custom IPCs return a policy that will always cause the capability check to pass + return TSecurityPolicy(TSecurityPolicy::EAlwaysPass); + } + } +