diff -r 000000000000 -r 63b37f68c1ce adaptationlayer/tsy/simatktsy_dll/src/satnotifications.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/adaptationlayer/tsy/simatktsy_dll/src/satnotifications.cpp Fri Nov 06 17:28:23 2009 +0000 @@ -0,0 +1,9243 @@ +/* +* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "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: +* +*/ + + + + +// INCLUDE FILES +#include "satnotifications.h" // sat notifications class +#include "satmessaging.h" // sat messaging class +#include "satmesshandler.h" // sat message handler class +#include "sattimer.h" // sat timer class +#include "ber_tlv.h" // sat ber-tlv classes +#include "satutil.h" // sat utility class + +#include // isi message +#include // net server +#include // gss server +#include // atk server +#include // uicc server +#include +#include "osttracedefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "satnotificationstraces.h" +#endif + + + +// CONSTANTS + +// Character code +const TUint8 KPlusMarkCharacterCode = 0x2B; + +// Send SM +const TUint8 KTPDUMandatoryFieldsSmsSubmitUdl = 0x06; +const TUint8 KTPDUMandatoryFieldsSmsCommandUdl = 0x07; +const TUint8 KTPDUMandatoryFieldsSmsSubmitDcs = 0x05; +const TUint8 KSmsVPFEnhanced = 0x01; +const TUint8 KSmsVPFRelative = 0x02; +const TUint8 KSmsVPFAbsolute = 0x03; +const TUint8 KSmsVpFormatMask = 0x03; +const TUint8 KSATSmsMTISubmitOrSubmitReport = 0x01; +const TUint8 KSmsDcsDefaultAlphabet = 0x00; +const TUint8 KMinSmsTpduLength = 0x07; + +// Masks +const TUint8 KMask0 = 0x00; +const TUint8 KMask3 = 0x03; +const TUint8 KMaskC0 = 0xC0; +const TUint8 KMaskF0 = 0xF0; +const TUint8 KMaskF3 = 0xF3; +const TUint8 KMaskFB = 0xFB; + +// Additional info +const TUint8 KNoCause = 0x00; + +// SetUpCall +const TUint8 KOnlyIfNotBusy = 0x00; +const TUint8 KOnlyIfNotBusyWithRedial = 0x01; +const TUint8 KHoldOtherCalls = 0x02; +const TUint8 KHoldOtherCallsWithRedial = 0x03; +const TUint8 KDisconnectOtherCalls = 0x04; +const TUint8 KDisconnectOtherCallsWithRedial = 0x05; + +// SetUpEventList +const TUint8 KMTCall = 0x00; +const TUint8 KCallConnected = 0x01; +const TUint8 KCallDisconnected = 0x02; +const TUint8 KLocationStatus = 0x03; +const TUint8 KUserActivity = 0x04; +const TUint8 KIdleScreenAvailable = 0x05; +const TUint8 KCardReaderStatus = 0x06; +const TUint8 KLanguageSelection = 0x07; +const TUint8 KBrowserTermination = 0x08; +const TUint8 KDataAvailable = 0x09; +const TUint8 KChannelStatus = 0x0A; +const TUint8 KAccessTechnologyChange = 0x0B; +const TUint8 KDisplayParamsChanges = 0x0C; +const TUint8 KLocalConnection = 0x0D; + + +// Timer management +const TUint8 KMinTimerValue = 0; +const TUint KMaxTimerValueInSeconds = 86400; + +// Launch browser +const TUint8 KLaunchBrowserCmdQualifierNotUsed = 0x01; +const TUint8 KLaunchBrowserCmdQualifierReserved = 0x04; +const TUint8 KCsdBearer = 0x01; +const TUint8 KGprsBearer = 0x03; +const TUint8 KDefaultBrowser = 0x00; +#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 ) +const TUint8 KWMLBrowser = 0x01; +const TUint8 KHTMLBrowser = 0x02; +const TUint8 KXHTMLBrowser = 0x03; +const TUint8 KCHTMLBrowser = 0x04; +#endif + +// Bearer independent protocol +const TUint8 KBipCsdBearer = 0x01; +const TUint8 KBipGprsBearer = 0x02; +const TUint8 KBipDefaultBearer = 0x03; +const TUint8 KBipLocalLinkTechnologyIndependentBearer = 0x04; +const TUint8 KBipBluetoothBearer = 0x05; +const TUint8 KBipIrDABearer = 0x06; +const TUint8 KBipRS232Bearer = 0x07; +const TUint8 KBipUSBBearer = 0x10; +const TUint8 KBipSendDataImmediately = 0x01; + +// Language notification +const TUint8 KSpecificLanguage = 0x01; + +// Elementary files +const TUint8 KRefresh1StLevelDedicatedFileHeader = 0x7F; +const TUint8 KRefresh2StLevelDedicatedFileHeader = 0x5F; + +// SIM/ME Interface transport protocol type coding +const TUint8 KProtocolUdp = 0x01; +const TUint8 KProtocolTcp = 0x02; + +// Link Establishment +const TUint8 KLinkEstablishmentMask = 0x01; + +// Reconnection mode +const TUint8 KReconnectionModeMask = 0x02; + + +// LOCAL FUNCTION PROTOTYPES + +// Declaration needed here for ARMV5 because method is used in Notifications +// base, but method implementation is bit later. +CSatNotificationsBase::TAllowedResults operator+( + const RSat::TPCmdResult aResultA, const RSat::TPCmdResult aResultB ); + +// ==================== MEMBER FUNCTIONS ==================================== + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::CSatNotificationsBase +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::CSatNotificationsBase + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + iSatMessHandler( aSatMessHandler ), + iSatMessaging( aSatMessaging ), + iTransId( KZero ), + iReqHandle( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::CSatNotificationsBase" ); + iCommandDetails.Zero(); + + // Following results are accepted by all commands + iAllowedResults = RSat::KSuccess + RSat::KPartialComprehension + + RSat::KMissingInformation + RSat::KMeUnableToProcessCmd + + RSat::KCmdBeyondMeCapabilities + RSat::KCmdTypeNotUnderstood + + RSat::KCmdDataNotUnderstood + RSat::KCmdNumberNotKnown; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::~CSatNotificationsBase +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::~CSatNotificationsBase() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::~CSatNotificationsBase" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::CancelNotification +// Cancels the current notification request +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotificationsBase::CancelNotification + ( + const TTsyReqHandle aReqHandle // Request handle + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CANCELNOTIFICATION, "CSatNotificationsBase::CancelNotification" ); + TFLOGSTRING("TSY: CSatNotificationsBase::CancelNotification"); + + // Check that the handle is valid + if ( aReqHandle == iReqHandle ) + { + iSatMessaging->ReqCompleted( aReqHandle, KErrCancel ); + } + else + { + // Handle is not valid + iSatMessaging->ReqCompleted( aReqHandle, KErrCorrupt ); + } + + iReqHandle = NULL; + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::TerminalResponse +// Handles the terminal response of a proactive command +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotificationsBase::TerminalResponse + ( + TDes8* /* aRsp */ // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TERMINALRESPONSE, "CSatNotificationsBase::TerminalResponse" ); + // Base class does not do anything + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::GetCmdDetails +// Returns a reference to member iCommandDetails +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TDes8& CSatNotificationsBase::GetCmdDetails() + { + OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETCMDDETAILS, "CSatNotificationsBase::GetCmdDetails" ); + return iCommandDetails; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::GetTransactionId +// Returns the transaction identifier of the current PCmd. +// This is a Nokia specific value found in ISI messages. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TUint8 CSatNotificationsBase::GetTransactionId() + { + OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETTRANSACTIONID, "CSatNotificationsBase::GetTransactionId" ); + return iTransId; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::TsyReqHandle +// Returns the TsyReqHandle of a request +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TTsyReqHandle CSatNotificationsBase::TsyReqHandle() + { + OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TSYREQHANDLE, "CSatNotificationsBase::TsyReqHandle" ); + return iReqHandle; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::CompleteRequest +// Completes the Request notification +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotificationsBase::CompleteRequest + ( + const TInt aError // Possible error + ) + { + OstTraceExt2( TRACE_NORMAL, CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest, Handle: %d, Error: %d", (TInt)iReqHandle, aError ); + TFLOGSTRING3("CSatNotificationsBase::CompleteRequest. \n\t\t\t Handle:%d\n\t\t\t Error:%d", + iReqHandle, + aError); + TTsyReqHandle tempReqHandle = iReqHandle; + iReqHandle = NULL; + iSatMessaging->ReqCompleted( tempReqHandle, aError ); + TFLOGSTRING("CSatNotificationsBase::CompleteRequest. Request is now completed"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest. Request is now completed" ); + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::TAllowedResults::TAllowedResults +// C++ default constructor of the nested class. +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::TAllowedResults::TAllowedResults() : iResultField( 0 ) + { + } + +// ----------------------------------------------------------------------------- +// TBool CSatNotificationsBase::TAllowedResults::operator== +// The equality operator (==) for TAllowedResults +// ----------------------------------------------------------------------------- +// +TBool CSatNotificationsBase::TAllowedResults::operator== + ( + const RSat::TPCmdResult aResult + ) const + { + // Create mask from result for comparation + TAllowedResults mask; + mask = aResult; + + // Compare with bit-wise AND operation + TBool match( iResultField & mask.iResultField ); + + // Unfortunately AND operator does not seem to work if the mask contains a + // value in the high order 32 bits of a 64 bit number. This case has to be + // checked with following macro. + if ( I64HIGH( mask.iResultField ) ) + { + // Mask value is in the high order of the number so compare these. + match = I64HIGH( iResultField ) & I64HIGH( mask.iResultField ); + } + + // Open System Trace doesn't support tracing in nested classes + TFLOGSTRING3( "TAllowedResults::operator==: Bit Field: %08x %08x", + I64HIGH( iResultField ), I64LOW( iResultField ) ); + TFLOGSTRING2( "TAllowedResults::operator==: Match: %d", + ( match ? 1 : 0 ) ); + + return match; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::TAllowedResults::operator!= +// The not-equal operator (!=) for TAllowedResults. +// ----------------------------------------------------------------------------- +// +TBool CSatNotificationsBase::TAllowedResults::operator!= + ( + const RSat::TPCmdResult aResult + ) const + { + // Return the value of equals-operation (==) as inverted. + return !( *this == aResult ); + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::TAllowedResults::operator= +// The assignment operator (=) for TAllowedResults +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::TAllowedResults& + CSatNotificationsBase::TAllowedResults::operator= + ( + const RSat::TPCmdResult aResult + ) + { + // Convert result to bit field and assing internal field to it. + iResultField = CreateBitField( aResult ); + + // Return reference to this + return *this; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::operator+= +// The increment operator (+=) for TAllowedResults. +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::TAllowedResults& + CSatNotificationsBase::TAllowedResults::operator+= + ( + const RSat::TPCmdResult aResult + ) + { + // Append result to bit field by calling approriate plus operator + // and return reference to this + return *this = *this + aResult; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::operator+= +// The increment operator (+=) for TAllowedResults. +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::TAllowedResults& + CSatNotificationsBase::TAllowedResults::operator+= + ( + const CSatNotificationsBase::TAllowedResults aResults + ) + { + // Append result fields together + iResultField = iResultField | aResults.iResultField; + + // Return reference to this + return *this; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::TAllowedResults::operator+ +// The increment operator (+) for TAllowedResults. +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::TAllowedResults& + CSatNotificationsBase::TAllowedResults::operator+ + ( + const RSat::TPCmdResult aResult + ) + { + // Convert to bit field and append to result field. + iResultField = iResultField | CreateBitField( aResult ); + + // Return reference to this + return *this; + } + +// ----------------------------------------------------------------------------- +// operator+ +// Friend increment operator (+) for adding two TPCmdResults together as +// bitfield. +// ----------------------------------------------------------------------------- +// +CSatNotificationsBase::TAllowedResults operator+ + ( + const RSat::TPCmdResult aResultA, + const RSat::TPCmdResult aResultB + ) + { + // Create temporary bit field and append values into it. + // Because internal TAllowedResults is used, this method is declared as a + // friend + CSatNotificationsBase::TAllowedResults temp; + + temp = aResultA; + temp += aResultB; + + return temp; + } + +// ----------------------------------------------------------------------------- +// CSatNotificationsBase::CreateBitField +// Converts result code into bitfield representation. +// ----------------------------------------------------------------------------- +// +inline TUint64 + CSatNotificationsBase::TAllowedResults::CreateBitField + ( + const RSat::TPCmdResult aResult + ) const + { + // Create a bitfield from a result by shifting '1' to the left. + // Number of shifts depend on the result number: + // ...0000 0001 = KSuccess (0x00) + // ...0000 0010 = KPartialComprehension(0x01) + // ...0001 0000 = KSuccessRequestedIconNotDisplayed(0x04) + // and so forth. + + return static_cast( 1 ) << ( aResult ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyDisplayText::CSatNotifyDisplayText +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyDisplayText::CSatNotifyDisplayText + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iDisplayTextV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::CSatNotifyDisplayText" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser + + RSat::KNoResponseFromUser + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyDisplayText::~CSatNotifyDisplayText +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyDisplayText::~CSatNotifyDisplayText() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::~CSatNotifyDisplayText" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyDisplayText::MessageReceived +// Handles a DisplayText proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyDisplayText::MessageReceived( const TIsiReceiveC& aIsiMessage ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED, "CSatNotifyDisplayText::MessageReceived" ); + TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived"); + // Completion return value + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iCommandDetails.Copy( commandDetails.Data() ); + // Get command qualifier + TUint8 cmdQualifier( + commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + // Save ISA/CellMo transaction id + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + // Test if pending request + if ( !iReqHandle ) + { + TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived - Request Off"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED, "CSatNotifyDisplayText::MessageReceived - Request Off" ); + + // Request not on, returning response immediately + iSatMessHandler->DisplayTextTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KMeUnableToProcessCmd, // Result + RSat::KNoAdditionalInfo ); // Additional info + } + else + { + // Pending request, adapts the PCmd ISI message. + // Let's fill the display text structure + RSat::TDisplayTextV2& displayTextV2 = ( *iDisplayTextV2Pckg )(); + // Store command number + displayTextV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Priority scheme + if ( KPriorityMask & cmdQualifier ) + { + // Display priority high + displayTextV2.iPriority = RSat::EHighPriority; + } + else + { + // Display priority normal + displayTextV2.iPriority = RSat::ENormalPriority; + } + // Clearing scheme + if ( KMessageClearMask & cmdQualifier) + { + // Wait for user to clear the message + displayTextV2.iClearScreenTrigger = RSat::EUserClear; + } + else + { + // Clear message after a delay + displayTextV2.iClearScreenTrigger = RSat::EClearAfterDelay; + } + // Immediate response TLV + CTlv immediateResponse; + TInt returnValue( berTlv.TlvByTagValue( + &immediateResponse, + KTlvImmediateResponseTag ) ); + if ( KErrNotFound != returnValue ) + { + // Respond immediately + displayTextV2.iImmediateRsp = RSat::EImmediateRsp; + } + else + { + // Do not respond immediately + displayTextV2.iImmediateRsp = RSat::ENoImmediateRsp; + } + // Text to display TLV + displayTextV2.iText.Zero(); + CTlv textString; + returnValue = berTlv.TlvByTagValue( &textString, + KTlvTextStringTag ); + if ( KErrNone == returnValue ) + { + // Check if Icon Id found + // Iconid (optional) + TSatUtility::FillIconStructure( + berTlv, displayTextV2.iIconId ); + + // Text string tag is found, now + // check if the text string is null. + if ( textString.GetLength() ) + { + // Convert and set text + TSatUtility::SetText( textString, displayTextV2.iText ); + } + else if ( RSat::ENoIconId != displayTextV2.iIconId.iQualifier ) + { + // Text string is a null data object and there is icon qualifier + // presented + // Return terminal response immediately. + iSatMessHandler->DisplayTextTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details TLV + RSat::KCmdDataNotUnderstood, // Result + KNoCause ); // Additional info + ret = KErrCorrupt; + } + } + else + { + iSatMessHandler->DisplayTextTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details TLV + RSat::KErrorRequiredValuesMissing, // Result + KNoCause ); // Additional info + ret = KErrCorrupt; + } + // Duration,( optional ) see 3GPP TS 31.111 + TSatUtility::FillDurationStructure( + berTlv, displayTextV2.iDuration ); + + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyDisplayTextNotify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a DisplayText PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyDisplayText::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_NOTIFY, "CSatNotifyDisplayText::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifyDisplayText::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iDisplayTextV2Pckg = static_cast< RSat::TDisplayTextV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KDisplayText ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyDisplayText::TerminalResponse +// Handles a DisplayText terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyDisplayText::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_TERMINALRESPONSE, "CSatNotifyDisplayText::TerminalResponse" ); + TFLOGSTRING("CSatNotifyDisplayText::TerminalResponse"); + // Completion return value + TInt ret( KErrNone ); + // Additional info + TUint8 additionalInfo( 0 ); + // Cast the input parameter to EtelSat data structure + RSat::TDisplayTextRspV1Pckg* aRspPckg = + reinterpret_cast( aRsp ); + RSat::TDisplayTextRspV1& rspV1 = ( *aRspPckg ) (); + // Check that general result value is valid + + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + + // If there is Me (Mobile Equipment) error, additional info is needed + if ( ( RSat::KMeProblem == rspV1.iInfoType ) ) + { + // Check the length of additional info + if ( rspV1.iAdditionalInfo.Length() != 0 ) + { + additionalInfo = static_cast( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + // Prepare and send the terminal response to ISA/CellMo sw. + iSatMessHandler->DisplayTextTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + static_cast< TUint8 >( rspV1.iGeneralResult ), // Result + additionalInfo ); // Additional info + // return completion value. + return ret; + + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInkey::CSatNotifyGetInkey +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyGetInkey::CSatNotifyGetInkey + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iGetInkeyV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY, "CSatNotifyGetInkey::CSatNotifyGetInkey" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser + + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInkey::~CSatNotifyGetInkey +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyGetInkey::~CSatNotifyGetInkey() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY, "CSatNotifyGetInkey::~CSatNotifyGetInkey" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInkey::MessageReceived +// Handles a GetInkey proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyGetInkey::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_MESSAGERECEIVED, "CSatNotifyGetInkey::MessageReceived" ); + TFLOGSTRING( "TSY: CSatNotifyGetInkey::MessageReceived" ); + + // Completion return value + TInt ret( KErrNone ); + + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + + // Get command details + CTlv cmdDetails; + berTlv.TlvByTagValue( &cmdDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( cmdDetails.Data() ); + + // Save ISA/CellMo transaction id + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + + // Get command qualifier + TUint8 cmdQualifier( cmdDetails.GetShortInfo( ETLV_CommandQualifier ) ); + + // Test if pending request + if ( !iReqHandle ) + { + RSat::TGetInkeyRspV2 error; + error.iGeneralResult = RSat::KMeUnableToProcessCmd; + error.iInfoType = RSat::KNoAdditionalInfo; + + iSatMessHandler->GetInkeyTerminalResp( + iTransId, // Transaction Id + iCommandDetails, // Command details + error // Error result + ); + } + else + { + // Fill the get inkey structure + RSat::TGetInkeyV2& getInkeyV2 = ( *iGetInkeyV2Pckg )(); + + // Store command number + getInkeyV2.SetPCmdNumber( + cmdDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Transfer command qualifier parameter to ETelSat data structure + if ( KYesNoMask & cmdQualifier ) + { + // The character set bits are disabled and yes/no response + // is requested + getInkeyV2.iRspFormat = RSat::EYesNo; + } + else + { + // The character set bits are enabled + if ( KAlphabetMask & cmdQualifier ) + { + // Character set selected + if ( KUCS2AlphabetMask & cmdQualifier ) + { + // UCS2 alphabet selected + getInkeyV2.iRspFormat = RSat::ECharUcs2Alphabet; + } + else + { + // SMS default alphabet selected + getInkeyV2.iRspFormat = RSat::ECharSmsDefaultAlphabet; + } + } + else + { + // Digits only selected + getInkeyV2.iRspFormat = RSat::EDigitOnly; + } + + } + // Help information. + if ( KHelpAvailabilityMask & cmdQualifier ) + { + // Help information available + getInkeyV2.iHelp = RSat::EHelpAvailable; + } + else + { + // No help + getInkeyV2.iHelp = RSat::ENoHelpAvailable; + } + // Response Mode + getInkeyV2.iMode = RSat::EGetInkeyRspModeNotSet; + if ( KImmediateDigitResponse & cmdQualifier ) + { + // an immediate digit response (0-9, * and #) is requested. + getInkeyV2.iMode = RSat::EImmediateDigitRsp; + } + else + { + getInkeyV2.iMode = RSat::EUserRspDisplayed; + } + // Get Inkey text + CTlv textString; + if ( KErrNone == berTlv.TlvByTagValue( + &textString, KTlvTextStringTag ) ) + { + // Convert and set text + TSatUtility::SetText( textString, getInkeyV2.iText ); + } + else + { + RSat::TGetInkeyRspV2 error; + error.iGeneralResult = RSat::KErrorRequiredValuesMissing; + error.iInfoType = RSat::KNoAdditionalInfo; + + iSatMessHandler->GetInkeyTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details TLV + error ); // Error Result + ret = KErrCorrupt; + } + // IconId Optional + TSatUtility::FillIconStructure( berTlv, + getInkeyV2.iIconId ); + // Duration + TSatUtility::FillDurationStructure( berTlv, + getInkeyV2.iDuration ); + // Complete request to Etel + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInkey::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a GetInkey PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyGetInkey::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYGETINKEY_NOTIFY, "CSatNotifyGetInkey::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2( "TSY: CSatNotifyGetInkey::Notify. Handle: %d", aReqHandle ); + + iReqHandle = aReqHandle; + iGetInkeyV2Pckg = static_cast< RSat::TGetInkeyV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KGetInkey ); + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInkey::TerminalResponse +// Handles a GetInkey terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyGetInkey::TerminalResponse + ( + TDes8* aRsp // Response packet from ETel + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_TERMINALRESPONSE, "CSatNotifyGetInkey::TerminalResponse" ); + TFLOGSTRING("TSY: CSatNotifyGetInkey::TerminalResponse" ); + + TInt ret( KErrNone ); + + RSat::TGetInkeyRspV2Pckg& aRspPckg = + reinterpret_cast( *aRsp ); + RSat::TGetInkeyRspV2& rspV2 = aRspPckg(); + + // Checking that infotype is valid + switch ( rspV2.iInfoType ) + { + case RSat::KMeProblem: + case RSat::KTextString: + { + if ( !rspV2.iAdditionalInfo.Length() ) + { + // These info types require additional info + ret = KErrCorrupt; + } + break; + } + case RSat::KNoAdditionalInfo: + { + if ( rspV2.iAdditionalInfo.Length() ) + { + // For this type, AI shouldn't be present + ret = KErrCorrupt; + } + break; + } + default: + { + // Unexpected value + ret = KErrCorrupt; + break; + } + } + + // Checking that the response type is valid + switch ( rspV2.iRspFormat ) + { + case RSat::EDigitOnly: + case RSat::ECharSmsDefaultAlphabet: + case RSat::ECharUcs2Alphabet: + case RSat::EYesNo: + { + // Ok + break; + } + default: + { + // Unexpected value + ret = KErrCorrupt; + break; + } + } + + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Unexpected value + ret = KErrCorrupt; + } + + if ( ( RSat::ETimeUnitNotSet == rspV2.iDuration.iTimeUnit ) ) + { + // Time should have been initialized + ret = KErrCorrupt; + } + + iSatMessHandler->GetInkeyTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details + rspV2 ); // Response data + + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInput::CSatNotifyGetInput +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyGetInput::CSatNotifyGetInput + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iGetInputV1Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT, "CSatNotifyGetInput::CSatNotifyGetInput" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser + + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInput::~CSatNotifyGetInput +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyGetInput::~CSatNotifyGetInput() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT, "CSatNotifyGetInput::~CSatNotifyGetInput" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInput::MessageReceived +// Handles a GetInput proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyGetInput::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_MESSAGERECEIVED, "CSatNotifyGetInput::MessageReceived" ); + TFLOGSTRING("CSatNotifyGetInput::MessageReceived"); + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + TBuf<1> emptyString; + // Request not on, returning response immediately + iSatMessHandler->GetInputTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KMeUnableToProcessCmd, // Result + KNoCause, // Additional info, KNoCause: 0 + emptyString, // No string + RSat::ESmsDefaultAlphabetUnpacked );// data coding scheme + + } + else + { + // Fill the get input structure + RSat::TGetInputV1& getInputV1 = ( *iGetInputV1Pckg )(); + // Store command number + getInputV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Get command qualifier + TUint8 cmdQualifier( + commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + // First comes the user input display option + if ( KUserInputMask & cmdQualifier ) + { + // User input hidden + getInputV1.iInputDisplayOption = RSat::EHideUserInput; + } + else + { + // User input shown + getInputV1.iInputDisplayOption = RSat::EDisplayUserInput; + } + // Next the response format expected + if ( KUCS2AlphabetMask & cmdQualifier ) + { + getInputV1.iRspFormat = RSat::EUcs2Alphabet; + } + else if ( KAlphabetMask & cmdQualifier ) + { + if ( KGetInputSmsPackedMask & cmdQualifier ) + { + // SMS default alphabet + getInputV1.iRspFormat = RSat::ESmsDefaultAlphabetPacked; + } + else + { + getInputV1.iRspFormat = RSat::ESmsDefaultAlphabetUnpacked; + } + } + else + { + if ( KGetInputSmsPackedMask & cmdQualifier ) + { + // Digit only + getInputV1.iRspFormat = RSat::EDigitOnlyPacked; + } + else + { + getInputV1.iRspFormat = RSat::EDigitOnlyUnpacked; + } + } + // Help information. + if ( KHelpAvailabilityMask & cmdQualifier ) + { + // Help information available + getInputV1.iHelp = RSat::EHelpAvailable; + } + else + { + // No help + getInputV1.iHelp = RSat::ENoHelpAvailable; + } + + // Get Input text + getInputV1.iText.Zero(); + CTlv textString; + TInt returnValue( berTlv.TlvByTagValue( &textString, + KTlvTextStringTag ) ); + if ( KErrNone == returnValue ) + { + // Set and conver text + TSatUtility::SetText( textString, getInputV1.iText ); + } + else + { + TBuf<1> emptyString; + iSatMessHandler->GetInputTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KErrorRequiredValuesMissing, // Result + KNoCause, // KNoCause: 0 + emptyString, // No string + RSat::ESmsDefaultAlphabetUnpacked );// Data coding scheme + + ret = KErrCorrupt; + } + TFLOGSTRING2("TSY: GetInput, text: %S", &getInputV1.iText ); + OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYGETINPUT_MESSAGERECEIVED, "CSatNotifyGetInput::MessageReceived GetInput, text: %S", getInputV1.iText ); + + // Response length expected + CTlv responseLength; + returnValue = berTlv.TlvByTagValue( &responseLength, + KTlvResponseLengthTag ); + if ( KErrNone == returnValue ) + { + // Set minimum response length + getInputV1.iRspLength.iMinRspLength = + responseLength.GetShortInfo( ETLV_MinimumLengthOfResponse ); + + if ( RSat::KGetInputTextMaxSize < + getInputV1.iRspLength.iMinRspLength ) + { + TBuf<1> emptyString; + iSatMessHandler->GetInputTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KCmdDataNotUnderstood, // Result + KNoCause, // KNoCause: 0 + emptyString, // No string + RSat::ESmsDefaultAlphabetUnpacked );// Data coding scheme + + ret = KErrCorrupt; + } + // Set maximum response length + getInputV1.iRspLength.iMaxRspLength = + responseLength.GetShortInfo( ETLV_MaximumLengthOfResponse ); + } + else + { + // Mandatory reponse length tlv is missing + TBuf<1> emptyString; + iSatMessHandler->GetInputTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KErrorRequiredValuesMissing, // Result + KNoCause, // KNoCause: 0 + emptyString, // No string + RSat::ESmsDefaultAlphabetUnpacked );// Data coding scheme + + ret = KErrCorrupt; + } + // Default text to display (optional) + getInputV1.iDefaultText.Zero(); + returnValue = berTlv.TlvByTagValue( &textString, KTlvDefaultTextTag ); + // If default text exist + if ( KErrNone == returnValue ) + { + TSatUtility::SetText( textString, getInputV1.iDefaultText ); + } + // Iconid ( optional ) + TSatUtility::FillIconStructure( berTlv, getInputV1.iIconId ); + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInput::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a GetInput PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyGetInput::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYGETINPUT_NOTIFY, "CSatNotifyGetInput::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifyGetInput::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iGetInputV1Pckg = static_cast< RSat::TGetInputV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KGetInput ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetInput::TerminalResponse +// Handles a GetInput terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyGetInput::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_TERMINALRESPONSE, "CSatNotifyGetInput::TerminalResponse" ); + TFLOGSTRING("CSatNotifyGetInput::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + + RSat::TGetInputRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TGetInputRspV1Pckg* >( aRsp ); + RSat::TGetInputRspV1& rspV1 = ( *aRspPckg ) (); + + // Checking that the response type is valid. If additional info contain + // a text string, response format has to be set. + if ( RSat::EGetInputRspFormatNotSet == rspV1.iRspFormat + && RSat::KTextString == rspV1.iInfoType ) + { + ret = KErrCorrupt; + } + + // Check the additional info + if ( ( RSat::KTextString == rspV1.iInfoType ) + || ( RSat::KSuccess == rspV1.iGeneralResult ) ) + { + // Making sure first that the string is not empty + if ( RSat::KNoAdditionalInfo != rspV1.iInfoType + && 0 == rspV1.iAdditionalInfo.Length() ) + { + ret = KErrCorrupt; + } + } + // Check that general result values are valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // If there is Me (Mobile Entity) error, additional info is needed + if ( ( RSat::KMeProblem == rspV1.iInfoType ) ) + { + // Check the length of additional info + if ( rspV1.iAdditionalInfo.Length() != 0 ) + { + additionalInfo = static_cast< TUint8 >( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + iSatMessHandler->GetInputTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details Tlv + static_cast< TUint8 >( + rspV1.iGeneralResult ), // Result + additionalInfo, // Additional info + rspV1.iAdditionalInfo, // Input text + static_cast< TUint8 >( rspV1.iRspFormat ) ); // Resp. format + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyPlayTone::CSatNotifyPlayTone +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyPlayTone::CSatNotifyPlayTone + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iPlayToneV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE, "CSatNotifyPlayTone::CSatNotifyPlayTone" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPlayTone::~CSatNotifyPlayTone +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyPlayTone::~CSatNotifyPlayTone() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE, "CSatNotifyPlayTone::~CSatNotifyPlayTone" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPlayTone::MessageReceived +// Handles a PlayTone proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyPlayTone::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_MESSAGERECEIVED, "CSatNotifyPlayTone::MessageReceived" ); + TFLOGSTRING("CSatNotifyPlayTone::MessageReceived"); + //get ber tlv + CBerTlv berTlv; + TInt returnValue( KErrNone ); + returnValue = berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + iSatMessHandler->PlayToneTerminalResp( + iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + KNoCause ); // KNoCause: 0 + } + else + { + // Fill the play tone structure + RSat::TPlayToneV2& playToneV2 = ( *iPlayToneV2Pckg )(); + // command number + playToneV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + + // Alpha ID string (optional) + CTlv alphaIdentifier; + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ); + if ( KErrNotFound != returnValue ) + { + TUint16 alphaIdLength = alphaIdentifier.GetLength(); + if ( alphaIdLength ) + { + // get the alpha id + TPtrC8 sourceString; + sourceString.Set( + alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceString , + playToneV2.iAlphaId.iAlphaId ); + } + // Set Alpha ID status + if ( playToneV2.iAlphaId.iAlphaId.Length() ) + { + playToneV2.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + playToneV2.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + else + { + playToneV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + + // Tone selection (optional) + playToneV2.iTone = RSat::KToneNotSet; + CTlv tone; + returnValue = berTlv.TlvByTagValue( &tone, KTlvToneTag ); + if (returnValue != KErrNotFound) + { + playToneV2.iTone = ( RSat::TTone ) tone.GetShortInfo( ETLV_Tone ); + } + // Duration of the tone (optional) + TSatUtility::FillDurationStructure( berTlv, + playToneV2.iDuration ); + // Icond Id (optional) + TSatUtility::FillIconStructure( berTlv, + playToneV2.iIconId ); + + CompleteRequest( KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPlayTone::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a PlayTone PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyPlayTone::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYPLAYTONE_NOTIFY, "CSatNotifyPlayTone::Notify Handle: %u", aReqHandle ); + + TFLOGSTRING2("CSatNotifyPlayTone::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iPlayToneV2Pckg = static_cast< RSat::TPlayToneV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KPlayTone ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPlayTone::TerminalResponse +// Handles a PlayTone terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyPlayTone::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_TERMINALRESPONSE, "CSatNotifyPlayTone::TerminalResponse" ); + TFLOGSTRING("CSatNotifyPlayTone::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TPlayToneRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TPlayToneRspV1Pckg* >( aRsp ); + RSat::TPlayToneRspV1& rspV1 = ( *aRspPckg ) (); + // Check that general result value is valid. + // Note: When the phone is in silent mode, KMeUnableToProcessCmd + // is returned as a result, with no additional info. + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + + // If there is Me (Mobile Entity) error, additional info is needed + if ( RSat::KMeProblem == rspV1.iInfoType ) + { + // Check the length of additional info + if ( rspV1.iAdditionalInfo.Length() ) + { + additionalInfo = TUint8( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + iSatMessHandler->PlayToneTerminalResp( + iTransId, // Transaction Id + iCommandDetails, // Command number + TUint8( rspV1.iGeneralResult ), // Result + additionalInfo ); // Additional info + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyPollInterval::CSatNotifyPollInterval +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyPollInterval::CSatNotifyPollInterval + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL, "CSatNotifyPollInterval::CSatNotifyPollInterval" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPollInterval::~CSatNotifyPollInterval +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyPollInterval::~CSatNotifyPollInterval() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL, "CSatNotifyPollInterval::~CSatNotifyPollInterval" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPollInterval::MessageReceived +// Handles a PollInterval proactive command ISI message. +// No ETel pending request is required. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyPollInterval::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived" ); + TFLOGSTRING("CSatNotifyPollInterval::MessageReceived"); + //get ber tlv + CBerTlv berTlv; + TInt returnValue( KErrNone ); + berTlv.BerTlv( aIsiMessage ); + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + TUint16 anIntervalInSeconds( KDefaultPollInterval ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + // Duration of the interval + CTlv duration; + returnValue = berTlv.TlvByTagValue( &duration, KTlvDurationTag ); + if ( KErrNone != returnValue ) + { + // Required values are missing + iSatMessHandler->PollIntervalTerminalResp( iTransId, iCommandDetails, + RSat::KErrorRequiredValuesMissing, RSat::KNoSpecificMeProblem, 0); + } + else + { + TUint8 timeIntv( duration.GetShortInfo( ETLV_TimeInteval ) ); + + // Time Interval 0 is SIM server's default value (25 seconds) + if ( 0 != timeIntv ) + { + TUint8 durationTimeUnit( duration.GetShortInfo( ETLV_TimeUnit ) ); + + switch (durationTimeUnit) + { + case KMinutes: + { + anIntervalInSeconds = timeIntv * 60; + break; + } + case KSeconds: + { + anIntervalInSeconds = timeIntv; + break; + } + case KTenthsOfSeconds: + { + // Rounding + if ( 5 >= ( timeIntv % 10 ) ) + { + // if the intervals the ME can offer are equidistant + // (higher and lower) from the SIM's request, the ME shall + // respond with the lower interval of the two. + anIntervalInSeconds = static_cast (timeIntv / 10 ); + } + else + { + anIntervalInSeconds = static_cast ( (timeIntv / 10) + 1); + } + break; + } + default: + { + returnValue = KErrNotFound; + TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived, Time unit did not match."); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived, Time unit did not match." ); + // Command data not understood + iSatMessHandler->PollIntervalTerminalResp( iTransId, iCommandDetails, + RSat::KCmdDataNotUnderstood, RSat::KNoSpecificMeProblem, 0); + break; + } + }//switch + + // Check interval limits + if ( KMinPollInterval > anIntervalInSeconds ) + { + anIntervalInSeconds = KMinPollInterval; + } + else if ( KMaxPollInterval < anIntervalInSeconds ) + { + if ( iSatMessHandler->OldPollInterval() ) + { + TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived MaxPolInterval"); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived MaxPolInterval" ); + anIntervalInSeconds = KMaxPollInterval; + } + else + { + TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived, DefaultPollInterval"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived, DefaultPollInterval" ); + // Use SIM server's default value (0) + anIntervalInSeconds = KDefaultPollInterval; + } + } + } + else + { + // Use SIM server's default value (0) + anIntervalInSeconds = KDefaultPollInterval; + } + + if ( KErrNone == returnValue ) + { + + // A PCmd PollingOff may be executed. + iSatMessHandler->SetPollingOff( EFalse ); + // Send SetPollInterval request to ISA CellMo side. The terminal response + // will be sent to ISA CellMo side after SetPollInterval response. + iSatMessHandler->SetPollingInterval( + iTransId, + static_cast( anIntervalInSeconds ) ); + } + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPollInterval::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a PollInterval PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyPollInterval::Notify + ( + const TTsyReqHandle /*aReqHandle*/, // Request handle + TDes8* /*aDataPtr*/ // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_NOTIFY, "CSatNotifyPollInterval::Notify" ); + // PollInterval is completely implemented by SimAtkTsy. Client + // insn't notified about the command. + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpMenu::CSatNotifySetUpMenu +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpMenu::CSatNotifySetUpMenu + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSetUpMenuV2Pckg( NULL ), + iSatIsiMsg( NULL ), + iItemsNextIndicatorRemoved( EFalse ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU, "CSatNotifySetUpMenu::CSatNotifySetUpMenu" ); + TFLOGSTRING("CSatNotifySetUpMenu::CSatNotifySetUpMenu"); + iToolKitName.Zero(); + + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpMenu::~CSatNotifySetUpMenu +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpMenu::~CSatNotifySetUpMenu() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU, "CSatNotifySetUpMenu::~CSatNotifySetUpMenu" ); + TFLOGSTRING("CSatNotifySetUpMenu::~CSatNotifySetUpMenu"); + if ( iSatIsiMsg ) + { + delete iSatIsiMsg; + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpMenu::MessageReceived +// Handles a SetUpMenu proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpMenu::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived" ); + TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived"); + TInt ret( KErrNone ); + TInt returnValue( KErrNone ); + // get ber tlv + CBerTlv berTlv; + returnValue = berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + // Get command qualifier + TUint8 cmdQualifier( commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request is not pending. Store pcmd for later use + // This may happen e.g. when changing ME's language (warm reset) + if ( iSatIsiMsg ) + { + // first clear buffer if there's already data + delete iSatIsiMsg; + iSatIsiMsg = NULL; + } + // Alloc memory + iSatIsiMsg = aIsiMessage.GetBuffer().Alloc(); + + if ( iSatIsiMsg ) + { + TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived, pcmd saved"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, pcmd saved" ); + } + else + { + TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived, \ + out of memory unable to buffer received cmd"); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, out of memory unable to buffer received cmd" ); + iSatMessHandler->SetUpMenuTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + NULL ); + ret = KErrCorrupt; + } + } + RSat::TSetUpMenuV2 menu; + // Store command number + menu.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Selection preference + menu.iPreference = RSat::ESelectionPreferenceNotSet; + if ( cmdQualifier & KSelectionUsingSoftKey ) + { + menu.iPreference = RSat::ESoftKeyPreferred; + } + else + { + menu.iPreference = RSat::ENoSelectionPreference; + } + // Alpha Id string (optional) + menu.iAlphaId.iAlphaId.Zero(); + //get alpha identifier tlv + CTlv alphaIdentifier; + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ); + if ( KErrNone != returnValue ) + { + + iSatMessHandler->SetUpMenuTerminalResp( + iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + RSat::KNoAdditionalInfo ); + ret = KErrCorrupt; + } + else + { + TUint16 alphaIdLength = alphaIdentifier.GetLength(); + TFLOGSTRING2("TSY: Alpha ID length:%d", alphaIdLength ); + OstTraceExt1( TRACE_NORMAL, DUP3_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived Alpha ID: %hu", alphaIdLength ); + if ( alphaIdLength > RSat::KAlphaIdMaxSize ) + { + // String too long + ret = KErrCorrupt; + } + else if ( alphaIdLength ) + { + TPtrC8 temp; + // get the alpha id + temp.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + // convert and set the alpha id + TSatUtility::SetAlphaId( temp , menu.iAlphaId.iAlphaId ); + // Set SAT toolikit name, send SAT SMS logging purpose + iToolKitName.Copy( menu.iAlphaId.iAlphaId ); + TFLOGSTRING2("TSY: SetUpMenu iToolKitName:%S", + &iToolKitName ); + OstTraceExt1( TRACE_NORMAL, DUP4_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived SetUpMenu iToolKitName: %S", iToolKitName ); + } + else + { + TFLOGSTRING("TSY: CSatNotifySetUpMenu::MessageReceived,\ + Wrong length of alpha id."); + OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, Wrong length of alpha id." ); + } + // Alpha Id status + if ( menu.iAlphaId.iAlphaId.Length() ) + { + menu.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + menu.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + // Help information. + if ( commandDetails.GetShortInfo( ETLV_CommandQualifier ) + & KHelpAvailabilityMask ) + { + // Help information available + menu.iHelp = RSat::EHelpAvailable; + } + else + { + // No help + menu.iHelp = RSat::ENoHelpAvailable; + } + // Icon identifier + TSatUtility::FillIconStructure( berTlv, menu.iIconId ); + // Item Icon identifier list + CTlv itemsIconIdentifierList; + TInt retValue = berTlv.TlvByTagValue( &itemsIconIdentifierList, + KTlvItemIconIdentifierListTag ); + TPtrC8 iconIdList; + menu.iIconListQualifier = RSat::EIconQualifierNotSet; + + if( KErrNone == retValue ) + { + TUint8 iIconListQualifier( itemsIconIdentifierList.GetShortInfo( + ETLV_IconListQualifier ) ); + iconIdList.Set( itemsIconIdentifierList.GetData( ETLV_IconIdentifierList )); + + if( iIconListQualifier ) + { + menu.iIconListQualifier = RSat::ENotSelfExplanatory; + } + else + { + menu.iIconListQualifier = RSat::ESelfExplanatory; + } + } + else if ( KErrNotFound == retValue ) + { + menu.iIconListQualifier = RSat::ENoIconId; + } + else + { + TFLOGSTRING("TSY: CSatNotifySetUpMenu::MessageReceived, \ + Wrong return value of icon identifier list."); + OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, Wrong return value of icon identifier list." ); + } + + //Items Data + TInt itemNbr( 0 ); + CTlv itemsData; + returnValue = berTlv.TlvByTagValue( &itemsData, KTlvItemTag, + itemNbr ); + TUint8 numberOfItemData( 0 ); + TUint16 stringLength( 0 ); + if( !returnValue ) + { + CTlv itemsDataTemp; + stringLength = ( itemsData.GetLength()); + TInt ret(KErrNone); + // Set numberOfItemData + while ( KErrNone == ret ) + { + numberOfItemData++; + ret = berTlv.TlvByTagValue( &itemsDataTemp, KTlvItemTag, + numberOfItemData ); + } + } + + //Item Next Action Indicator + CTlv itemNextActionIndicator; + retValue = berTlv.TlvByTagValue( &itemNextActionIndicator, + KTlvItemsNextActionIndicatorTag ); + TPtrC8 itemNextIndicator; + if ( KErrNone == retValue ) + { + TPtrC8 itemNextIndicatorTemp; + itemNextIndicatorTemp.Set( + itemNextActionIndicator.GetData( ETLV_ItemsNextActionIndicator )); + + //In case the number of items in this list does not match the number + //of items in the menu the Items Next Action Indicator list is ignored by ME + if(itemNextIndicatorTemp.Length() != numberOfItemData ) + { + iItemsNextIndicatorRemoved = ETrue; + } + else + { + itemNextIndicator.Set(itemNextIndicatorTemp); + } + } + + //if first item is NULL -> remove existing menu + if( stringLength != 0 ) + { + for ( TInt8 i( 0 ) ; ( KErrNone == ret ) + && ( KErrNone == returnValue ) ; i++ ) + { + // Filling up the menu items + RSat::TItem newItem; + // Suffle through all the menu items + stringLength = 0; + TFLOGSTRING2("TSY: item number:%d", i ); + OstTraceExt1( TRACE_NORMAL, DUP7_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived Item number: %hhd", i ); + // Fill the newitem + newItem.iItemId = itemsData.GetShortInfo( ETLV_IdentifierOfItem ); + stringLength = itemsData.GetLength(); + stringLength--; + TPtrC8 itemData = itemsData.GetData( ETLV_TextStringOfItem ); + // Menu item string, coded as EFadn (3gpp 11.11) + newItem.iItemString.Zero(); + if ( ( KUCS2ArabicCoding == itemData[0] ) + || ( KUCS2GreekCoding == itemData[0] ) + || ( KUCS2TurkishCoding == itemData[0] ) ) + { + TSatUtility::ConvertAlphaFieldsToUnicode( itemData, + newItem.iItemString ); + } + else + { + TSatUtility::ConvertSms7ToUnicode16( newItem.iItemString, + itemData ); + } + TFLOGSTRING2("TSY: SetUpMenu newItem.iItemString:%S", + &newItem.iItemString ); + OstTraceExt1( TRACE_NORMAL, DUP8_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, newItem.iItemString: %S", newItem.iItemString ); + // Adding the new menuitem + if( NULL != iconIdList.Size() && ( i < iconIdList.Length() ) ) + { + if( ( NULL != itemNextIndicator.Size() ) + && ( i < itemNextIndicator.Length() ) ) + { + //Menu item with item next idicator and icon identifier + if ( KErrNoMemory == menu.AddItem( newItem, + itemNextIndicator[i], iconIdList[i] ) ) + { + // Too many or long menu items + ret = KErrCorrupt; + } + } + //menu item with icon identifier + else if ( KErrNoMemory == menu.AddItemIcon( newItem, + iconIdList[i] ) ) + { + // Too many or long menu items + ret = KErrCorrupt; + } + else + { + // All ok + } + } + else + { + if( ( NULL != itemNextIndicator.Size() ) + && ( i < itemNextIndicator.Length() ) ) + { + //menu item with item next indicator + if ( KErrNoMemory == menu.AddItem( newItem, + itemNextIndicator[i] ) ) + { + // Too many or long menu items + ret = KErrCorrupt; + } + } + //menu item + else + { + TInt retAdd = menu.AddItem( newItem ); + if ( KErrNoMemory == retAdd ) + { + // Too many or long menu items + // // If there is not enough space left in the + // buffer used + // by the menu KErrNoMemory is returned. + ret = KErrCorrupt; + // send terminal response + iSatMessHandler->SetUpMenuTerminalResp( + iTransId, + iCommandDetails, + RSat::KCmdDataNotUnderstood, + RSat::KNoAdditionalInfo ); + } + } + } + itemNbr++; + returnValue = berTlv.TlvByTagValue( &itemsData, + KTlvItemTag, + itemNbr ); + } + } + } + if ( iReqHandle ) + { + RSat::TSetUpMenuV2& setUpMenuV2 = ( *iSetUpMenuV2Pckg )(); + setUpMenuV2 = menu; + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpMenu::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SetUpMenu PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpMenu::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSETUPMENU_NOTIFY, "CSatNotifySetUpMenu::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifySetUpMenu::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + TInt ret( KErrNone ); + iReqHandle = aReqHandle; + iSetUpMenuV2Pckg = static_cast< RSat::TSetUpMenuV2Pckg* >( aDataPtr ); + ret = iSatMessaging->SatReady( KSetUpMenu ); + if ( KErrNotFound == ret ) + { + if ( iSatIsiMsg ) + { + MessageReceived( TIsiReceiveC( iSatIsiMsg->Des() ) ); + delete iSatIsiMsg; + iSatIsiMsg = NULL; + } + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpMenu::TerminalResponse +// Handles a SetUpMenu terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySetUpMenu::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_TERMINALRESPONSE, "CSatNotifySetUpMenu::TerminalResponse" ); + TFLOGSTRING("CSatNotifySetUpMenu::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TSetUpMenuRspV1Pckg* aRspPckg = + reinterpret_cast( aRsp ); + RSat::TSetUpMenuRspV1& rspV1 = ( *aRspPckg ) (); + + // Check that general result value is valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // If there is Me (Mobile Entity) error, additional info is needed + if ( RSat::KMeProblem == rspV1.iInfoType ) + { + // Check the length of additional info + if ( rspV1.iAdditionalInfo.Length() != 0 ) + { + additionalInfo = static_cast( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + + if( RSat::KSuccess == rspV1.iGeneralResult && iItemsNextIndicatorRemoved ) + { + TFLOGSTRING("CSatNotifySetUpMenu::TerminalResponseL, iItemsNextIndicatorRemoved"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_TERMINALRESPONSE, "CSatNotifySetUpMenu::TerminalResponseL, iItemsNextIndicatorRemoved" ); + rspV1.iGeneralResult = RSat::KPartialComprehension; + } + iItemsNextIndicatorRemoved = EFalse; + + // Creating the info message + iSatMessHandler->SetUpMenuTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command number + static_cast( rspV1.iGeneralResult ), // Result + additionalInfo ); // additional info + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpMenu::SatApplicationName +// Return a reference to sat application name. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TDes16& CSatNotifySetUpMenu::SatApplicationName() + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_SATAPPLICATIONNAME, "CSatNotifySetUpMenu::SatApplicationName" ); + if ( 0x0 == iToolKitName.Length() ) + { + // Default toolkit name + iToolKitName.Copy( KSatToolkit ); + } + return iToolKitName; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySelectItem::CSatNotifySelectItem +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySelectItem::CSatNotifySelectItem + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSelectItemV2Pckg( NULL ), + iItemNextIndicatorRemoved( EFalse ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM, "CSatNotifySelectItem::CSatNotifySelectItem" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser + + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySelectItem::~CSatNotifySelectItem +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySelectItem::~CSatNotifySelectItem() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM, "CSatNotifySelectItem::~CSatNotifySelectItem" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySelectItem::MessageReceived +// Handles a SelectItem proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySelectItem::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived" ); + TFLOGSTRING("CSatNotifySelectItem::MessageReceived"); + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iCommandDetails.Copy( commandDetails.Data() ); + // Get command qualifier + TUint8 cmdQualifier( + commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + iSatMessHandler->SelectItemTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details TLV + RSat::KMeUnableToProcessCmd, // Result + KNoCause ); // Additional info + } + else + { + // Fill the select item structure + RSat::TSelectItemV2& selectItemV2 = ( *iSelectItemV2Pckg )(); + // Store command number + selectItemV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + TPtrC8 sourceString; // Used in unicode conversions + // Alpha id string (optional) + selectItemV2.iAlphaId.iAlphaId.Zero(); + CTlv alphaIdentifier; + TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ) ); + // If alpha id string exist + if ( KErrNone == returnValue ) + { + TUint16 alphaIdLength( + alphaIdentifier.GetLength() ); + if ( alphaIdLength ) + { + // Get the alpha id + sourceString.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + + // Convert and set the alpha id + TSatUtility::SetAlphaId( sourceString , + selectItemV2.iAlphaId.iAlphaId ); + } + // Check alpha tag (id) status + if ( alphaIdLength ) + { + // Alpha tag present + if ( selectItemV2.iAlphaId.iAlphaId.Length() ) + { + selectItemV2.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + selectItemV2.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + } + // Alpha id not present + else + { + selectItemV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + // Help information + if ( KHelpAvailabilityMask & cmdQualifier ) + { + // Help information available + selectItemV2.iHelp = RSat::EHelpAvailable; + } + else + { + // No help + selectItemV2.iHelp = RSat::ENoHelpAvailable; + } + + // Presentation type + if ( KSelectItemPresentationTypeMask & cmdQualifier ) + { + if ( KSelectItemChoiceOfNavigationMask & cmdQualifier ) + { + // Presentation as a choice of navigation options + selectItemV2.iPresentationType = RSat::ENavigationOptions; + } + else + { + // Presentation as a choice of data values + selectItemV2.iPresentationType = RSat::EDataValues; + } + } + else + { + TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived, \ + Presentation type was not set."); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Presentation type was not set" ); + + selectItemV2.iPresentationType = RSat::ENotSpecified; + } + // Selection preference + if ( KSelectItemSelectUsingSoftKeyMask & cmdQualifier ) + { + // Preference = soft key + selectItemV2.iPreference = RSat::ESoftKeyPreferred; + } + else + { + // Preference not set + selectItemV2.iPreference = RSat::ENoSelectionPreference; + } + // Default item id ( optional ) + CTlv defaultItem; + returnValue = berTlv.TlvByTagValue( &defaultItem, + KTlvItemIdentifierTag ); + if ( KErrNone == returnValue ) + { + selectItemV2.iDefaultItemId = + defaultItem.GetShortInfo( ETLV_IdentifierOfItemChosen ); + } + // Icon qualifier list ( optional ) + // Each item of a list of items has an icon identifier coded on one + // byte. The length of the Items icon identifier list shall be the + // number of items of the list of items (X-1 shall be the number of + // items in the list). The order of each item icon identifier, + // shall reflect the order of the items in the list of items. + // Each icon identifier addresses a record + // in EFIMG as defined in TS 11.11 + CTlv itemsIconIdentifierList; + TInt retValue( berTlv.TlvByTagValue( &itemsIconIdentifierList, + KTlvItemIconIdentifierListTag ) ); + selectItemV2.iIconListQualifier = RSat::EIconQualifierNotSet; + TPtrC8 iconIdList; + if ( KErrNone == retValue ) + { + TUint8 iconListQualifier( itemsIconIdentifierList.GetShortInfo( + ETLV_IconListQualifier ) ); + // set iconIdList pointer + iconIdList.Set( + itemsIconIdentifierList.GetData( ETLV_IconIdentifierList )); + // The icon list qualifier indicates to the ME how + // the icons are to be used + if( iconListQualifier ) + { + // icon is not self-explanatory, i.e. if displayed, + // it shall be displayed together with the item text + selectItemV2.iIconListQualifier = RSat::ENotSelfExplanatory; + } + else + { + // icon is self-explanatory, i.e. if displayed, + // it replaces the item text + selectItemV2.iIconListQualifier = RSat::ESelfExplanatory; + } + } + else if ( KErrNotFound == retValue ) + { + selectItemV2.iIconListQualifier = RSat::ENoIconId; + } + else + { + TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived, \ + Return value not valid."); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Return value not valid." ); + + } + + CTlv item; + // Get all items + returnValue = berTlv.TlvByTagValueMulti( &item, KTlvItemTag ); + TPtrC8 itemData = item.Data(); + TUint8 numberOfItemData( 0 ); + TInt ind( 0 ); + TUint16 tlvLength( 0 ); + TInt currentTlv( 0 ); + TInt i( 0 ); + // Set numberOfItemData + for ( i = 0; i < itemData.Length(); i += TInt( tlvLength ) ) + { + // First determine if the length of the TLV is + // coded with 1 or 2 bytes. + if ( KTwoByteLengthCoding == itemData[ind+1] ) + { + // Length is coded with 2 bytes -> real length is in second + // byte first byte is 81 and it is "tag" for 2 byte length + // coding. + tlvLength = + TUint16( itemData[ind + 2] + KTlvHeaderLength + 1 ); + } + else + { + //TLV header bytes (2) must be added to total length + tlvLength = TUint16( itemData[ind + 1] + KTlvHeaderLength ); + } + + currentTlv = itemData[ind]&KTagValueMask; + + if ( KTlvItemTag == currentTlv ) + { + numberOfItemData++; + } + + ind += tlvLength; + } + + // See if itemnextindicator is included ( optional ) + CTlv nextIndicator; + + returnValue = berTlv.TlvByTagValue( &nextIndicator, + KTlvItemsNextActionIndicatorTag ); + TPtrC8 itemNextIndicator; + if ( KErrNone == returnValue ) + { + TPtrC8 itemNextIndicatorTemp; + itemNextIndicatorTemp.Set( + nextIndicator.GetData( ETLV_ItemsNextActionIndicator ) ); + + //In case the number of items in this list does not match the number + //of items in the menu the Items Next Action Indicator list is ignored by ME + if( itemNextIndicatorTemp.Length() != numberOfItemData ) + { + iItemNextIndicatorRemoved = ETrue; + } + else + { + itemNextIndicator.Set(itemNextIndicatorTemp); + } + } + + // Filling up the menu items + RSat::TItem newItem; + // Set string length and pos + TUint8 stringLength( 0 ); + TUint8 pos( 2 ); + // Transfers menu items to EtelSat data structure + for ( i = 0; ( i < numberOfItemData ) && ( KErrNone == ret ); i++ ) + { + // Check if two byte length coding is used + if ( itemData[pos - 1] == KTwoByteLengthCoding ) + { + // Set new offset + pos++; + } + // Fill item if TLV contains real data, length < 0 + if ( KZero < itemData[pos - 1] ) + { + // Fill the newitem + newItem.iItemId = itemData[pos]; + stringLength = itemData[pos - 1]; + } + else + { + // No real ítem data in TLV + newItem.iItemId = 0; + stringLength = 0; + } + + // Copying the string from 8-bit to 16-bit + if ( stringLength > RSat::KMenuItemMaxSize ) + { + // String too long + ret = KErrCorrupt; + } + newItem.iItemString.Zero(); + // ArabicCoding, GreekCoding and TurkishCoding have different + // coding method. There is a tag for each type of alphabet + // (resp. 80, 81 or 82) before the text, and there are base + // pointers used for expanding 1 byte to 2 bytes as required + // in UCS2 + // Ref: 3gpp 11.11, Annex B + + //Check if string present + if ( 0 < ( stringLength - 1 ) ) + { + TBuf8 itemText; + itemText = itemData.Mid( pos + 1, stringLength - 1 ); + + if ( ( itemText[0] == KUCS2ArabicCoding ) + || ( itemText[0] == KUCS2GreekCoding ) + || ( itemText[0] == KUCS2TurkishCoding ) ) + { + TSatUtility::ConvertAlphaFieldsToUnicode( itemText, + newItem.iItemString ); + } + else + { + // 8-bit format + TSatUtility::ConvertSms7ToUnicode16( newItem.iItemString, + itemText ); + } + } + + if( NULL != iconIdList.Size() + && ( i < iconIdList.Length() ) ) + { + if( ( NULL != itemNextIndicator.Size() ) + && ( i < itemNextIndicator.Length() ) ) + { + // ADD ITEM WITH ITEM NEXT INDICATOR AND ICON IDENTIFIER + if ( KErrNoMemory == selectItemV2.AddItem( + newItem, itemNextIndicator[i], iconIdList[i] ) ) + { + // Too many or long menu items + ret = KErrCorrupt; + } + } + // ADD ITEM WITH ICON + else if ( KErrNoMemory == selectItemV2.AddItemIcon( + newItem, iconIdList[i] ) ) + { + // Too many or long menu items + ret = KErrCorrupt; + } + else + { + TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived,\ + Item with icon not valid."); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Item with icon not valid." ); + } + } + else + { + if( ( NULL != itemNextIndicator.Size() ) + && ( i < itemNextIndicator.Length() ) ) + { + // ADD ITEM WITH ITEM NEXT INDICATOR + if ( KErrNoMemory == selectItemV2.AddItem( + newItem, itemNextIndicator[i] ) ) + { + // Too many or long menu items + ret = KErrCorrupt; + } + } + //ADD ITEM + else + { + TInt retAdd = selectItemV2.AddItem( newItem ); + if ( KErrNoMemory == retAdd ) + { + // Too many or long menu items + // If there is not enough space left in the buffer used + // by the menu KErrNoMemory is returned. + // Send terminal response + iSatMessHandler->SelectItemTerminalResp( + iTransId, // transaction id + iCommandDetails, // Command details TLV + RSat::KCmdDataNotUnderstood, // Result + KNoCause ); // Additional info + ret = KErrCorrupt; + } + } + } + // Calculating the new position + pos = TUint8( pos + itemData[pos - 1] + 2 ); + } + // Iconid + TSatUtility::FillIconStructure( berTlv, selectItemV2.iIconId ); + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySelectItem::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SelectItem PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySelectItem::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSELECTITEM_NOTIFY, "CSatNotifySelectItem::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifySelectItem::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iSelectItemV2Pckg = static_cast< RSat::TSelectItemV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSelectItem ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySelectItem::TerminalResponse +// Handles a SelectItem terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySelectItem::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_TERMINALRESPONSE, "CSatNotifySelectItem::TerminalResponse" ); + TFLOGSTRING("CSatNotifySelectItem::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TSelectItemRspV1Pckg* aRspPckg = + reinterpret_cast( aRsp ); + RSat::TSelectItemRspV1& rspV1 = ( *aRspPckg ) (); + + // Check that general result values are valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + + // If there is Me (Mobile Entity) error or there there should be + // item identifier or + // general result is success, additional info is needed + if ( ( RSat::KMeProblem == rspV1.iInfoType ) + || ( RSat::KItemIdentifier == rspV1.iInfoType ) + || ( RSat::KSuccess == rspV1.iGeneralResult ) ) + { + // Check the length of additional info + if ( rspV1.iAdditionalInfo.Length() != 0 ) + { + additionalInfo = static_cast( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + + if( RSat::KSuccess == rspV1.iGeneralResult && iItemNextIndicatorRemoved ) + { + TFLOGSTRING("CSatNotifySelectItem::TerminalResponseL, iItemNextIndicatorRemoved"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_TERMINALRESPONSE, "CSatNotifySelectItem::TerminalResponse, iItemNextIndicatorRemoved" ); + + rspV1.iGeneralResult = RSat::KPartialComprehension; + } + iItemNextIndicatorRemoved = EFalse; + + iSatMessHandler->SelectItemTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details + static_cast< TUint8 >( + rspV1.iGeneralResult ), // General result + additionalInfo ); // Additional info + return ret; + + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::CSatNotifySendSm +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySendSm::CSatNotifySendSm + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSendSmV1Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_CSATNOTIFYSENDSM, "CSatNotifySendSm::CSatNotifySendSm" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KNetworkUnableToProcessCmd + RSat::KSmsRpError + + RSat::KErrorRequiredValuesMissing + + RSat::KInteractionWithCCPermanentError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::~CSatNotifySendSm +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySendSm::~CSatNotifySendSm() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_CSATNOTIFYSENDSM, "CSatNotifySendSm::~CSatNotifySendSm" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::MessageReceived +// Handles a SendSm proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendSm::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_MESSAGERECEIVED, "CSatNotifySendSm::MessageReceived" ); + TFLOGSTRING("CSatNotifySendSm::MessageReceived"); + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + iSatMessHandler->SendSmTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KMeUnableToProcessCmd, // Result + KNoCause ); // Additional info + } + else + { + // Fill the send sm structure + RSat::TSendSmV1& sendSmV1 = ( *iSendSmV1Pckg )(); + // Store command number + sendSmV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + sendSmV1.iSmsTpdu.Zero(); + CTlv smsTpduTlv; + // Get TPdu tlv + TInt returnValue( berTlv.TlvByTagValue( &smsTpduTlv, + KTlvSmsTpduTag ) ); + if ( KErrNone == returnValue ) + { + // Tpdu TLV length + TUint16 smsTpduLength( smsTpduTlv.GetLength() ); + // Set pointer to Tpdu + TPtrC8 smsTpdu = smsTpduTlv.GetData( ETLV_SmsTPdu ); + // Check that TP-UDL is valid + ret = CheckTpdu( smsTpdu ); + if ( KErrCorrupt == ret ) + { + // Length of TPDU is invalid + iSatMessHandler->SendSmTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KCmdDataNotUnderstood, // Result + KNoCause ); // Additional info + } + if ( smsTpduLength && KErrNone == ret ) + { + // Copying the smsTpdu + sendSmV1.iSmsTpdu.Append( smsTpdu ); + } + // Checking if packing is required for the SMS message or not + // Packing: see ETSI 3.38 and 3.40 + if ( KSmsPackingRequiredMask & iCommandDetails[KCommandQualifier] + && ( KErrNone == ret ) ) + { + // Packing required + if ( smsTpduLength ) + { + // Call method to pack sms + ret = PackSms( smsTpdu, sendSmV1.iSmsTpdu ); + if ( KErrNone != ret ) + { + // tpdu is invalid or packing cannot be requested + // if tpdu is something else than SMS-SUBMIT + iSatMessHandler->SendSmTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KCmdDataNotUnderstood,// Result + KNoCause ); // Additional info + ret = KErrCorrupt; + } + } + } + } + else + { + // TPdu is missing, returning response immediately + iSatMessHandler->SendSmTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KErrorRequiredValuesMissing,// Result + KNoCause ); // Additional info + ret = KErrCorrupt; + } + if ( KErrNone == ret ) + { + TPtrC8 sourceString; // Used in unicode conversions + // Alpha id string (optional) + sendSmV1.iAlphaId.iAlphaId.Zero(); + CTlv alphaIdTlv; + returnValue = berTlv.TlvByTagValue( &alphaIdTlv, + KTlvAlphaIdentifierTag ) ; + if ( KErrNone == returnValue ) + { + // alpha id tlv found + if ( alphaIdTlv.GetLength() ) + { + // get alpha id text + sourceString.Set( + alphaIdTlv.GetData( ETLV_AlphaIdentifier ) ); + + // convert and set alpha id + TSatUtility::SetAlphaId( sourceString, + sendSmV1.iAlphaId.iAlphaId ); + } + // Alpha Tag present + if ( sendSmV1.iAlphaId.iAlphaId.Length() ) + { + sendSmV1.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + sendSmV1.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + else + { + sendSmV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + // The address data object holds the RP_Destination_Address of the + // Service Centre. If no RP_Destination_Address is transferred, + // then the ME shall insert the default Service Centre address. + // Service centre address + sendSmV1.iAddress.iTelNumber.Zero(); + CTlv addressTlv; + // Get address tlv. Includes SCA number. (optional) + returnValue = berTlv.TlvByTagValue( &addressTlv, KTlvAddressTag ); + if ( KErrNone == returnValue ) + { + if ( 0 < addressTlv.GetLength() ) + { + // Initialize ton and npi + RSat::TTypeOfNumber ton; + RSat::TNumberingPlan npi; + // Call utility function that maps received TON and NPI to + // RSat values + TSatUtility::GetTonAndNpi( + addressTlv.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi ); + // Set TON and NPI + sendSmV1.iAddress.iTypeOfNumber = ton; + sendSmV1.iAddress.iNumberPlan = npi; + + TBuf8 tempScaNumber; + // set pointer to address tlv + sourceString.Set( + addressTlv.GetData( ETLV_DiallingNumberString ) ); + if ( sourceString.Length() ) + { + // Semi-octet presentation used + // Converting back to ASCII format + TSatUtility::BCDToAscii( sourceString, tempScaNumber ); + + sendSmV1.iAddress.iTelNumber.Copy( tempScaNumber ); + + TFLOGSTRING2("TSY:SendSm, SCA number: %S", + &sendSmV1.iAddress.iTelNumber ); + OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_MESSAGERECEIVED, "CSatNotifySendSm::MessageReceived SCA number: %S", sendSmV1.iAddress.iTelNumber ); + } + else + { + // Address TLV found, TON/NPI present, but number epmpty. + sendSmV1.iAddress.iTypeOfNumber = RSat::EUnknownNumber; + sendSmV1.iAddress.iNumberPlan = RSat::EUnknownNumberingPlan; + } + } + else + { + // Address TLV found, but the Value part doesn't exist + sendSmV1.iAddress.iTypeOfNumber = RSat::EUnknownNumber; + sendSmV1.iAddress.iNumberPlan = RSat::EUnknownNumberingPlan; + } + } + else + { + // Addrress TLV not found + sendSmV1.iAddress.iTypeOfNumber = RSat::ETypeOfNumberNotSet; + sendSmV1.iAddress.iNumberPlan = RSat::ENumberingPlanNotSet; + } + // Iconid + TSatUtility::FillIconStructure( berTlv, sendSmV1.iIconId ); + } + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SendSm PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendSm::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDSM_NOTIFY, "CSatNotifySendSm::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifySendSm::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iSendSmV1Pckg = static_cast< RSat::TSendSmV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSendShortMessage ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::TerminalResponse +// Handles a SendSm terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendSm::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_TERMINALRESPONSE, "CSatNotifySendSm::TerminalResponse" ); + TFLOGSTRING("CSatNotifySendSm::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TSendSmRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TSendSmRspV1Pckg* >( aRsp ); + RSat::TSendSmRspV1& rspV1 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // If there is Me (Mobile Entity) error or network error, additional info + // is needed + if ( ( RSat::KMeProblem == rspV1.iInfoType ) + || ( RSat::KSatNetworkErrorInfo == rspV1.iInfoType ) + || ( RSat::KControlInteraction == rspV1.iInfoType ) ) + { + // Check the length of additional info + if ( 0 == rspV1.iAdditionalInfo.Length() ) + { + // No info + ret = KErrCorrupt; + } + else + { + additionalInfo = static_cast< TUint8 >( rspV1.iAdditionalInfo[0] ); + } + } + // Creating the info message + iSatMessHandler->SendSmTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + static_cast< TUint8 >( + rspV1.iGeneralResult ), // Result + additionalInfo ); // Additional info + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::GetTpUdlIndex +// Returns respectively index of TP-UDL or TP-CDL field if sms type is +// respectively SMS-SUBMIT or SMS-COMMAND +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TUint8 CSatNotifySendSm::GetTpUdlIndex + ( + TPtrC8 aTpdu // Tpdu where to read TP-UDL or TP-CDL + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_GETTPUDLINDEX, "CSatNotifySendSm::GetTpUdlIndex" ); + TFLOGSTRING("CSatNotifySendSm::GetTpUdlIndex"); + + // Position on TP-UDL/TP-CDL field in SMS TPDU + TUint8 tpDlIndex( 0 ); + + // SMS-SUBMIT + if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) ) + { + // Add mandatory fields at first: TP-MTI, TP-MR, TP-DA(address length, + // TON&NPI), TP-PID, DCS and TP-UDL. + // Index starts from [0] + tpDlIndex = KTPDUMandatoryFieldsSmsSubmitUdl; + + // Checking the TP-VP field existence and format + // bit4 bit3 + // 0 0 TP-VP field not present + // 1 0 TP-VP field present - relative format + // 0 1 TP-VP field present - enhanced format + // 1 1 TP-VP field present - absolute format + + // Shift by 3 and mask for getting bits 3 and 4 + TUint8 vpFormat( ( aTpdu[0] >> 3 ) & KSmsVpFormatMask ); + + if ( KSmsVPFRelative == vpFormat ) + { + // TP-Validity period comprises 1 octet + tpDlIndex++; + } + else if ( KSmsVPFEnhanced == vpFormat || KSmsVPFAbsolute == vpFormat ) + { + // TP-Validity period comprises 7 octets + tpDlIndex += 7; + } + + // Calculate the address length in bytes, located in index 2 + TUint8 addressLengthInBytes( aTpdu[2] ); + // Address length is number of BCD characters. + // Two BCD string chars are coded in one byte => + // divide by two (shitf to right). Before dividing, 1 is added + // for ensuring that result is rounded up in case of odd value + addressLengthInBytes++; + addressLengthInBytes >>= 1; + + // Add address length + tpDlIndex += addressLengthInBytes; + } + // SMS-COMMAND + else + { + // Add mandatory fields at first: TP-MTI, TP-MR, TP-PID, TP-CT, TP-MN, + // TP-DA(address length, TON&NPI) and TP-CDL. + // Index starts from [0] + tpDlIndex = KTPDUMandatoryFieldsSmsCommandUdl; + // Address length, located in index 5 + TUint8 addressLengthInBytes( aTpdu[5] ); + // Address length is number of BCD characters + // Two BCD string chars are coded in one byte => + // divide by two (shitf to right). Before dividing, 1 is added + // for ensuring that result is rounded up in case of odd value + addressLengthInBytes++; + addressLengthInBytes >>= 1; + + // Add address length + tpDlIndex += addressLengthInBytes; + } + + return tpDlIndex; // Return TP-UDL/TP-CDL index + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::GetTpDcsIndex +// Returns index of TP-DCS (data coding scheme) of the sms. +// SMS type is SMS-SUBMIT. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TUint8 CSatNotifySendSm::GetTpDcsIndex + ( + TPtrC8 aTpdu // Tpdu + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_GETTPDCSINDEX, "CSatNotifySendSm::GetTpDcsIndex" ); + TFLOGSTRING("CSatNotifySendSm::GetTpDcsIndex"); + + // Position of TP-DCS field in SMS TPDU + // Add mandatory fields at first: TP-MTI, TP-MR, TP-DA(address length, + // TON/NPI), TP-PID and TP-DCS. + // Index starts from [0] + TUint8 tpDcsIndex( KTPDUMandatoryFieldsSmsSubmitDcs ); + // Calculate the length of address, located in index 2 + TUint8 addressLengthInBytes( aTpdu[2] ); + // Address lenght is number of BCD characters. + // Add one for ensuring the rounding up after division in case of odd + // number + addressLengthInBytes++; + // Divide by two for getting length in bytes + addressLengthInBytes >>= 1; + // Add address length to dcs position + tpDcsIndex += addressLengthInBytes; + + return tpDcsIndex; // Return index of TP-DCS + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::CheckTpdu +// Check TPDU validity +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendSm::CheckTpdu + ( + TPtrC8 aTpdu // TPDU + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu" ); + TFLOGSTRING("CSatNotifySendSm::CheckTpdu"); + TInt ret( KErrNone ); + TUint8 tpUdlPos( 0 ); // UDL position + TUint8 tpUdl( 0 ); // User data length + TUint8 bufferLength( aTpdu.Length() ); // TPDU buffer length + + // At first check that TPDU length isn't under minimum + if ( KMinSmsTpduLength > bufferLength ) + { + TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid TPDU length"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid TPDU length" ); + ret = KErrCorrupt; + } + else + { + // Get index of UDL field + tpUdlPos = GetTpUdlIndex( aTpdu ); + // Check that UDL index is valid + if ( tpUdlPos < bufferLength ) + { + // Get user data length in 8-bit characters (without packing) + tpUdl = aTpdu[tpUdlPos]; + } + else + { + TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid UDL index"); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid UDL index" ); + ret = KErrCorrupt; + } + } + + if ( KErrNone == ret ) + { + // SMS-SUBMIT + if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) ) + { + // Only user data bytes are remained + bufferLength -= ( tpUdlPos + 1 ); + // Get index of TP-DCS field + TUint8 tpDcsPos( GetTpDcsIndex( aTpdu ) ); + // Get data coding scheme + TUint8 dcs( aTpdu[tpDcsPos] ); + + // Bits 2 and 3 are for coding scheme ( spec. 3GPP TS23.038 ) + dcs = ( dcs >> 2 ) & 0x03; + // GSM 7 bit default alphabet + if ( KSmsDcsDefaultAlphabet == dcs ) + { + // When 7 bit packing is used, number of characters is calculated + // as follows (spec. 3GPP TS 23.038 V7.0.0 ): + // number of characters = length of user data in bytes * 8 / 7 + bufferLength = ( bufferLength * 8 ) / 7; + // Check the validity of user data length + if ( KSmsMaxSize < tpUdl || bufferLength < tpUdl ) + { + // Message is over 160 bytes or invalid user data length + TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid user data length"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" ); + ret = KErrCorrupt; + } + } + else // 8-bit or 16-bit data + { + // Check if packing is required + TBool isPackingRequired( KSmsPackingRequiredMask & + iCommandDetails[KCommandQualifier] ); + TUint8 maxSmsSize( isPackingRequired ? + KSmsMaxSize : KSmsMaxSizeWithoutPacking ); + // Check the validity of user data length + if ( maxSmsSize < tpUdl || bufferLength < tpUdl ) + { + // Message size is over the limit or invalid user data length + TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid user data length"); + OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" ); + ret = KErrCorrupt; + } + } + } // end of if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) ) + else // SMS-COMMAND + { + if ( KSMSCommandMaxSize < tpUdl ) + { + TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: user data length over maximum"); + OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: user data length over maximum" ); + ret = KErrCorrupt; + } + } + } // End of if ( KErrNone == ret ) + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSm::PackSms +// Pack SMS content if it is required by the sim +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendSm::PackSms + ( + TPtrC8 aTpdu, // Received Tpdu + TTpdu& aSendSm // Where to store packed sms + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_PACKSMS, "CSatNotifySendSm::PackSms" ); + TFLOGSTRING("CSatNotifySendSm::PackSms"); + TInt ret( KErrNone ); + + // Checking the message type, SMS-SUBMIT can be packed: + // + // Bit1 | Bit0 | Message type + // ------------------------------------------------------------ + // 0 | 0 | SMS-DELIVER (in the direction SC to MS) + // 0 | 0 | SMS-DELIVER REPORT (in the direction MS to SC) + // 1 | 0 | SMS-STATUS-REPORT (in the direction SC to MS) + // 1 | 0 | SMS-COMMAND (in the direction MS to SC) + // 0 | 1 | SMS-SUBMIT (in the direction MS to SC) + // 0 | 1 | SMS-SUBMIT-REPORT (in the direction SC to MS) + // 1 | 1 | Reserved + // + if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) ) + { + // Message is a SMS-SUBMIT message. + // + // Get index of TP-UDL field and it is also starting position. + TUint8 startPosition( GetTpUdlIndex( aTpdu ) ); + // Get number of characters what will be packed. + TUint8 charsToPack( aTpdu[startPosition] ); + // Calculate end position. + TUint8 endPosition( startPosition + charsToPack ); + // Get SMS TPDU length + TUint8 tpduLength( aTpdu.Length() ); + + // Initialize values. + TInt i( 0 ); + TInt x( startPosition + 1 ); + TBool endOfTPDU( EFalse ); + TUint8 move( 0 ); + + // Lets pack all the characters in SMS Message (TP-UD), including header + // (TP-UD-Header) if exist. + // + // Go through the TP-UD. + for ( i = startPosition; i < endPosition; i++ ) + { + // Check that index is not over SMS TPDU length. + if ( ( i + 1 ) < tpduLength ) + { + TUint8 char1( TUint8( aTpdu[i + 1] >> move ) ); + + TUint8 char2( 0 ); + + if ( ( i + 2 ) <= endPosition ) + { + // Check that index is not over SMS TPDU length. + if ( ( i + 2 ) < tpduLength ) + { + char2 = TUint8( aTpdu[i + 2] << ( 7 - move ) ); + } + else + { + ret = KErrCorrupt; + break; + } + } + else + { + // No more characters to pack. + endOfTPDU = ETrue; + char2 = 0; + } + + // Append packed characters. + aSendSm[x++] = TUint8( char1 | char2 ); + + // New values for next round. + if ( ( 6 == move ) && !endOfTPDU ) + { + i++; + move = 0; + } + else + { + move++; + } + } + else + { + ret = KErrCorrupt; + break; + } + } + + // TP-UD is now packed + if ( KErrCorrupt != ret ) + { + // New string length (number of characters) + // + // Calculate if string length is changed from orginal length. + // These lengths are aTpdu[] buffer length so it start from "0" + // > "i" includes old value + // > "x" is new value with packed TP-UD + // > "x - 1" because we needed to add one for start point earlier + // to append characters to correct position. + TUint8 stringLengthChanged( i - ( x - 1 ) ); + + if ( stringLengthChanged ) + { + aSendSm.SetLength( aSendSm.Length() - stringLengthChanged ); + } + + // Change the DCS to default alphabet coding. See ETSI 3.38 + // + // Get the position of TP-DCS + TUint8 posDCS( GetTpDcsIndex( aTpdu ) ); + + // Coding Group Bits are 7..4 and Use of bits are 3..0 + // We need to find out correct Coding Group. + // + // KMaskC0: 0xC0 = 1100 0000 + // > This check include Coding Group: + // >> Bits: 7..4 + // >> Group: 00xx + // + if ( KMask0 == ( aTpdu[posDCS] & KMaskC0 ) ) + { + // Set bits 2 and 3 to 0. + // Bits 3 and 2 indicate the alphabet being used, as follows: + // + // Bit3 | Bit2 | Alphabet: + // ---------------------------------------- + // 0 | 0 | GSM 7 bit default alphabet + // 0 | 1 | 8 bit data + // 1 | 0 | UCS2 (16bit) + // 1 | 1 | Reserved + // + // KMaskF3: 0xF3 = 1111 0011 + aSendSm[posDCS] = TUint8( aSendSm[posDCS] & KMaskF3 ); + } + + // KMaskF0: 0xF0 = 1111 0000 + // > This check include Coding Group: + // >> Bits: 7..4 + // >> Group: 1111 + // + if ( KMaskF0 == ( aTpdu[posDCS] & KMaskF0 ) ) + { + // Set bit 2 to 0. + // Bit 3 is reserved, set to 0. + // + // Bit 2 indicate the alphabet being used, as follows: + // + // Bit2 | Message coding: + // --------------------------------- + // 0 | GSM 7 bit default alphabet + // 1 | 8-bit data + // + // KMaskFB: 0xFB = 1111 1011 + aSendSm[posDCS] = TUint8( aSendSm[posDCS] & KMaskFB ); + } + } + } + else + { + // Packing cannot be requested if TPDU is something else + // than SMS submit. + ret = KErrCorrupt; + } + + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendDtmf::CSatNotifySendDtmf +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySendDtmf::CSatNotifySendDtmf + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSendDtmfV1Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF, "CSatNotifySendDtmf::CSatNotifySendDtmf" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendDtmf::~CSatNotifySendDtmf +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySendDtmf::~CSatNotifySendDtmf() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF, "CSatNotifySendDtmf::~CSatNotifySendDtmf" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendDtmf::MessageReceived +// Handles a SendDtmf proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendDtmf::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_MESSAGERECEIVED, "CSatNotifySendDtmf::MessageReceived" ); + TFLOGSTRING("CSatNotifySendDtmf::MessageReceived"); + // get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + iSatMessHandler->SendDtmfTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + KNoCause ); + } + else + { + TInt returnValue( KErrNone ); + TInt ret( KErrNone ); + // Fill the send ss structure + RSat::TSendDtmfV1& sendDtmfV1 = ( *iSendDtmfV1Pckg )(); + // command number + sendDtmfV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Alpha id string (optional) + sendDtmfV1.iAlphaId.iAlphaId.Zero(); + CTlv alphaIdentifier; + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ); + // if alpha id string exist + if( KErrNone == returnValue ) + { + TUint16 alphaIdLength = alphaIdentifier.GetLength(); + + if ( alphaIdLength > RSat::KAlphaIdMaxSize ) + { + // String too long + iSatMessHandler->SendDtmfTerminalResp( iTransId, + iCommandDetails, + RSat::KCmdBeyondMeCapabilities, + KNoCause ); + ret = KErrCorrupt; + } + else if ( alphaIdLength ) + { + TPtrC8 temp; // Used with Copy8to16 + // get the alpha id + temp.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + // convert and set the alpha id + TSatUtility::SetAlphaId( temp , + sendDtmfV1.iAlphaId.iAlphaId ); + + sendDtmfV1.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + sendDtmfV1.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Alpha id not present + else + { + sendDtmfV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + + // Dtmf string length, 8-bit string, mandatory + CTlv sendDtmf; + returnValue = berTlv.TlvByTagValue( &sendDtmf, + KTlvDtmfStringTag ); + if ( KErrNone == returnValue ) + { + TUint8 generalResult( RSat::KSuccess ); + // length - 1 for string + TUint16 dtmfStringLength = TUint16( sendDtmf.GetLength() ); + + //If first byte of the dtmf string is 0xFF it means that dtmf string + //is empty and we have to return general result + if ( ( dtmfStringLength && ( sendDtmf.Data()[2] == 0xFF ) ) || + !dtmfStringLength ) + { + generalResult = RSat::KCmdDataNotUnderstood; + ret = KErrCorrupt; + } + else if( RSat::KDtmfStringMaxSize < dtmfStringLength ) + { + generalResult = RSat::KCmdBeyondMeCapabilities; + ret = KErrCorrupt; + } + else + { + sendDtmfV1.iDtmfString.Append( sendDtmf.GetData( ETLV_DtmfString ) ); + } + + if( KErrCorrupt == ret ) + { + // String too long + iSatMessHandler->SendDtmfTerminalResp( iTransId, + iCommandDetails, + generalResult, + KNoCause ); + } + } + else + { + iSatMessHandler->SendDtmfTerminalResp( iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + KNoCause ); + ret = KErrCorrupt; + } + + // Iconid + if ( KErrNone == ret ) + { + TSatUtility::FillIconStructure( berTlv, + sendDtmfV1.iIconId ); + } + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendDtmf::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SendDtmf PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendDtmf::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDDTMF_NOTIFY, "CSatNotifySendDtmf::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifySendDtmf::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iSendDtmfV1Pckg = static_cast< RSat::TSendDtmfV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSendDtmf ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendDtmf::TerminalResponse +// Handles a SendDtmf terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendDtmf::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_TERMINALRESPONSE, "CSatNotifySendDtmf::TerminalResponse" ); + TFLOGSTRING("CSatNotifySendDtmf::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TSendDtmfRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TSendDtmfRspV1Pckg* >( aRsp ); + RSat::TSendDtmfRspV1& rspV1 = ( *aRspPckg ) (); + + // Check that general result values are valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + if( RSat::KMeProblem == rspV1.iInfoType ) + { + if ( rspV1.iAdditionalInfo.Length() ) + { + additionalInfo = TUint8( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + + // Creating the info message + ret = iSatMessHandler->SendDtmfTerminalResp( iTransId, iCommandDetails, + TUint8( rspV1.iGeneralResult ), additionalInfo ); + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySendSs::CSatNotifySendSs +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySendSs::CSatNotifySendSs + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSendSsV1Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CSATNOTIFYSENDSS, "CSatNotifySendSs::CSatNotifySendSs" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KModifiedByCallControl + RSat::KUssdTransactionTerminatedByUser + + RSat::KNetworkUnableToProcessCmd + + RSat::KInteractionWithCCTemporaryError + RSat::KSsReturnError + + RSat::KErrorRequiredValuesMissing + + RSat::KInteractionWithCCPermanentError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSs::~CSatNotifySendSs +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySendSs::~CSatNotifySendSs() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSS_CSATNOTIFYSENDSS, "CSatNotifySendSs::~CSatNotifySendSs" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSs::MessageReceived +// Handles a DisplayText proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendSs::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_MESSAGERECEIVED, "CSatNotifySendSs::MessageReceived" ); + TFLOGSTRING("CSatNotifySendSs::MessageReceived"); + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + TBuf8<1> noCause; + iSatMessHandler->SendSsTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + noCause ); + } + else + { + // Fill the send ss structure + RSat::TSendSsV1& sendSsV1 = ( *iSendSsV1Pckg )(); + // Store command number + sendSsV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + TPtrC8 sourceString; // Used with conversions + // Alpha id string (optional) + sendSsV1.iAlphaId.iAlphaId.Zero(); + CTlv alphaIdentifier; + // Get alpha id tlv from berTlv + TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ) ); + // if alpha id string exist + if ( KErrNone == returnValue ) + { + if ( alphaIdentifier.GetLength() ) + { + // 8-bit string to 16-bit string + sourceString.Set( + alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + + // Convert and set the alpha id + TSatUtility::SetAlphaId( + sourceString ,sendSsV1.iAlphaId.iAlphaId ); + // Set alpha id status + sendSsV1.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + sendSsV1.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Alpha id not present + else + { + sendSsV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + // SS string Tlv + sendSsV1.iSsString.iSsString.Zero(); + CTlv ssString; + // Get SS string tlv + returnValue = berTlv.TlvByTagValue( &ssString, + KTlvSsStringTag ); + if ( KErrNone == returnValue ) + { + // Initialize ton and npi + RSat::TTypeOfNumber ton; + RSat::TNumberingPlan npi; + + iSatMessaging->SetTonNpi ( ssString.GetShortInfo( ETLV_TonAndNpi ) ); + + // Call utility function that maps received TON and NPI + // to RSat values + TSatUtility::GetTonAndNpi( + ssString.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi ); + // Set TON and NPI + sendSsV1.iSsString.iTypeOfNumber = ton; + sendSsV1.iSsString.iNumberPlan = npi; + // Check length of SS string. + // BCD format = two digits "packed" in one characher + if ( ssString.GetLength() * 2 <= RSat::KStringMaxSize ) + { + TBuf8 tempString; + // Set pointer to the BCD SS string + sourceString.Set( ssString.GetData( ETLV_SsOrUssdString ) ); + // Semi-octet presentation used + // Converting back to ASCII format + TSatUtility::BCDToAscii( sourceString, tempString ); + // Set pointer to the ASCII string. + sourceString.Set( tempString ); + sendSsV1.iSsString.iSsString.Append( tempString ); + } + else + { + // SS string is too long + ret = KErrCorrupt; + } + if ( RSat::EInternationalNumber == + sendSsV1.iSsString.iTypeOfNumber ) + { + // Append '+' character if the string is for call forwarding + CheckCallForwarding( sourceString, sendSsV1.iSsString ); + } + } + else + { + // Mandatory tlv is missing, returning response immediately + TBuf8<1> noCause; + iSatMessHandler->SendSsTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details TLV + RSat::KErrorRequiredValuesMissing, // Result + noCause ); // Additional info + ret = KErrCorrupt; + CompleteRequest( ret ); + return; + } + if ( KErrCorrupt == CheckSsStringValidity( sourceString ) || + KErrCorrupt == ret ) + { + TBuf8<1> noCause; + iSatMessHandler->SendSsTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details TLV + RSat::KCmdDataNotUnderstood, // Result + noCause ); // Additional info + ret = KErrCorrupt; + } + + // Icon (optional) + TSatUtility::FillIconStructure( berTlv, sendSsV1.iIconId ); + CompleteRequest( ret ); +#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 ) + // Notify NokiaTSY that next SS request is SAT originated + if ( KErrNone == ret ) + { + TFLOGSTRING("TSY: Inform NokiaTSY SS request being SAT originated"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSS_MESSAGERECEIVED, "Inform NokiaTSY SS request being SAT originated" ); + iSatMessaging->GetMessageRouter()->ExtFuncL( + ESatNotifyCallControlRequest, + NULL ); + } +#endif + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSs::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SendSs PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendSs::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDSS_NOTIFY, "CSatNotifySendSs::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifySendSs::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iSendSsV1Pckg = static_cast< RSat::TSendSsV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSendSs ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSs::TerminalResponse +// Handles a DisplayText terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendSs::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_TERMINALRESPONSE, "CSatNotifySendSs::TerminalResponse" ); + TFLOGSTRING("CSatNotifySendSs::TerminalResponse"); + + TInt ret( KErrNone ); + + // Buffer for additional information + TBuf8 additionalInfo; + + RSat::TSendSsRspV2Pckg* aRspPckg = + reinterpret_cast( aRsp ); + RSat::TSendSsRspV2& rspV2 = ( *aRspPckg ) (); + + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + + // If no SS error, set additional info + if ( RSat::KSsReturnError != rspV2.iGeneralResult ) + { + // iAdditionalInfo is 8-bit + additionalInfo.Copy( rspV2.iAdditionalInfo ); + + if ( RSat::KSendSsInfo == rspV2.iInfoType && additionalInfo.Length() ) + { + // Remove operation code. + // SATUI appends iOperationCode to additional info. + // RMmCustomAPI::TSsAdditionalInfo iAddtionalInfo includes + // correct SS Return Result Operation code, so fisrt byte of + // additionalInfo is not needed. + additionalInfo.Delete( 0, 1 ); + } + } + else + { + // SS error code, one byte + // For the general result "SS Return Error", it is mandatory for the ME + // to provide additional information. The first byte shall be the error + // value given in the Facility (Return result) information element + // returned by the network (as defined in TS 24.080). + if ( 2 <= rspV2.iAdditionalInfo.Length() ) + { + additionalInfo.Append( rspV2.iAdditionalInfo[1] ); + } + else + { + additionalInfo.Append( 0x00 ); + } + } + + // Creating the info message + iSatMessHandler->SendSsTerminalResp( iTransId, + iCommandDetails, + TUint8( rspV2.iGeneralResult ), + additionalInfo ); + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSs::CheckCallForwarding +// Check SS string if it is for call forwarding. If it is +// append '+' character to pretending international number. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendSs::CheckCallForwarding + ( + TPtrC8 aSource, // original string + RSat::TSsString& aSsString // where to store modified string + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CHECKCALLFORWARDING, "CSatNotifySendSs::CheckCallForwarding" ); + TFLOGSTRING("CSatNotifySendSs::CheckCallForwarding"); + _LIT8(KCFU,"*21*"); // Call forwarding unconditional (CFU) + _LIT8(KCFB,"*67*"); // Call forwarding on Mobile Subscriber Busy(CFB) + _LIT8(KCFNRy, "*61*"); // Call forwarding on No Reply (CFNRy) + _LIT8(KCFNRc, "*62*"); // Call forwarding on Mobile Subscriber Not + // Reachable (CFNRc) + // Try to find call forwarding string + TInt pos( aSource.Find( KCFU ) ); + if ( KErrNotFound == pos ) + { + pos = aSource.Find( KCFB ); + } + if ( KErrNotFound == pos ) + { + pos = aSource.Find( KCFNRy ); + } + if ( KErrNotFound == pos ) + { + pos = aSource.Find( KCFNRc ); + } + if ( KErrNotFound != pos ) + { + // String is for call forwarding + aSsString.iSsString.Zero(); + aSsString.iSsString.Append( aSource.Left( pos + 4 ) ); + aSsString.iSsString.Append( KPlusMarkCharacterCode ); + aSsString.iSsString.Append( + aSource.Right( aSource.Length() - ( pos + 4) ) ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendSs::CheckSsStringValidity +// Checks validity of SS string.If string includes undefined SS +// characters or length is zero then return KErrCorrupt. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendSs::CheckSsStringValidity + ( + TPtrC8 aSsString + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CHECKSSSTRINGVALIDITY, "CSatNotifySendSs::CheckSsStringValidity" ); + TFLOGSTRING("CSatNotifySendSs::CheckSsStringValidity"); + TInt ret( KErrNone ); + if ( !aSsString.Length() ) + { + // If length is zero + ret = KErrCorrupt; + } + _LIT8( KDtmf, "p"); + _LIT8( KWild, "w"); + _LIT8( KExpansionDigit, "."); + // SS string can contain only digits, star '*' and dash '#' characters. + if ( KErrNotFound != aSsString.Find( KDtmf ) + || KErrNotFound != aSsString.Find( KWild ) + || KErrNotFound != aSsString.Find( KExpansionDigit ) ) + { + // Incompatible character found + ret = KErrCorrupt; + } + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySendUssd::CSatNotifySendUssd +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySendUssd::CSatNotifySendUssd + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSendUssdV1Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD, "CSatNotifySendUssd::CSatNotifySendUssd" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KModifiedByCallControl + RSat::KUssdTransactionTerminatedByUser + + RSat::KNetworkUnableToProcessCmd + + RSat::KInteractionWithCCTemporaryError + + RSat::KErrorRequiredValuesMissing + RSat::KUssdReturnError + + RSat::KInteractionWithCCPermanentError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendUssd::~CSatNotifySendUssd +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySendUssd::~CSatNotifySendUssd() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD, "CSatNotifySendUssd::~CSatNotifySendUssd" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendUssd::MessageReceived +// Handles a SendUssd proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendUssd::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived" ); + TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived"); + TInt ret( KErrNone ); + TInt returnValue( KErrNone ); + //get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + TUint8 noCause( 0 ); + TBuf<1> noTextString; + TUint8 paramNotSet( 0 ); + iSatMessHandler->SendUssdTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + noCause, + noTextString, + paramNotSet ); + } + else + { + // Fill the Send Ussd structure + RSat::TSendUssdV1& sendUssdV1 = ( *iSendUssdV1Pckg )(); + sendUssdV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + TPtrC8 sourceStr; // Used with Copy8to16 function + // Alpha id string (optional) + sendUssdV1.iAlphaId.iAlphaId.Zero(); + CTlv alphaIdentifier; + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ); + if ( KErrNotFound != returnValue ) + { + TUint16 alphaIdLength = alphaIdentifier.GetLength() ; + if ( RSat::KAlphaIdMaxSize < alphaIdLength ) + { + // String too long + TUint8 noCause( 0 ); + TBuf<1> noTextString; + TUint8 paramNotSet( 0 ); + iSatMessHandler->SendUssdTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + noCause, + noTextString, + paramNotSet ); + ret = KErrCorrupt; + } + else if ( alphaIdLength ) + { + // get the alpha id + sourceStr.Set( alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceStr , + sendUssdV1.iAlphaId.iAlphaId ); + } + // Check alpha id status + // Alpha Tag present + if ( sendUssdV1.iAlphaId.iAlphaId.Length() ) + { + sendUssdV1.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + sendUssdV1.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + else + { + sendUssdV1.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + // Ussd string (mandatory) + CTlv ussdTlv; + sendUssdV1.iUssdString.iUssdString.Zero(); + returnValue = berTlv.TlvByTagValue( &ussdTlv, + KTlvUssdStringTag ); + if ( KErrNone == returnValue ) + { + // Get the data coding scheme from the ISI msg + // and set the corresponding ETel Sat data field. + // The DCS is coded as for Cell Broadcast. + sendUssdV1.iUssdString.iDcs = + ussdTlv.GetShortInfo( ETLV_DataCodingScheme ); + // Decode DCS + TSmsDcs decodedDcs( ESmsUnknownOrReservedDcs ); + decodedDcs = TSatUtility::DecodeCbsDcs( sendUssdV1.iUssdString.iDcs ); + TPtrC8 ussdString = ussdTlv.GetData( ETLV_UssdString ); + TUint16 ussdStringLengthInBytes = TUint16( ussdString.Length() ); + if ( ( ( ESms16BitDcs==decodedDcs ) + && 2*RSat::KStringMaxSize emptyTextString; + TUint8 paramNotSet( 0 ); + iSatMessHandler->SendUssdTerminalResp( iTransId, + iCommandDetails, + RSat::KCmdDataNotUnderstood, + noCause, + emptyTextString, + paramNotSet ); + } + else + { + // Conversion to 16-bit following the DCS + switch ( decodedDcs ) + { + case ESms7BitDcs: + { + TBuf8 ussdString8; + TSatUtility::Packed7to8Unpacked( ussdString, + ussdString8 ); + TSatUtility::ConvertSms7ToUnicode16( + sendUssdV1.iUssdString.iUssdString, ussdString8 ); + break; + } + case ESms8BitDcs: + { + TSatUtility::ConvertSms7ToUnicode16( + sendUssdV1.iUssdString.iUssdString, ussdString ); + break; + } + case ESms16BitDcs: + { + TIsiUtility::CopyFromBigEndian( ussdString , sendUssdV1.iUssdString.iUssdString ); + break; + } + default: + { + TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \ + USSD DCS has a reserved value"); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, USSD DCS has a reserved value" ); + // the DCS has a reserved value + ret = KErrCorrupt; + TUint8 noCause( 0 ); + TBuf<1> emptyTextString; + TUint8 paramNotSet( 0 ); + iSatMessHandler->SendUssdTerminalResp( iTransId, + iCommandDetails, + RSat::KCmdDataNotUnderstood, + noCause, + emptyTextString, + paramNotSet ); + break; + } + } + } + } + else + { + TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \ + Mandatory field missing"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, Mandatory field missing" ); + // Mandatory field missing + ret = KErrCorrupt; + TUint8 noCause( 0 ); + TBuf<1> noTextString; + TUint8 paramNotSet( 0 ); + iSatMessHandler->SendUssdTerminalResp( iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + noCause, + noTextString, + paramNotSet ); + } + if ( KErrNone == ret ) + { + // Iconid + TSatUtility::FillIconStructure( berTlv, + sendUssdV1.iIconId ); + } + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendUssd::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SendUssd PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendUssd::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDUSSD_NOTIFY, "CSatNotifySendUssd::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("TSY:CSatNotifySendUssd::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iSendUssdV1Pckg = static_cast< RSat::TSendUssdV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSendUssd ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendUssd::TerminalResponse +// Handles a SendUssd terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendUssd::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse" ); + TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse"); + TInt ret( KErrNone ); + RSat::TSendUssdRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TSendUssdRspV1Pckg* >( aRsp ); + RSat::TSendUssdRspV1& rspV1 = ( *aRspPckg ) (); + TUint8 additionalInfo( 0 ); + // Check that general result values are valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // If there is Me (Mobile Entity) error, network error or text string, + // additional info is needed + if ( ( RSat::KMeProblem == rspV1.iInfoType ) + || ( RSat::KCallControlRequestedAction == rspV1.iInfoType ) + || ( RSat::KSatNetworkErrorInfo == rspV1.iInfoType ) + || ( RSat::KTextString == rspV1.iInfoType ) ) + { + // Check the length of additional info: + if ( 0 == rspV1.iAdditionalInfo.Length() ) + { + // No info + TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse, \ + AdditionalInfoType set, but no additional info available"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set, but no additional info available" ); + ret = KErrCorrupt; + } + else if ( RSat::KTextString == rspV1.iInfoType ) + { + // Text string - additional info for a + // successful GET INKEY, GET INPUT or SEND USSD. + // --> Not used by SAT Server when the command has been + // performed successfully, SAT Server uses the + // rspV1.iUssdString.iUssdString to return the USSD string + // sent by the network. + TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse, \ + AdditionalInfoType set to TextString."); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set to TextString." ); + } + else + { + // For the general result "USSD Return Error", + // the ME shall provide additional information. + // The first byte shall be the error value given in + // the Facility (Return result) information element + // returned by the network (as defined in TS 24.080 [10]). + // One further value is defined: + // - '00' = No specific cause can be given. + additionalInfo = TUint8( rspV1.iAdditionalInfo[0] ); + } + } + // Creating the info message + iSatMessHandler->SendUssdTerminalResp( iTransId, iCommandDetails, + TUint8( rspV1.iGeneralResult ), + additionalInfo, + rspV1.iUssdString.iUssdString, + rspV1.iUssdString.iDcs ); + return ret; + + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpCall::CSatNotifySetUpCall +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpCall::CSatNotifySetUpCall + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSetUpCallV1Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL, "CSatNotifySetUpCall::CSatNotifySetUpCall" ); + TFLOGSTRING( "TSY:CSatNotifySetUpCall::CSatNotifySetUpCall" ); + iCallConnectedEvent.Zero(); + + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KModifiedByCallControl + RSat::KPSessionTerminatedByUser + + RSat::KUssdTransactionTerminatedByUser + + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser + + RSat::KCallClearedBeforeConnectionOrReleased + + RSat::KInteractionWithCCTemporaryError + RSat::KSsReturnError + + RSat::KErrorRequiredValuesMissing + + RSat::KInteractionWithCCPermanentError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpCall::~CSatNotifySetUpCall +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpCall::~CSatNotifySetUpCall() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL, "CSatNotifySetUpCall::~CSatNotifySetUpCall" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpCall::MessageReceived +// Handles a SetUpCall proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpCall::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "CSatNotifySetUpCall::MessageReceived" ); + TFLOGSTRING("CSatNotifySetUpCall::MessageReceived"); + TInt ret( KErrNone ); + TInt returnValue( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + iSatMessHandler->SetUpCallTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + KNoCause ); + } + else + { + // Fill the Set Up Call structure + RSat::TSetUpCallV1& setUpCallV1 = ( *iSetUpCallV1Pckg )(); + // Store command number + setUpCallV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + switch ( iCommandDetails[KCommandQualifier] ) + { + case KOnlyIfNotBusy: + { + // Set up call, if not busy on another call + setUpCallV1.iType = RSat::EOnlyIfNotBusy; + break; + } + case KOnlyIfNotBusyWithRedial: + { + // Set up call, if not busy on another call, with redial + setUpCallV1.iType = RSat::EOnlyIfNotBusyWithRedial; + break; + } + case KHoldOtherCalls: + { + // Set up call, put other calls (if any) on hold + setUpCallV1.iType = RSat::EHoldOtherCalls; + break; + } + case KHoldOtherCallsWithRedial: + { + // Set up call, put other calls (if any) on hold, with redial + setUpCallV1.iType = RSat::EHoldOtherCallsWithRedial; + break; + } + case KDisconnectOtherCalls: + { + // Set up call, disconnect other calls (if any) + setUpCallV1.iType = RSat::EDisconnectOtherCalls; + break; + } + case KDisconnectOtherCallsWithRedial: + { + // Set up call, disconnect other calls (if any), with redial + setUpCallV1.iType = RSat::EDisconnectOtherCallsWithRedial; + break; + } + default: + { + // Call type not set + setUpCallV1.iType = RSat::ESetUpCallTypeNotSet; + break; + } + } + TPtrC8 sourceString; // Used with conversions + // Alpha id string (optional) + setUpCallV1.iAlphaIdConfirmationPhase.iAlphaId.Zero(); + // Call setup phase alphaid (optional) + setUpCallV1.iAlphaIdCallSetUpPhase.iAlphaId.Zero(); + CTlv alphaIdentifier; + // check alpha identifiers (for user confirmation phase and call set + // up phase ) + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ); + // if alpha id string exist + if ( KErrNone == returnValue ) + { + // fist alpha identifier is for user confirmation phase + if ( alphaIdentifier.GetLength() ) + { + // set status + setUpCallV1.iAlphaIdConfirmationPhase.iStatus = + RSat::EAlphaIdProvided; + + // get alpha id string + sourceString.Set( alphaIdentifier.GetData( + ETLV_AlphaIdentifier ) ); + + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceString , + setUpCallV1.iAlphaIdConfirmationPhase.iAlphaId ); + + } + // alpha id found for user confirmation phase, but length + // is zero + else + { + setUpCallV1.iAlphaIdConfirmationPhase.iStatus = + RSat::EAlphaIdNull; + } + } + // no alpha id for user confirmation phase + else + { + setUpCallV1.iAlphaIdConfirmationPhase.iStatus = + RSat::EAlphaIdNotPresent; + } + // Get alpha identifier for call set up phase + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag, 1 ); + // if alpha id string exist + if ( KErrNone == returnValue ) + { + //second alpha identifier is for call set up phase + if ( alphaIdentifier.GetLength() ) + { + // set status + setUpCallV1.iAlphaIdCallSetUpPhase.iStatus = + RSat::EAlphaIdProvided; + // get alpha id string + sourceString.Set( alphaIdentifier.GetData( + ETLV_AlphaIdentifier ) ); + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceString, + setUpCallV1.iAlphaIdCallSetUpPhase.iAlphaId ); + + } + // alpha id found for set up call phase, but length is zero + else + { + setUpCallV1.iAlphaIdCallSetUpPhase.iStatus = + RSat::EAlphaIdNull; + } + } + // no alpha id set up call phase + else + { + setUpCallV1.iAlphaIdCallSetUpPhase.iStatus = + RSat::EAlphaIdNotPresent; + } + // First icon for user confirmation phase + TSatUtility::FillIconStructure( + berTlv, setUpCallV1.iIconIdConfirmationPhase, 0 ); + // Second icon for set up call phase + TSatUtility::FillIconStructure( + berTlv, setUpCallV1.iIconIdCallSetUpPhase, 1 ); + // Expecting address + CTlv addressTlv; + returnValue = berTlv.TlvByTagValue( &addressTlv, + KTlvAddressTag ); + if ( KErrNone == returnValue && addressTlv.GetLength() ) + { + // Initialize ton and npi + RSat::TTypeOfNumber ton( RSat::EUnknownNumber ); + RSat::TNumberingPlan npi( RSat::EUnknownNumberingPlan ); + // Call utility function that maps received TON and NPI to + // RSat values + TSatUtility::GetTonAndNpi( + addressTlv.GetShortInfo( ETLV_TonAndNpi ) , &ton, &npi ); + // Set TON and NPI + setUpCallV1.iAddress.iTypeOfNumber = ton; + setUpCallV1.iAddress.iNumberPlan = npi; + // Address + setUpCallV1.iAddress.iTelNumber.Zero(); + // length is number of BCD characters, + // multiply by two to get real length and - 2 for ton&npi + TInt dialNumberLength( ( ( addressTlv.GetLength() * 2 ) - 2 ) ); + + if ( dialNumberLength ) + { + // Semi-octet presentation used + sourceString.Set( + addressTlv.GetData( ETLV_DiallingNumberString ) ); + TBuf8 tempNumber; + // Convert BCD string to ascii + TSatUtility::BCDToAscii( sourceString, tempNumber ); + sourceString.Set( tempNumber ); + //add '+' character to the preceding of international number + if ( ( setUpCallV1.iAddress.iTypeOfNumber + == RSat::EInternationalNumber ) + && (sourceString[0] != KPlusMarkCharacterCode ) + && RSat::KMaxMobileTelNumberSize > dialNumberLength ) + { + _LIT8( KPlusMark, "+"); + tempNumber.Insert( 0, KPlusMark ); + sourceString.Set( tempNumber ); + } + // The command may also include DTMF digits, which the ME shall + // send to the network after the call has connected. + // Remove expansion digits from it if present. + TSatUtility::RemoveExpansionDigit( tempNumber ); + // Set actual number + setUpCallV1.iAddress.iTelNumber.Copy( tempNumber ); + TFLOGSTRING2("TSY: SetUpCall, TelNumber: %S", + &setUpCallV1.iAddress.iTelNumber ); + OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "CSatNotifySetUpCall::MessageReceived TelNumber: %S", setUpCallV1.iAddress.iTelNumber ); + } + } + else + { + // address is missing, returning response immediately + iSatMessHandler->SetUpCallTerminalResp( iTransId, + iCommandDetails, + RSat::KCmdDataNotUnderstood, + KNoCause ); + ret = KErrCorrupt; + } + // Bearer capability + setUpCallV1.iCapabilityConfigParams.Zero(); + CTlv capabilityConfig; + returnValue = berTlv.TlvByTagValue( &capabilityConfig, + KTlvCapabilityConfigurationParametersTag ); + if ( ( KErrNone == returnValue ) + && ( capabilityConfig.GetLength() ) ) + { + // iCapabilityConfigParams is 8-bit string + setUpCallV1.iCapabilityConfigParams.Append( capabilityConfig. + GetData( ETLV_CapabilityConfigurationParameters ) ); + } + // Called Party SubAddress + setUpCallV1.iSubAddress.Zero(); + CTlv subAddress; + returnValue = berTlv.TlvByTagValue( &subAddress, KTlvSubaddressTag ); + if ( KErrNone == returnValue ) + { + if ( subAddress.GetLength() + || subAddress.GetComprehensionRequired() ) + { + TFLOGSTRING("TSY: SetUpCall, SubAddress is not supported!" ); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "SetUpCall, SubAddress is not supported!" ); + iSatMessHandler->SetUpCallTerminalResp( iTransId, + iCommandDetails, + RSat::KCmdBeyondMeCapabilities, + KNoCause ); + ret = KErrCorrupt; + } + } + + // Duration (optional, maximum duration for the redial mechanism) + TSatUtility::FillDurationStructure( + berTlv, setUpCallV1.iDuration ); + + // Set SetUpCall flag on for Call connected event. To avoid situation + // that event is send before terminal response + if ( KErrNone == ret ) + { + iSatMessaging->SetSetUpCallStatus( ETrue ); + } + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpCall::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SetUpCall PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpCall::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_NOTIFY, "CSatNotifySetUpCall::Notify" ); + TFLOGSTRING("CSatNotifySetUpCall::Notify"); + iReqHandle = aReqHandle; + iSetUpCallV1Pckg = static_cast< RSat::TSetUpCallV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSetUpCall ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpCall::TerminalResponse +// Handles a SetUpCall terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySetUpCall::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_TERMINALRESPONSE, "CSatNotifySetUpCall::TerminalResponse" ); + TFLOGSTRING("CSatNotifySetUpCall::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TSetUpCallRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TSetUpCallRspV2Pckg* >( aRsp ); + RSat::TSetUpCallRspV2& rspV2 = ( *aRspPckg ) (); + + // Check that general result values are valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + + // If there is Me (Mobile Entity) error or network error, + // additional info is needed + if ( ( RSat::KSatNetworkErrorInfo == rspV2.iInfoType ) + || ( RSat::KMeProblem == rspV2.iInfoType ) ) + { + // Check the length of additional info + if ( rspV2.iAdditionalInfo.Length() ) + { + additionalInfo = static_cast( rspV2.iAdditionalInfo[0] ); + } + else + { + // No info + ret = KErrCorrupt; + } + } + + // Creating the terminal response message + iSatMessHandler->SetUpCallTerminalResp( iTransId, + iCommandDetails, TUint8( rspV2.iGeneralResult ), additionalInfo ); + + // Clear flag + iSatMessaging->SetSetUpCallStatus( EFalse ); + + // In the case of a call initiated through a SET UP CALL proactive command + // while the call connected event is part of the current event list, the + // ME shall send both the TERMINAL RESPONSE related to the proactive + // command, and the EVENT DOWNLOAD command, in the order TERMINAL RESPONSE + // first, ENVELOPE(EVENT DOWNLOAD - call connected) second. + // Check if there is stored envelope in the buffer + if ( iCallConnectedEvent.Length() ) + { + // Send envelope.. + iSatMessHandler->UiccCatReqEnvelope( iSatMessaging->GetTransactionId(), + iCallConnectedEvent ); + // ..and clear the buffer + iCallConnectedEvent.Zero(); + } + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpCall::StoreCallConnectedEvent +// Store a Call connected envelope to buffer +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpCall::StoreCallConnectedEvent + ( + const TDesC8& aEnvelope // envelope received from CSatEventDownload + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_STORECALLCONNECTEDEVENT, "CSatNotifySetUpCall::StoreCallConnectedEvent" ); + // store it to the buffer + iCallConnectedEvent = aEnvelope; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::CSatNotifyRefresh +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyRefresh::CSatNotifyRefresh + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iRefreshV2Pckg( NULL ), + iRefreshRequiredV2Pckg( NULL ), + iReqHandleRefreshRequired( NULL ), + iInternalCache( KZero ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CSATNOTIFYREFRESH, "CSatNotifyRefresh::CSatNotifyRefresh" ); + iFileList.Zero(); + iAid.Zero(); + + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KRefreshAdditionEFRead + + RSat::KRefreshUSIMNotActive + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::~CSatNotifyRefresh +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyRefresh::~CSatNotifyRefresh() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_CSATNOTIFYREFRESH, "CSatNotifyRefresh::~CSatNotifyRefresh" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::MessageReceived +// Handles a Refresh proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyRefresh::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived" ); + TFLOGSTRING("TSY: CSatNotifyRefresh::MessageReceived"); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv. Returned to SIM card in terminal resp. + iCommandDetails.Copy( commandDetails.Data() ); + // Store Transaction id + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle || !iReqHandleRefreshRequired ) + { + TFLOGSTRING3("TSY: CSatNotifyRefresh::MessageReceived, iReqHandle:%d,\ + iReqHandleRefreshRequired:%d ", iReqHandle, iReqHandleRefreshRequired ); + OstTraceExt2( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived iReqHandle: %u, iReqHandleRefreshRequired: %u", iReqHandle, iReqHandleRefreshRequired ); + + // Some of the request were not on, returning response immediately + iSatMessHandler->RefreshTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + RSat::KMeUnableToProcessCmd, // Result + RSat::KNoSpecificMeProblem ); // Additional info + } + else + { + // Fill the refresh structure + RSat::TRefreshV2& refreshV2 = ( *iRefreshRequiredV2Pckg )(); + TInt returnValue( KErrNone ); + // Is the command valid + TInt ret( KErrNone ); + // File list + refreshV2.iFileList.Zero(); + iFileList.Zero(); + iInternalCache = 0; + + CTlv fileListTlv; + returnValue = berTlv.TlvByTagValue( &fileListTlv, + KTlvFileListTag ); + if ( KErrNone == returnValue ) + { + // Filelist found + // Check if file list really contains any files + if ( KZero < fileListTlv.GetLength() ) + { + // File list length, -1 for number of files + TUint8 fileLength( TUint8( fileListTlv.GetLength() - 1 ) ); + // Save file list with full path. + // Needed when creating a SIM_ATK_REQ isi-message + iFileList = fileListTlv.GetData( ETLV_Files ); + // Going through all files + // Received as 8-bit, append to 16-bit + TInt i( 0 ); + for ( i = 0; i < fileLength / 2; i++ ) + { + TUint16 oneItem( 0 ); + // read 16-bit + TSatUtility::GetWord( oneItem, iFileList, 2 * i ); + // File header 8-bit + TUint8 header( oneItem >> 8 ); + // The TSY needs to strip the Refresh File List + // provided by the ICC to remove the paths to the files. + //'3FXX': Master File; + //'7FXX': 1st level Dedicated File; + //'5FXX': 2nd level Dedicated File; + if ( ( KRefreshMasterFileHeader != header ) + && ( KRefresh1StLevelDedicatedFileHeader != header ) + && ( KRefresh2StLevelDedicatedFileHeader != header ) ) + { + // Append file to the file list, without path + refreshV2.iFileList.Append( oneItem ); + } + } + // Check if the file list contains the EF-SST file which is + // cached in SIM ATK TSY + if ( KErrNotFound != refreshV2.iFileList.Locate( RSat::KSstEf ) ) + { + iInternalCache |= KCacheEFSST; + } + // Check EF-CBMID + if ( KErrNotFound != refreshV2.iFileList.Locate( RSat::KCbmidEf ) ) + { + iInternalCache |= KCacheEFCBMID; + } + } + } + else if ( iCommandDetails[KCommandQualifier] == + KFileChangeNotification ) + { + // File list object is missing, return terminal resp immediately. + ret = KErrCorrupt; + iSatMessHandler->RefreshTerminalResp( iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + RSat::KNoSpecificMeProblem ); + } + else + { + TFLOGSTRING("TSY: CSatNotifyRefresh::MessageReceived, \ + Return value of file list TLV not valid."); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Return value of file list TLV not valid." ); + } + if ( KErrNone == ret ) + { + // Set refresh mode + switch ( iCommandDetails[KCommandQualifier] ) + { + case KSimInitFullFileChangeNotification: + { + TFLOGSTRING("TSY: SAT, Refresh mode: Sim init and \ + full file change notification"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and full file change notification" ); + refreshV2.iType = RSat::ESimInitFullFileChangeNotification; + iInternalCache = KCacheEFSST + KCacheEFCBMID; + break; + } + case KFileChangeNotification: + { + TFLOGSTRING("TSY: SAT, refresh mode: File Change \ + Notification"); + TFLOGSTRING2("TSY: Number of files: %d", + refreshV2.iFileList.Length() ); + + OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: File Change Notification" ); + OstTrace1( TRACE_NORMAL, DUP5_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() ); + + refreshV2.iType = RSat::EFileChangeNotification; + if ( KErrNotFound != + refreshV2.iFileList.Locate( RSat::KImsiEf ) + && !fileListTlv.GetComprehensionRequired() ) + { + // IMSI was part of file list and the CR bit was cleared + // This is done here because client does not have the CR + // bit information available, + // Other error values comes from Client + ret = KErrCorrupt; + iSatMessHandler->RefreshTerminalResp( iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + RSat::KNoSpecificMeProblem ); + } + break; + } + case KSimInitFileChangeNotification: + { + TFLOGSTRING("TSY: SAT, Refresh mode: Sim init and \ + file change notification"); + TFLOGSTRING2("TSY: Number of files: %d", + refreshV2.iFileList.Length() ); + + OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and file change notification" ); + OstTrace1( TRACE_NORMAL, DUP7_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() ); + + refreshV2.iType = RSat::ESimInitFileChangeNotification; + break; + } + case KSimInit: + { + TFLOGSTRING("TSY: SAT, Refresh mode: Sim init "); + OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init" ); + refreshV2.iType = RSat::ESimInit; + iInternalCache = KCacheEFSST + KCacheEFCBMID; + break; + } + case KSimReset: + { + refreshV2.iType = RSat::ESimReset; + TFLOGSTRING("TSY: SAT, Refresh mode: Reset"); + OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Reset" ); + iInternalCache = KCacheEFSST + KCacheEFCBMID; + break; + } + case KUSIMApplicationReset: + { + TFLOGSTRING("TSY: SAT, Refresh mode: USIM Application Reset"); + OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: USIM Application Reset" ); + refreshV2.iType = RSat::EUsimApplicationReset; + iInternalCache = KCacheEFSST + KCacheEFCBMID; + break; + } + case K3GSessionReset: + { + TFLOGSTRING("TSY: SAT, Refresh mode: 3G Session Reset"); + OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: 3G Session Reset" ); + refreshV2.iType = RSat::E3GSessionReset; + break; + } + default: + // This migth be an error case + refreshV2.iType = RSat::ERefreshTypeNotSet; + break; + } + // Application identifies(optional) + // If an AID TLV is present, it indicates the USIM application which + // needs to be refreshed. If it is not present, the ME shall assume + // the current USIM application needs to be refreshed. + CTlv applicationId; + returnValue = berTlv.TlvByTagValue( &applicationId, KTlvAIDTag ); + iAid.Zero(); + if ( KErrNone == returnValue ) + { + // Set application identifies + refreshV2.iAid = applicationId.GetData( ETLV_AID ); + // Store aplication Id to member variable. + iAid = refreshV2.iAid; + } + } + // Copy parameters + (*iRefreshV2Pckg)() = ( *iRefreshRequiredV2Pckg )(); + TTsyReqHandle tempReqHandle = iReqHandleRefreshRequired; + iReqHandleRefreshRequired = NULL; + // Ask permission from client + iSatMessaging->ReqCompleted( tempReqHandle, ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a Refresh PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyRefresh::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_NOTIFY, "CSatNotifyRefresh::Notify" ); + TFLOGSTRING("TSY: CSatNotifyRefresh::Notify"); + iReqHandle = aReqHandle; + iRefreshV2Pckg = static_cast< RSat::TRefreshV2Pckg* >( aDataPtr ); + if ( iReqHandleRefreshRequired ) + { + // Check the command buffer, if both notifications are received + iSatMessaging->SatReady( KRefresh ); + } + + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::NotifyRefreshRequired +// Notification requested by ETel server +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyRefresh::NotifyRefreshRequired + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_NOTIFYREFRESHREQUIRED, "CSatNotifyRefresh::NotifyRefreshRequired" ); + TFLOGSTRING("TSY: CSatNotifyRefresh::NotifyRefreshRequired"); + iReqHandleRefreshRequired = aReqHandle; + iRefreshRequiredV2Pckg = static_cast< RSat::TRefreshV2Pckg* >( aDataPtr ); + if ( iReqHandle ) + { + // Check the command buffer, if both notifications are received + iSatMessaging->SatReady( KRefresh ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::CancelRefreshRequiredNotification +// Cancels the current notification request +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyRefresh::CancelRefreshRequiredNotification + ( + const TTsyReqHandle aReqHandle // Request handle + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CANCELREFRESHREQUIREDNOTIFICATION, "CSatNotifyRefresh::CancelRefreshRequiredNotification" ); + TFLOGSTRING("TSY: CSatNotifyRefresh::CancelRefreshRequiredNotification"); + // Check that the handle is valid + if ( aReqHandle == iReqHandleRefreshRequired ) + { + iSatMessaging->ReqCompleted( aReqHandle, KErrCancel ); + } + else + { + // Handle is not valid + iSatMessaging->ReqCompleted( aReqHandle, KErrCorrupt ); + } + iReqHandleRefreshRequired = NULL; + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::TerminalResponse +// Handles a Refresh terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyRefresh::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse" ); + TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse"); + RSat::TRefreshRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TRefreshRspV1Pckg* >( aRsp ); + RSat::TRefreshRspV1& rspV1 = ( *aRspPckg ) (); + TUint8 additionalInfo( 0x00 ); + if ( RSat::KNoAdditionalInfo != rspV1.iInfoType ) + { + additionalInfo = TUint8( rspV1.iAdditionalInfo[0] ); + } + + // Empty TR is sent to Simson, if refresh type was Reset or IMSI was + // changed during the SIM Init refresh. Empty TR is not sent to SIM, + if ( KSimReset == iCommandDetails[KCommandQualifier] ) + { + TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse, Reset performed, send an empty TR"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse, Reset performed, send an empty TR" ); + TBuf8<1> emptyDescriptor( KNullDesC8 ); + iSatMessHandler->UiccCatReqTerminalResponse( + emptyDescriptor, emptyDescriptor, iTransId ); + } + else + { + TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse, S60 has done the Refresh" ); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse, S60 has done the Refresh" ); + // Send terminal response + iSatMessHandler->RefreshTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command number + TUint8 ( rspV1.iGeneralResult ), // Result + additionalInfo ); // Additinal info + } + + return iAllowedResults == rspV1.iGeneralResult ? KErrNone : KErrCorrupt; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::RefreshAllowed +// Response to RefreshRequired notify. Tells if the refresh is allowed by +// the Client. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyRefresh::RefreshAllowed + ( + TDesC8* aDataPtr + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_REFRESHALLOWED, "CSatNotifyRefresh::RefreshAllowed" ); + TFLOGSTRING("TSY: CSatNotifyRefresh::RefreshAllowed "); + RSat::TRefreshRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TRefreshRspV1Pckg* >( aDataPtr ); + RSat::TRefreshRspV1& rspV1 = ( *aRspPckg ) (); + if ( ( RSat::KSuccess == rspV1.iGeneralResult ) + || ( RSat::KRefreshAdditionEFRead == rspV1.iGeneralResult ) ) + { + // Refresh allowed, send refresh request to UICC + iSatMessHandler->UiccCatReqRefresh( + iSatMessaging->GetTransactionId(), + Map3GppRefreshToUiccValues( iCommandDetails[KCommandQualifier] ), + iFileList, + iAid ); + } + else + { + // Refresh not allowed by the client + TFLOGSTRING("TSY: CSatNotifyRefresh::RefreshAllowed, refresh was not \ + allowed by the client"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_REFRESHALLOWED, "CSatNotifyRefresh::RefreshAllowed, refresh was not allowed by the client" ); + TUint8 additionalInfo( 0x00 ); + if ( RSat::KNoAdditionalInfo != rspV1.iInfoType ) + { + additionalInfo = TUint8( rspV1.iAdditionalInfo[0] ); + } + // Send terminal response + iSatMessHandler->RefreshTerminalResp( iTransId, + iCommandDetails, + TUint8( rspV1.iGeneralResult ), + additionalInfo ); + } + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::Map3GppRefreshToUiccValues +// Maps 3GPP refresh values to match with UICC values. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TUint8 CSatNotifyRefresh::Map3GppRefreshToUiccValues + ( + const TUint8 a3GppRefresh // 3GPP refresh level + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_MAP3GPPREFRESHTOUICCVALUES, "CSatNotifyRefresh::Map3GppRefreshToUiccValues" ); + TFLOGSTRING("TSY: CSatNotifyRefresh::Map3GppRefreshToUiccValues "); + + TUint8 serviceType( a3GppRefresh ); + switch ( serviceType ) + { + case KSimInitFullFileChangeNotification: + { + serviceType = UICC_REFRESH_NAA_INIT_FULL_FILE_CHANGE; + break; + } + case KFileChangeNotification: + { + serviceType = UICC_REFRESH_NAA_FILE_CHANGE; + break; + } + case KSimInitFileChangeNotification: + { + serviceType = UICC_REFRESH_NAA_INIT_FILE_CHANGE; + break; + } + case KSimInit: + { + serviceType = UICC_REFRESH_NAA_INIT; + break; + } + case KSimReset: + { + serviceType = UICC_REFRESH_UICC_RESET; + break; + } + case KUSIMApplicationReset: + { + serviceType = UICC_REFRESH_NAA_APPLICATION_RESET; + break; + } + case K3GSessionReset: + { + serviceType = UICC_REFRESH_NAA_SESSION_RESET; + break; + } + default: + { + break; + } + } + return serviceType; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::CompleteRequest +// Overloads original protected CompleteRequest method from Base class. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyRefresh::CompleteRequest + ( + const TInt aError + ) + { + OstTraceExt2( TRACE_NORMAL, CSATNOTIFYREFRESH_COMPLETEREQUEST, "CSatNotifyRefresh::CompleteRequest Handle: %d, Error: %d", (TInt)iReqHandle, aError ); + TFLOGSTRING3("CSatNotifyRefresh::CompleteRequest. \n\t\t\t Handle:%d\n\t\t\t Error:%d", + iReqHandle, + aError); + TTsyReqHandle tempReqHandle = iReqHandle; + iReqHandle = NULL; + iSatMessaging->ReqCompleted( tempReqHandle, aError ); + TFLOGSTRING("CSatNotifyRefresh::CompleteRequest. Request is now completed"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_COMPLETEREQUEST, "CSatNotifyRefresh::CompleteRequest Request is now completed" ); + + } + +// ----------------------------------------------------------------------------- +// CSatNotifyRefresh::CachedFiles +// Returns list of files that are cached in SIM ATK TSY +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TUint16 CSatNotifyRefresh::CachedFiles() const + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CACHEDFILES, "CSatNotifyRefresh::CachedFiles" ); + return iInternalCache; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySimSessionEnd::CSatNotifySimSessionEnd +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySimSessionEnd::CSatNotifySimSessionEnd + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND, "CSatNotifySimSessionEnd::CSatNotifySimSessionEnd" ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND, "CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd" ); + // None + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySimSessionEnd::MessageReceived +// Handles a SimSessionEnd proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySimSessionEnd::MessageReceived + ( + const TIsiReceiveC& /*aIsiMessage*/ // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_MESSAGERECEIVED, "CSatNotifySimSessionEnd::MessageReceived" ); + TFLOGSTRING("CSatNotifySimSessionEnd::MessageReceived"); + if ( iReqHandle ) // If request on + { + CompleteRequest( KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySimSessionEnd::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SimSessionEnd PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySimSessionEnd::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* /* aDataPtr */ // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_NOTIFY, "CSatNotifySimSessionEnd::Notify" ); + TFLOGSTRING("CSatNotifySimSessionEnd::Notify"); + iReqHandle = aReqHandle; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSetUpIdleModeTextV1Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT, "CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT, "CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpIdleModeText::MessageReceived +// Handles a SetUpIdleModeText proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpIdleModeText::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED, "CSatNotifySetUpIdleModeText::MessageReceived" ); + TFLOGSTRING("CSatNotifySetUpIdleModeText::MessageReceived"); + TInt ret( KErrNone ); + TInt returnValue( KErrNone ); + //get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + iSatMessHandler->SetUpIdleModeTextTerminalResp( + iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + KNoCause ); + } + else + { + // Fill the set up idle mode text structure + RSat::TSetUpIdleModeTextV1& setUpIdleModeTextV1 + = ( *iSetUpIdleModeTextV1Pckg )(); + setUpIdleModeTextV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + //Initialize Type to notSet, coding scheme to unicode and text to zero + setUpIdleModeTextV1.iType = RSat::ESetUpIdleModeTextTypeNotSet; + setUpIdleModeTextV1.iCodingScheme = RSat::E16bitUCS2; + setUpIdleModeTextV1.iText.Zero(); + CTlv textString; + returnValue = berTlv.TlvByTagValue( &textString, + KTlvTextStringTag ); + // If the returnValue is KErrNone + if ( KErrNone == returnValue ) + { + if ( textString.GetLength() ) + { + // Convert and set text + TSatUtility::SetText( textString, setUpIdleModeTextV1.iText ); + //set type + setUpIdleModeTextV1.iType = RSat::EUpdateIdleModeText; + } + else + { + //set type + setUpIdleModeTextV1.iType = RSat::ERemoveExistingIdleModeText; + } + } + else + { + TFLOGSTRING("CSatNotifySetUpIdleModeText::MessageReceived \ + No TLV text string found"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED, "CSatNotifySetUpIdleModeText::MessageReceived No TLV text string found" ); + iSatMessHandler->SetUpIdleModeTextTerminalResp( + iTransId, + iCommandDetails, + RSat::KCmdDataNotUnderstood, + KNoCause ); + ret = KErrCorrupt; + } + // Iconid (optional) + TSatUtility::FillIconStructure( berTlv, + setUpIdleModeTextV1.iIconId ); + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpIdleModeText::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SetUpIdleModeText PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpIdleModeText::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_NOTIFY, "CSatNotifySetUpIdleModeText::Notify" ); + TFLOGSTRING("CSatNotifySetUpIdleModeText::Notify"); + iReqHandle = aReqHandle; + iSetUpIdleModeTextV1Pckg = + static_cast< RSat::TSetUpIdleModeTextV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSetUpIdleModeText ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpIdleModeText::TerminalResponse +// Handles a SetUpIdleModeText terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySetUpIdleModeText::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_TERMINALRESPONSE, "CSatNotifySetUpIdleModeText::TerminalResponse" ); + TFLOGSTRING("CSatNotifySetUpIdleModeText::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TSetUpIdleModeTextRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TSetUpIdleModeTextRspV1Pckg* >( aRsp ); + RSat::TSetUpIdleModeTextRspV1& rspV1 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // If there is Me (Mobile Equipment) error, additional info is needed + if ( ( RSat::KMeProblem == rspV1.iInfoType ) ) + { + // Check the length of additional info + if ( rspV1.iAdditionalInfo.Length() != 0 ) + { + additionalInfo = TUint8( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + // Creating the info message + iSatMessHandler->SetUpIdleModeTextTerminalResp( + iTransId, + iCommandDetails, + TUint8( rspV1.iGeneralResult ), additionalInfo ); + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyCallControlRequest::CSatNotifyCallControlRequest +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyCallControlRequest::CSatNotifyCallControlRequest + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iCallControlPckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST, "CSatNotifyCallControlRequest::CSatNotifyCallControlRequest" ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST, "CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCallControlRequest::MessageReceived +// Handles a CallControlRequest proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyCallControlRequest::MessageReceived + ( + const TIsiReceiveC& /*aIsiMessage*/ // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_MESSAGERECEIVED, "CSatNotifyCallControlRequest::MessageReceived" ); + // In S60 phones, the call control request is received via an ISI + // message coming from the ATK Guardian / Call server. That's why the body + // of this method is empty, see the class CSatCC. The Etel Sat API is used + // to pass to S60 Sat Server the alpha identifier provided by the SIM, + // if any. The SIM can provide such an alpha id to tell the user that the + // number to be called has been modified by the SIM. + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCallControlRequest::CompleteNotification +// Handles the Call Control notification received from ATK Guardian Server. +// Completes an Etel Sat API CallControlRequest pending request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyCallControlRequest::CompleteNotification + ( + TDesC& aAlphaId, + RSat::TControlResult aResult + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification" ); + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotification"); + //check that someone has requested this notifications + if ( iReqHandle ) + { + // Temporary storage for Alpha Id + RSat::TAlphaId alphaId; + // Alpha ID validity + RSat::TAlphaIdValidity validity( RSat::EValidAlpaId ); + alphaId.iStatus = RSat::EAlphaIdProvided; + alphaId.iAlphaId.Append( aAlphaId ); + // Fill the call control structure + RSat::TCallControlV5& callControl = ( *iCallControlPckg )(); + +#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 ) + if ( RSat::KSatV6 == callControl.ExtensionId() ) + { + callControl = ( RSat::TCallControlV6& )callControl; + callControl = ( *iCallControlPckg )(); + } +#endif + + // Set default control result + callControl.SetCcGeneralResult( aResult ); + callControl.SetAlphaId( validity, alphaId ); + // Complete notification + CompleteRequest( KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCallControlRequest::CompleteNotification +// Handles the Call Control GPRS notification received from ATK Guardian Server. +// Completes an Etel Sat API CallControlRequest pending request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyCallControlRequest::CompleteNotification + ( + const TDesC& aAlphaId, + const RSat::TControlResult aResult + ) + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification" ); + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotification"); + // Check that someone has requested this notifications + if ( iReqHandle ) + { + // Create the call control structure + RSat::TCallControlV5& callControl = ( *iCallControlPckg )(); + +#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 ) + // Check which version in use + if ( RSat::KSatV6 == callControl.ExtensionId() ) + { + callControl = ( RSat::TCallControlV6& )callControl; + callControl = ( *iCallControlPckg )(); + } +#endif + + // Check if the Alpha ID is present + if ( aAlphaId.Length() ) + { + // Temporary storage for Alpha Id + RSat::TAlphaId alphaId; + // Alpha ID validity + RSat::TAlphaIdValidity validity( RSat::EValidAlpaId ); + alphaId.iStatus = RSat::EAlphaIdProvided; + alphaId.iAlphaId.Append( aAlphaId ); + // Set Alpha ID data + callControl.SetAlphaId( validity, alphaId ); + } + + // The PDP Parameters need to be set even though they are not present. + // Otherwise the Call Control Type will not be set to ECcPDPParameters + // Temporary storage for PDP Context Parameters + TPdpParameters pdpParameters; + // Set empty PDP Parameters data + callControl.SetPdpParameters( pdpParameters ); + + // Set call control result + callControl.SetCcGeneralResult( aResult ); + // In Call control on GPRS, action originator is always modem + callControl.SetActionOriginator( RSat::EMeSideOriginator ); + // Complete notification + CompleteRequest( KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCallControlRequest::CompleteNotificationL +// Completes an Etel Sat API CallControlRequest pending request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyCallControlRequest::CompleteNotificationL + ( + const TUint8 aCcResult, + TPtrC8 aEnvelopeResponse + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL" ); + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL"); +#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 ) + // Check that someone has requested this notifications + if ( iReqHandle ) + { + // When this method is used V6 structure is always used. Therefore + // casting is needed. Otherwise compiler gives errors. + // Create the call control structure. + RSat::TCallControlV6& callControl = + ( *(RSat::TCallControlV6Pckg*)iCallControlPckg )(); + + switch ( aCcResult ) + { + case KAllowed: + { + callControl.SetCcGeneralResult( RSat::EAllowedNoModification ); + // Cellmo continues with original operation + callControl.SetActionOriginator( RSat::EMeSideOriginator ); + break; + } + case KRejected: + { + callControl.SetCcGeneralResult( RSat::ENotAllowed ); + // original operation is rejected + callControl.SetActionOriginator( RSat::EMeSideOriginator ); + break; + } + case KModified: + { + callControl.SetCcGeneralResult( + RSat::EAllowedWithModifications ); + // With cellmo value ATK_MODIFIED, same action is modified to + // similar action and cellmo takes care of this + callControl.SetActionOriginator( RSat::EMeSideOriginator ); + break; + } + case KChanged: + { + callControl.SetCcGeneralResult( + RSat::EAllowedWithModifications ); + // With cellmo value ATK_CHANGED, same action is modified to + // another action and client is supposed to care of next action + callControl.SetActionOriginator( RSat::EClientOriginator ); + break; + } + default: + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL\ + Not a valid call control result"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Not a valid call control result" ); + break; + } + } + TInt ret( KErrNotFound ); + // Initialize ton and npi + RSat::TTypeOfNumber ton( RSat::EUnknownNumber ); + RSat::TNumberingPlan npi( RSat::EUnknownNumberingPlan ); + // incoming ber-tlv + CBerTlv response; + response.SetData( aEnvelopeResponse ); + + CTlv ssString; + CTlv ussdTlv; + + if ( KErrNone == response.TlvByTagValue( &ssString, KTlvSsStringTag ) ) + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + Modified to SS"); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to SS" ); + // This SS related + RSat::TSsString tempSs; + // Call utility function that maps received TON and NPI + // to RSat values + TSatUtility::GetTonAndNpi( + ssString.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi ); + // Set TON and NPI + tempSs.iTypeOfNumber = ton; + tempSs.iNumberPlan = npi; + + TBuf8 tempString; + // Check length of SS string. + // BCD format = two digits "packed" in one characher + if ( ssString.GetLength() * 2 <= RSat::KStringMaxSize ) + { + // Semi-octet presentation used + // Converting back to ASCII format + TSatUtility::BCDToAscii( + ssString.GetData( ETLV_SsOrUssdString ), + tempString ); + + tempSs.iSsString.Append( tempString ); + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + SetSendSsDetails"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendSsDetails" ); + // Set SS string to struct + callControl.SetSendSsDetails( tempSs ); + // Notify NokiaTSY that next SS request is SAT originated + TFLOGSTRING("TSY: Inform NokiaTSY SS request being Call Control originated"); + OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "Inform NokiaTSY SS request being Call Control originated" ); + iSatMessaging->GetMessageRouter()->ExtFuncL( + ESatNotifyCallControlRequest, + NULL ); + } + else + { + // SS string is too long + ret = KErrCorrupt; + } + } + else if ( KErrNone == + response.TlvByTagValue( &ussdTlv, KTlvUssdStringTag ) ) + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + Modified to USSD"); + OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to USSD" ); + // This is USSD related + RSat::TUssdString tempUssd; + // Get the data coding scheme from the ISI msg + // and set the corresponding ETel Sat data field. + tempUssd.iDcs = ussdTlv.GetShortInfo( ETLV_DataCodingScheme ); + + // Check length of USSD string + if ( ussdTlv.GetLength() <= RSat::KStringMaxSize ) + { + // Client wants USSD data as received from SIM + tempUssd.iUssdString.Copy( + ussdTlv.GetData( ETLV_UssdString ) ); + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + SetSendUssdDetails"); + OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendUssdDetails" ); + callControl.SetSendUssdDetails( tempUssd ); + } + else + { + // USSD string is too long + ret = KErrCorrupt; + } + } + else + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + Modified to Call"); + OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to Call" ); + // This must be call related response + CTlv addressTlv; + + RSat::TCallSetUpParams tempCallParams; + + ret = response.TlvByTagValue( &addressTlv, KTlvAddressTag ); + if ( KErrNone == ret && addressTlv.GetLength() ) + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + Address found"); + OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Address found" ); + + // Call utility function that maps received TON and NPI to + // RSat values + TSatUtility::GetTonAndNpi( + addressTlv.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi ); + // Set TON and NPI + tempCallParams.iAddress.iTypeOfNumber = ton; + tempCallParams.iAddress.iNumberPlan = npi; + // Address + tempCallParams.iAddress.iTelNumber.Zero(); + // length is number of BCD characters, + // multiply by two to get real length and - 2 for ton&npi + TInt dialNumberLength( + ( ( addressTlv.GetLength() * 2 ) - 2 ) ); + + if ( dialNumberLength ) + { + // Semi-octet presentation used + TBuf8 tempNumber; + // Convert BCD string to ascii + TSatUtility::BCDToAscii( + addressTlv.GetData( ETLV_DiallingNumberString ), + tempNumber ); + + // add '+' character to the preceding of international + // number + if ( ( tempCallParams.iAddress.iTypeOfNumber + == RSat::EInternationalNumber ) + && ( tempNumber[ 0 ] != KPlusMarkCharacterCode ) + && RSat::KMaxMobileTelNumberSize > dialNumberLength ) + { + _LIT8( KPlusMark, "+"); + tempNumber.Insert( 0, KPlusMark ); + } + + // Set actual number + tempCallParams.iAddress.iTelNumber.Copy( tempNumber ); + } + } + // Check if Capability configuration parameters 1 are found + CTlv bcc1; + ret = response.TlvByTagValue( + &bcc1, + KTlvCapabilityConfigurationParametersTag ); + + if ( KErrNone == ret ) + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + bcc1 found"); + OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL bcc1 found" ); + // BC length is the first byte in BC data + tempCallParams.iCcp1.Copy( + bcc1.GetData( ETLV_CapabilityConfigurationParameters ) ); + } + + // Subaddress (optional) + CTlv subAddress; + ret = response.TlvByTagValue( &subAddress, KTlvSubaddressTag ); + if ( KErrNone == ret ) + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + subaddress found"); + OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL subaddress found" ); + tempCallParams.iSubAddress.Copy( + subAddress.GetData( ETLV_SubAddress ) ); + } + // Capability configuration parameters 2 + // --> BC repeat indicator is mandatory, only if BCC2 present + CTlv bcc2; + ret = response.TlvByTagValue( + &bcc2, + KTlvCapabilityConfigurationParametersTag, + 1 ); + + if ( KErrNone == ret ) + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + bcc2 found"); + OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL bcc2 found" ); + CTlv bcRepeat; + ret = response.TlvByTagValue( + &bcRepeat, + KTlvBcRepeatIndicatorTag ); + + if ( KErrNone == ret ) + { + // If bcc2 present, BC repeat indicator is mandatory + if ( ATK_CIRCULAR_REPEAT_INDICATOR == + bcRepeat.GetShortInfo( ETLV_BcRepeatIndicatorValues ) ) + { + callControl.SetBCRepeatIndicator( + RSat::EBCAlternateMode ); + } + else if ( ATK_SEQUENTIAL_REPEAT_INDICATOR == + bcRepeat.GetShortInfo( ETLV_BcRepeatIndicatorValues ) ) + { + callControl.SetBCRepeatIndicator( + RSat::EBCFallbackMode ); + } + else + { + // repeat indicator not valid + ret = KErrCorrupt; + } + // If mandatory BC repeat indicator present + if ( ret != KErrCorrupt ) + { + tempCallParams.iCcp2.Copy( + bcc2.GetData( + ETLV_CapabilityConfigurationParameters ) ); + } + } + } + // set call parameters + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + SetCallSetUpDetails"); + OstTrace0( TRACE_NORMAL, DUP12_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetCallSetUpDetails" ); + callControl.SetCallSetUpDetails( tempCallParams ); + } + // Check if alpha id present + TPtrC8 sourceString; // Used with conversions + RSat::TAlphaId tempAlphaId; + RSat::TAlphaIdValidity tempValidity( RSat::EAlphaIdValidityNotSet ); + CTlv alphaIdentifier; + // Get alpha id tlv from berTlv + ret = response.TlvByTagValue( + &alphaIdentifier, + KTlvAlphaIdentifierTag ); + // if alpha id string exist + if ( KErrNone == ret ) + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + Alpha id found"); + OstTrace0( TRACE_NORMAL, DUP13_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha id found" ); + if ( alphaIdentifier.GetLength() ) + { + // 8-bit string to 16-bit string + sourceString.Set( + alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + + // Convert and set the alpha id + TSatUtility::SetAlphaId( + sourceString, tempAlphaId.iAlphaId ); + // Set alpha id status + tempAlphaId.iStatus = RSat::EAlphaIdProvided; + tempValidity = RSat::EValidAlpaId; + } + else + { + tempAlphaId.iStatus = RSat::EAlphaIdNull; + tempValidity = RSat::ENullAlphaId; + } + } + // Alpha id not present + else + { + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + Alpha ID not present"); + OstTrace0( TRACE_NORMAL, DUP14_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha ID not present" ); + tempAlphaId.iStatus = RSat::EAlphaIdNotPresent; + tempValidity = RSat::ENoAlphaId; + } + // Set alpha id values + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + SetAlphaId"); + OstTrace0( TRACE_NORMAL, DUP15_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetAlphaId" ); + callControl.SetAlphaId( tempValidity, tempAlphaId ); + TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \ + SetCallParamOrigin"); + OstTrace0( TRACE_NORMAL, DUP18_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification SetCallParamOrigin" ); + + CompleteRequest( KErrNone ); + } +#endif + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCallControlRequest::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a CallControlRequest PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyCallControlRequest::Notify + ( + const TTsyReqHandle aReqHandle, + TDes8* aDataPtr + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_NOTIFY, "CSatNotifyCallControlRequest::Notify" ); + TFLOGSTRING("CSatNotifyCallControlRequest::Notify"); + iReqHandle = aReqHandle; + + iCallControlPckg = static_cast( aDataPtr ); + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iLaunchBrowserV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER, "CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser + + RSat::KLaunchBrowserError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER, "CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLaunchBrowser::MessageReceived +// Handles a LaunchBrowser proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyLaunchBrowser::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_MESSAGERECEIVED, "CSatNotifyLaunchBrowser::MessageReceived" ); + TFLOGSTRING("CSatNotifyLaunchBrowser::MessageReceived"); + //get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + // Get command qualifier + TUint8 cmdQualifier( commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KMeUnableToProcessCmd, + KNoCause ); + } + else if ( CSatMessHandler::ENotBusy != iSatMessHandler->SsStatus() ) + { + TUint8 additionalInfo( RSat::KMeBusyOnSs ); + if( CSatMessHandler::EUssdBusy == iSatMessHandler->SsStatus() ) + { + additionalInfo = RSat::KMeBusyOnUssd; + } + // Ss or Ussd transaction ongoing + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KMeUnableToProcessCmd, + additionalInfo ); + } + else + { + TInt ret( KErrNone ); + TInt returnValue( KErrNone ); + // Launch browser structure + RSat::TLaunchBrowserV2& launchBrowserV2 = ( *iLaunchBrowserV2Pckg )(); + launchBrowserV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber )); + switch ( cmdQualifier ) + { + case KLaunchBrowserIfNotYetLaunched: + { + launchBrowserV2.iBrowserSel = + RSat::ELaunchBrowserIfNotAlreadyLaunched; + } + break; + case KUseExistingBrowser: + { + launchBrowserV2.iBrowserSel = RSat::EUseExistingBrowser; + break; + } + case KCloseAndLaunchNewBrowser: + { + launchBrowserV2.iBrowserSel = + RSat::ECloseExistingLaunchNewBrowserSession; + break; + } + case KLaunchBrowserCmdQualifierNotUsed: + case KLaunchBrowserCmdQualifierReserved: + { + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KCmdTypeNotUnderstood, KNoCause ); + ret = KErrCorrupt; + break; + } + default: + { + launchBrowserV2.iBrowserSel = RSat::EBrowserSelectionNotSet; + break; + } + } + if ( KErrNone == ret ) + { + CTlv browserId; // optional + returnValue = berTlv.TlvByTagValue( &browserId, + KTlvBrowserIdentityTag ); + if ( KErrNotFound != returnValue ) + { + // Browser id 0x00-0x04 allowed, other values are RFU + switch ( browserId.GetShortInfo( ETLV_BrowserIdentity ) ) + { + case KDefaultBrowser: + { + launchBrowserV2.iBrowserId = RSat::EDefaultBrowser; + break; + } +#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 ) + case KWMLBrowser: + { + launchBrowserV2.iBrowserId = RSat::EWMLBrowser; + break; + } + case KHTMLBrowser: + { + launchBrowserV2.iBrowserId = RSat::EHTMLBrowser; + break; + } + case KXHTMLBrowser: + { + launchBrowserV2.iBrowserId = RSat::EXHTMLBrowser; + break; + } + case KCHTMLBrowser: + { + launchBrowserV2.iBrowserId = RSat::ECHTMLBrowser; + break; + } +#endif + default: + { + // Object present but does not identify a known + // browser ID + launchBrowserV2.iBrowserId = + RSat::EBrowserIdNotSpecified; + break; + } + } + } + else + { + launchBrowserV2.iBrowserId = RSat::EBrowserIdNotPresent; + } + } + if ( KErrNone == ret ) + { + CTlv url; // mandatory + returnValue = berTlv.TlvByTagValue( &url, KTlvUrlTag ); + if ( KErrNotFound != returnValue ) + { + if ( RSat::KUrlMaxSize < url.GetLength() ) + { + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KMeUnableToProcessCmd, KNoCause ); + ret = KErrCorrupt; + } + else + { + launchBrowserV2.iUrl.Copy( url.GetData( ETLV_Url ) ); + } + } + else + { + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KErrorRequiredValuesMissing, KNoCause ); + ret = KErrCorrupt; + } + } + if ( KErrNone == ret ) + { + CTlv provisioningFileList; // optional + returnValue = berTlv.TlvByTagValueMulti( &provisioningFileList, + KTlvProvisioningReferenceFileTag ); + TPtrC8 fileRefData = provisioningFileList.Data(); + TUint8 numberOfFileRefData( 0 ); + TInt ind( 0 ); + TInt tlvLength( 0 ); + TInt currentTlv( 0 ); + if ( KErrNotFound != returnValue ) + { + // search for number of file references + TInt i( 0 ); + for ( i = 0; i < fileRefData.Length(); i += tlvLength ) + { + //first determine if the length of the TLV is coded + // with 1 or 2 bytes. + if ( KTwoByteLengthCoding == fileRefData[ind+1] ) + { + //length is coded with 2 bytes -> 1 extra byte required + // to be + //added to total length. Also TLV header bytes (2) + // must be added + //to total length + tlvLength = fileRefData[ind+2] + KTlvHeaderLength + 1; + } + else + { + //TLV header bytes (2) must be added to total length + tlvLength = fileRefData[ind+1] + KTlvHeaderLength; + } + + currentTlv = fileRefData[ind]; + if ( KTlvProvisioningReferenceFileTag == currentTlv ) + { + numberOfFileRefData++; + } + + ind += tlvLength; + } + RSat::TProvisioningFileRef newFileRef; + // Set string length and pos + TUint8 stringLength( 0 ); + TUint pos( 2 ); + // add FileReferences to the structure launchBrowserV2 + for ( i = 0; ( i < numberOfFileRefData ) && ( KErrNone == ret ); + i++ ) + { + // Fill the newfileref + stringLength = TUint8( fileRefData[pos - 1] ); + // Test whether the text contains more than "MF" + if ( ( RSat::KFileRefMaxSize < stringLength ) + || ( 4 > stringLength ) ) + { + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KLaunchBrowserError, + RSat::KMeUnableToReadProvisioningData ); + ret = KErrCorrupt; + break; + } + newFileRef.Zero(); + TUint8 x( 0 ); + for ( x = 0; x < stringLength; x++ ) + { + newFileRef.Append( fileRefData[pos+x] ); + } + // Adding the new fileref + if ( KErrNoMemory == + launchBrowserV2.AddFileRef( newFileRef ) ) + { + // Too many or long menuitems + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KLaunchBrowserError, + RSat::KMeUnableToReadProvisioningData ); + ret = KErrCorrupt; + } + // Calculating the new position + pos = TUint( pos + fileRefData[pos - 1] + 2 ); + } + } + } + if ( KErrNone == ret ) + { + // Bearers (optional) + CTlv bearerList; + returnValue = berTlv.TlvByTagValue( &bearerList, + KTlvBearerTag ); + if ( KErrNotFound != returnValue ) + { + if ( RSat::KBearerListMaxSize >= bearerList.GetLength() ) + { + TBuf8 brList = + bearerList.GetData( ETLV_ListOfBearers ); + // SMS or USSD are not available bearers. + TInt i( 0 ); + for ( i = 0; i < brList.Length() ; i++) + { + if ( KCsdBearer == brList[i] + || KGprsBearer == brList[i] ) + { + launchBrowserV2.iBearerList.Append( brList[i] ); + } + } + if ( 0x00 == launchBrowserV2.iBearerList.Length() ) + { + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KLaunchBrowserError, + RSat::KBearerUnvailable ); + ret = KErrCorrupt; + } + } + else + { + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, iCommandDetails, + RSat::KCmdDataNotUnderstood, KNoCause ); + ret = KErrCorrupt; + } + } + } + if ( KErrNone == ret ) + { + // Text string (Gateway/Proxy) + CTlv textString; + returnValue = berTlv.TlvByTagValue( &textString, + KTlvTextStringTag ); + if ( KErrNone == returnValue ) + { + TSatUtility::SetText( textString, launchBrowserV2.iText ); + } + } + if ( KErrNone == ret ) + { + // Alpha ID string (optional) for user confirmation phase + CTlv alphaIdentifier; + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ); + launchBrowserV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + if ( KErrNotFound != returnValue ) + { + TUint8 alphaIdLength( alphaIdentifier.GetLength() ); + if ( alphaIdLength ) + { + TPtrC8 sourceString; + + // get the alpha id + sourceString.Set( + alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceString , + launchBrowserV2.iAlphaId.iAlphaId ); + + launchBrowserV2.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + launchBrowserV2.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Iconid + TSatUtility::FillIconStructure( berTlv, + launchBrowserV2.iIconId ); + CompleteRequest( ret ); + } + + } // end else + + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLaunchBrowser::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a LaunchBrowser PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyLaunchBrowser::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_NOTIFY, "CSatNotifyLaunchBrowser::Notify Handle :%u", aReqHandle ); + TFLOGSTRING2("CSatNotifyLaunchBrowser::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iLaunchBrowserV2Pckg = static_cast< RSat::TLaunchBrowserV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KLaunchBrowser ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLaunchBrowser::TerminalResponse +// Handles a LaunchBrowser terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyLaunchBrowser::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_TERMINALRESPONSE, "CSatNotifyLaunchBrowser::TerminalResponse" ); + TFLOGSTRING("CSatNotifyLaunchBrowser::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TLaunchBrowserRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TLaunchBrowserRspV2Pckg* >( aRsp ); + RSat::TLaunchBrowserRspV2& rspV2 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // Check that infotype is valid: from enum TBrowserError in etelsat.h + if ( ( RSat::KMeProblem != rspV2.iInfoType ) + && ( RSat::KNoAdditionalInfo != rspV2.iInfoType ) + && ( RSat::KBearerUnvailable != rspV2.iInfoType ) + && ( RSat::KBrowserUnavailable != rspV2.iInfoType ) + && ( RSat::KMeUnableToReadProvisioningData != rspV2.iInfoType ) + && ( RSat::KNoSpecificBrowserError != rspV2.iInfoType ) + ) + { + ret = KErrCorrupt; + } + // If there is Me (Mobile Equipment) error, additional info is needed + if ( ( RSat::KMeProblem == rspV2.iInfoType ) ) + { + // Check the length of additional info + if ( rspV2.iAdditionalInfo.Length() != 0 ) + { + additionalInfo = TUint8( rspV2.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + iSatMessHandler->LaunchBrowserTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command number + TUint8( rspV2.iGeneralResult ), // Result + additionalInfo ); // Additional info + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpEventList::CSatNotifySetUpEventList +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpEventList::CSatNotifySetUpEventList + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSetUpEventListV1Pckg( NULL ), + iCmdQualifier( KZero ), + iEvents( KZero ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST, "CSatNotifySetUpEventList::CSatNotifySetUpEventList" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpEventList::~CSatNotifySetUpEventList +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySetUpEventList::~CSatNotifySetUpEventList() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST, "CSatNotifySetUpEventList::~CSatNotifySetUpEventList" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpEventList::MessageReceived +// Handles a SetUpEventList proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpEventList::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED, "CSatNotifySetUpEventList::MessageReceived" ); + TFLOGSTRING("CSatNotifySetUpEventList::MessageReceived"); + TInt ret( KErrNone ); + TUint8 generalResult( RSat::KSuccess ); + //get ber tlv + CBerTlv berTlv; + ret = berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + generalResult = RSat::KMeUnableToProcessCmd; + } + else + { + // Let's fill the setup event list structure + RSat::TSetUpEventListV1& setUpEventListV1 = ( *iSetUpEventListV1Pckg )(); + setUpEventListV1.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + CTlv eventListTlv; + ret = berTlv.TlvByTagValue( &eventListTlv, KTlvEventListTag ); + //Initialize Type to Not set + setUpEventListV1.iType = RSat::ESetUpEventListTypeNotSet; + // If the returnValue is KErrNone + if ( KErrNone == ret ) + { + iEvents = 0; + TPtrC8 setUpEventList = eventListTlv.GetData( ETLV_EventList ); + TUint16 eventListLength = eventListTlv.GetLength(); + if ( !eventListLength ) + { + setUpEventListV1.iType = RSat::ERemoveExistingEventList; + // remove events from TSY:s list + iSatMessaging->SetUpEventList( 0 ); // no events = 0 + } + else + { + setUpEventListV1.iType = RSat::EUpdateEventList; + TInt8 i( 0 ); + TBuf8<14> eventList; + eventList.FillZ( 14 ); + for ( i = 0; i < eventListLength; i++ ) + { + if( KLocalConnection < setUpEventList[i] ) + { + //Invalid event code + generalResult = RSat::KCmdBeyondMeCapabilities; + } + else if( !eventList[setUpEventList[i]] ) + { + //Each event type shall not appear more than ones + eventList[ setUpEventList[i] ] = 0x01; + switch( setUpEventList[i] ) + { + case KMTCall: + iEvents += RSat::KMTCall; + break; + case KCallConnected: + iEvents += RSat::KCallConnected; + break; + case KCallDisconnected: + iEvents += RSat::KCallDisconnected; + break; + case KLocationStatus: + iEvents += RSat::KLocationStatus; + break; + case KUserActivity: + setUpEventListV1.iEvents + += RSat::KUserActivity; + iEvents += RSat::KUserActivity; + break; + case KIdleScreenAvailable: + setUpEventListV1.iEvents + += RSat::KIdleScreenAvailable; + iEvents += RSat::KIdleScreenAvailable; + break; + case KCardReaderStatus: + setUpEventListV1.iEvents + += RSat::KCardReaderStatus; + iEvents += RSat::KCardReaderStatus; + break; + case KLanguageSelection: + setUpEventListV1.iEvents + += RSat::KLanguageSelection; + iEvents += RSat::KLanguageSelection; + break; + case KBrowserTermination: + setUpEventListV1.iEvents + += RSat::KBrowserTermination; + iEvents += RSat::KBrowserTermination; + break; + case KDataAvailable: + setUpEventListV1.iEvents + += RSat::KDataAvailable; + iEvents += RSat::KDataAvailable; + break; + case KChannelStatus: + setUpEventListV1.iEvents + += RSat::KChannelStatus; + iEvents += RSat::KChannelStatus; + break; + case KAccessTechnologyChange: + iEvents += RSat::KAccessTechnologyChange; + break; + case KDisplayParamsChanges: + setUpEventListV1.iEvents + += RSat::KDisplayParamsChanges; + iEvents += RSat::KDisplayParamsChanges; + break; + case KLocalConnection: + setUpEventListV1.iEvents + += RSat::KLocalConnection; + iEvents += RSat::KLocalConnection; + break; + default: + break; + } + } + else + { + TFLOGSTRING("TSY: \ + CSatNotifySetUpEventList::MessageReceived, \ + Event not recognized or not supported."); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED, "CSatNotifySetUpEventList::MessageReceived, Event not recognized or not supported." ); + } + } + } + } + else + { + //Event list is missing + generalResult = RSat::KErrorRequiredValuesMissing; + } + } + if( RSat::KSuccess != generalResult ) + { + iSatMessHandler->SetUpEventListTerminalResp( + iTransId, + iCommandDetails, + generalResult, + KNoCause ); // KNoCause: 0 + } + else + { + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpEventList::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SetUpEventList PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySetUpEventList::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_NOTIFY, "CSatNotifySetUpEventList::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifySetUpEventList::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iSetUpEventListV1Pckg = static_cast< RSat::TSetUpEventListV1Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSetUpEventList ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySetUpEventList::TerminalResponse +// Handles a SetUpEventList terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySetUpEventList::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_TERMINALRESPONSE, "CSatNotifySetUpEventList::TerminalResponse" ); + TFLOGSTRING("CSatNotifySetUpEventList::TerminalResponse"); + TInt ret( KErrNone ); + TUint8 additionalInfo( 0 ); + RSat::TSetUpEventListRspV1Pckg* aRspPckg = + reinterpret_cast< RSat::TSetUpEventListRspV1Pckg* >( aRsp ); + RSat::TSetUpEventListRspV1& rspV1 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // If there is Me (Mobile Entity) error, additional info is needed + if ( ( RSat::KMeProblem == rspV1.iInfoType ) ) + { + // Check the length of additional info + if ( NULL != rspV1.iAdditionalInfo.Length() ) + { + additionalInfo = static_cast< TUint8 >( rspV1.iAdditionalInfo[0] ); + } + else + { + // Invalid additional info field + ret = KErrCorrupt; + } + } + if( RSat::KSuccess == rspV1.iGeneralResult ) + { + // set events to TSY:s list + iSatMessaging->SetUpEventList( iEvents ); + } + iSatMessHandler->SetUpEventListTerminalResp( + iTransId, + iCommandDetails, + TUint8( rspV1.iGeneralResult ), + additionalInfo ); + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyPollingOff::CSatNotifyPollingOff +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyPollingOff::CSatNotifyPollingOff + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF, "CSatNotifyPollingOff::CSatNotifyPollingOff" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPollingOff::~CSatNotifyPollingOff +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyPollingOff::~CSatNotifyPollingOff() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF, "CSatNotifyPollingOff::~CSatNotifyPollingOff" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPollingOff::MessageReceived +// Handles a PollingOff proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyPollingOff::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_MESSAGERECEIVED, "CSatNotifyPollingOff::MessageReceived" ); + TFLOGSTRING("CSatNotifyPollingOff::MessageReceived"); + //get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !( iSatMessHandler->PollingOff() ) ) + { + iSatMessHandler->SetPollingOff( ETrue ); + iSatMessHandler->SetPollingInterval( + iTransId, + KDefaultPollInterval ); + // Terminal response is sent when the response + //from SIM server is received + } + else + { + // PollingOff is already off + iSatMessHandler->PollingOffTerminalResp( + iTransId, + iCommandDetails, + RSat::KSuccess, + RSat::KNoAdditionalInfo ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyPollingOff::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a PollingOff PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyPollingOff::Notify + ( + const TTsyReqHandle /*aReqHandle*/, // Request handle + TDes8* /*aDataPtr*/ // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_NOTIFY, "CSatNotifyPollingOff::Notify" ); + // PollingOff is completely implemented by SimAtkTsy. Client + // insn't notified about the command. + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyLocalInfo::CSatNotifyLocalInfo +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyLocalInfo::CSatNotifyLocalInfo + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iLocalInfoV3Pckg( NULL ), + iLocalInfoIsOngoing( EFalse ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO, "CSatNotifyLocalInfo::CSatNotifyLocalInfo" ); + TFLOGSTRING("CSatNotifyLocalInfo::CSatNotifyLocalInfo"); + // Initialize response structure + iLocalInfoRspV3 = RSat::TLocalInfoRspV3(); + + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessLimitedService + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLocalInfo::~CSatNotifyLocalInfo +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyLocalInfo::~CSatNotifyLocalInfo() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO, "CSatNotifyLocalInfo::~CSatNotifyLocalInfo" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLocalInfo::MessageReceived +// Handles a LocalInfo proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyLocalInfo::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived" ); + TFLOGSTRING("CSatNotifyLocalInfo::MessageReceived"); + // Clear additional info + iLocalInfoRspV3.iAdditionalInfo.Zero(); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details tlv + iCommandDetails.Copy( commandDetails.Data() ); + // Trans id + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + switch ( iCommandDetails[KCommandQualifier] ) + { + case RSat::KProvideLocalInfo: + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: LOCAL INFO"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived Request: LOCAL INFO" ); + iLocalInfoIsOngoing = ETrue; + + // Send a net cell info request to the net server. + // Use same transaction id what comes with proactive + // command and compare that when response is received + iSatMessHandler->NetCellInfoGetReq( iTransId ); + + break; + } + case RSat::KProvideLocalInfoImei: + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: IMEI"); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived Request: IMEI" ); + // Check if IMEI is received + if ( iSatMessHandler->ImeiAvailable() ) + { + // IMEI is received from info server + iLocalInfoRspV3.iGeneralResult = RSat::KSuccess; + } + else + { + // No IMEI available at the moment + iLocalInfoRspV3.iGeneralResult = + RSat::KMeUnableToProcessCmd; + iLocalInfoRspV3.iAdditionalInfo.Append( + KNoSpecificCauseCanBeGiven ); + } + break; + } + case RSat::KProvideLocalInformationNmr: + { + // Check if UTRAN Measurement Qualifier TLV is present + CTlv utranMeasurement; + if ( KErrNone == berTlv.TlvByTagValue( &utranMeasurement, + KTlvUtranMeasurementQualifierTag ) ) + { + // ME has to be connected to GERAN if UTRAN NMR's are requested + if ( KNetworkModeUtran == + iSatMessHandler->CurrentAccessTechnology() ) + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: UTRAN NMR"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived UTRAN NMR" ); + + switch( utranMeasurement.GetShortInfo( + ETLV_UtranMeasurementQualifier ) ) + { + case KIntraFrequencyMeasurements: + { + iLocalInfoIsOngoing = ETrue; + TFLOGSTRING("CSatNotifyLocalInfo::INTRA_FREQ_NMR"); + OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived INTRA_FREQ_NMR" ); + iSatMessHandler->NetNeighbourCellsReq( + iSatMessaging->GetTransactionId(), + NET_SIM_INTRA_FREQ_NMR ); + break; + } + case KInterFrequencyMeasurements: + { + iLocalInfoIsOngoing = ETrue; + TFLOGSTRING("CSatNotifyLocalInfo::INTER_FREQ_NMR"); + OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived INTER_FREQ_NMR" ); + iSatMessHandler->NetNeighbourCellsReq( + iSatMessaging->GetTransactionId(), + NET_SIM_INTER_FREQ_NMR ); + break; + } + case KInterRatMeasurements: + { + iLocalInfoIsOngoing = ETrue; + TFLOGSTRING("CSatNotifyLocalInfo::INTER_RAT_NMR"); + OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived INTER_RAT_NMR" ); + iSatMessHandler->NetNeighbourCellsReq( + iSatMessaging->GetTransactionId(), + NET_SIM_INTER_RAT_NMR ); + break; + } + default: + { + iLocalInfoRspV3.iGeneralResult = + RSat::KCmdDataNotUnderstood; + TerminalResponse(); + break; + } + } + } + else + { + // ME connected to GSM, cannot serve the requested command + iLocalInfoRspV3.iGeneralResult = + RSat::KMeUnableToProcessCmd; + iLocalInfoRspV3.iAdditionalInfo.Append( KNoService ); + TerminalResponse(); + } + } + else + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: NMR"); + OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: NMR" ); + iLocalInfoIsOngoing = ETrue; + // Request NET_SIM_NMR + iSatMessHandler->NetNeighbourCellsReq( + iSatMessaging->GetTransactionId(), + NET_SIM_NMR ); + } + + break; + } + case RSat::KProvideLocalInfoDateTimeTimeZone: + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: DATE/TIME/TIMEZONE"); + OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: DATE/TIME/TIMEZONE" ); + TTime time; + TLocale locale; + TDateTime dateTime; + // Get Universal time + time.UniversalTime(); + // Get Universal time offset ( Time zone in seconds ) + TTimeIntervalSeconds universalTimeOffset( + locale.UniversalTimeOffset() ); + // Add locale's universal time offset to universal time + // to get the local time + time += universalTimeOffset; + // Converts a TTime object into a TDateTime object + dateTime = time.DateTime(); + // Get and conver year + TUint8 temp2( TSatUtility::ConvertToSemiOctet( + dateTime.Year() ) ); + // Append year to additional info + iLocalInfoRspV3.iAdditionalInfo.Append( temp2 ); + // Convert month + // Offset from zero. So adding one. + temp2 = TSatUtility::ConvertToSemiOctet( + dateTime.Month() + 1 ); + // Append month value to the additional info + iLocalInfoRspV3.iAdditionalInfo.Append( temp2 ); + // Convert day to the semi-octec presentation + // The day.Offset from zero, so add one before displaying + // the day number. + temp2 = TSatUtility::ConvertToSemiOctet( + dateTime.Day() + 1 ); + // Append the day value to the additional info + iLocalInfoRspV3.iAdditionalInfo.Append( temp2 ); + // Conver current time to the semi-octec presentation. + // First hour + temp2 = TSatUtility::ConvertToSemiOctet( + dateTime.Hour() ); + // Append the hour value to the additional info + iLocalInfoRspV3.iAdditionalInfo.Append( temp2 ); + // Minute value + temp2 = TSatUtility::ConvertToSemiOctet( + dateTime.Minute() ); + // Append the minute value to the additional info + iLocalInfoRspV3.iAdditionalInfo.Append( temp2 ); + // Seconds + temp2 = TSatUtility::ConvertToSemiOctet( + dateTime.Second() ); + // Append the seconds value to the additional info + iLocalInfoRspV3.iAdditionalInfo.Append( temp2 ); + // Append time zone + // received from NET_TIME_IND isi-message + iLocalInfoRspV3.iAdditionalInfo.Append( + iSatMessHandler->TimeZone() ); + // Set generall result as Success + iLocalInfoRspV3.iGeneralResult = RSat::KSuccess; + break; + } + case RSat::KProvideLocalInfoLanguage: + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: Language"); + OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: Language" ); + if( !iReqHandle ) + { + TFLOGSTRING("CSatNotifyLocalInfo:: No reqHandle"); + OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived No reqHandle" ); + + iLocalInfoRspV3.iGeneralResult = RSat::KMeUnableToProcessCmd; + iLocalInfoRspV3.iAdditionalInfo.Append( RSat::KNoSpecificMeProblem ); + TerminalResponse(); + } + else + { + TFLOGSTRING("CSatNotifyLocalInfo:: reqHandle"); + OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived reqHandle" ); + // Fill the send sm structure + RSat::TLocalInfoV3& localInfoV3 = ( *iLocalInfoV3Pckg )(); + // Get command details tlv + CTlv deviceIdentities; + berTlv.TlvByTagValue( &deviceIdentities, KTlvDeviceIdentityTag ); + localInfoV3.iDevideId = ( RSat::TDeviceId ) + deviceIdentities.GetShortInfo( ETLV_SourceDeviceIdentity ); + localInfoV3.iInfoType = + ( RSat::TLocaInfomationType) iCommandDetails[KCommandQualifier]; + localInfoV3.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + CompleteRequest( KErrNone ); + } + break; + } + case RSat::KProvideLocalInfoTimingAdv: + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: TimingAdvance"); + OstTrace0( TRACE_NORMAL, DUP12_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: TimingAdvance" ); + iLocalInfoIsOngoing = ETrue; + //request GSS_CS_SERVICE_REQ + iSatMessHandler->GssCsServiceReq( + iSatMessaging->GetTransactionId(), + GSS_ATK_TIMING_ADVANCE_GET ); + break; + } + case RSat::KProvideLocalInfoAccTech: + { + TFLOGSTRING("CSatNotifyLocalInfo:: request: Access Technology"); + OstTrace0( TRACE_NORMAL, DUP13_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: Access Technology" ); + iLocalInfoIsOngoing = ETrue; + //request NET_RAT_REQ + iSatMessHandler->NetRatReq( iSatMessaging->GetTransactionId() ); + break; + } + // Currently not supported: + case RSat::KProvideLocalInfoESN: + { + iLocalInfoRspV3.iGeneralResult = + RSat::KCmdBeyondMeCapabilities; + break; + } + default: + { + iLocalInfoRspV3.iGeneralResult = RSat::KCmdTypeNotUnderstood; + } + } + if ( RSat::KProvideLocalInformationNmr != + iCommandDetails[KCommandQualifier] + && RSat::KProvideLocalInfo != iCommandDetails[KCommandQualifier] + && RSat::KProvideLocalInfoTimingAdv != iCommandDetails[KCommandQualifier] + && RSat::KProvideLocalInfoLanguage != iCommandDetails[KCommandQualifier] + && RSat::KProvideLocalInfoAccTech != iCommandDetails[KCommandQualifier] ) + { + // Send terminal response to the sim + TerminalResponse(); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLocalInfo::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a LocalInfo PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyLocalInfo::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYLOCALINFO_NOTIFY, "CSatNotifyLocalInfo::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifyLocalInfo::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iLocalInfoV3Pckg = static_cast< RSat::TLocalInfoV3Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KProvideLocalInformation ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLocalInfo::TerminalResponse +// Handles a LocalInfo terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyLocalInfo::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_TERMINALRESPONSE, "CSatNotifyLocalInfo::TerminalResponse" ); + TFLOGSTRING("CSatNotifyLocalInfo::TerminalResponse"); + TInt ret( KErrNone ); + if ( aRsp ) + { + RSat::TLocalInfoRspV3Pckg* aRspPckg = + reinterpret_cast< RSat::TLocalInfoRspV3Pckg* >( aRsp ); + RSat::TLocalInfoRspV3& rspV1 = ( *aRspPckg ) (); + // Check that general result value is valid. + if ( iAllowedResults != rspV1.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + iLocalInfoRspV3.iGeneralResult = rspV1.iGeneralResult; + // If there is Me (Mobile Entity) error, additional info is needed + if ( RSat::KMeProblem == rspV1.iInfoType && + NULL == rspV1.iAdditionalInfo.Length() ) + { + // Invalid additional info field + ret = KErrCorrupt; + } + iLocalInfoRspV3.iAdditionalInfo = rspV1.iAdditionalInfo; + } + iSatMessHandler->LocalInfoTerminalResp( + iTransId, // Transaction id + iCommandDetails, // Command details tlv + TUint8( iLocalInfoRspV3.iGeneralResult ), // Result + iLocalInfoRspV3.iAdditionalInfo ); // Additional info + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLocalInfo::Status +// Method to check and set local info status. This is used when +// SIM request NMR or Local Info. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool CSatNotifyLocalInfo::Status + ( + TBool aClearStatus + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_STATUS, "CSatNotifyLocalInfo::Status" ); + TFLOGSTRING("CSatNotifyLocalInfo::Status"); + if ( aClearStatus ) + { + iLocalInfoIsOngoing = EFalse; + } + return iLocalInfoIsOngoing; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyTimerMgmt::CSatNotifyTimerMgmt +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyTimerMgmt::CSatNotifyTimerMgmt + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iCmdQualifier( KZero ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT, "CSatNotifyTimerMgmt::CSatNotifyTimerMgmt" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KContradictionWithTimerState + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT, "CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyTimerMgmt::MessageReceived +// Handles a TimerMgmt proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyTimerMgmt::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_MESSAGERECEIVED, "CSatNotifyTimerMgmt::MessageReceived" ); + TFLOGSTRING("CSatNotifyTimerMgmt::MessageReceived"); + TInt ret( KErrNone ); + TInt returnValue( KErrNone ); + TUint8 generalResult ( RSat::KSuccess ); + //get ber tlv + CBerTlv berTlv; + returnValue = berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + // Get command qualifier + TUint8 cmdQualifier( + commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + // get timer id tlv + CTlv timerId; + returnValue = berTlv.TlvByTagValue( &timerId, + KTlvTimerIdentifierTag ); + // initalize + TUint8 timerIdentifier( 0 ); + TUint8 time[3] = {0, 0, 0}; + if ( KErrNone == returnValue ) + { + timerIdentifier = timerId.GetShortInfo( ETLV_TimerIdentifier ); + // The Timer Identifier can take 8 different values + if ( ( RSat::KTimer8 < timerIdentifier ) + || ( RSat::KTimer1 > timerIdentifier ) ) + { + generalResult = RSat::KCmdDataNotUnderstood; + } + else + { + // if operation type is startTimer = 0x00 + if ( !cmdQualifier ) + { + //get timer value tlv + CTlv timerValue; + returnValue = berTlv.TlvByTagValue( &timerValue, + KTlvTimerValueTag ); + if ( KErrNotFound != returnValue) + { + TPtrC8 temp; + TUint32 timeValue( 0 ); + // value of a timer, expressed using + // the format hour, minute, second + // Semi-octec presentation used (23.040) + temp.Set( timerValue.GetData( ETLV_TimerValue ) ); + //convert to seconds + timeValue = ConvertToSeconds( temp ); + // The possible duration of a timer is + // between 1 second and 24 hours + if ( KMinTimerValue < timeValue && + KMaxTimerValueInSeconds >= timeValue ) + { + ret = iSatMessaging->GetSatTimer()-> + StartTimer( timerIdentifier, timeValue ); + if ( KErrNone != ret ) + { + generalResult = RSat::KMeUnableToProcessCmd; + } + } + else + { + generalResult = RSat::KCmdDataNotUnderstood; + } + } + else + { + generalResult = RSat::KErrorRequiredValuesMissing; + } + } + // if operation type is KDeactivateTimer or KGetTimerValue + else if ( KDeactivateTimer == cmdQualifier || + KGetTimerValue == cmdQualifier ) + { + TInt retValue( KErrNone ); + //get current value of the timer + ret = iSatMessaging->GetSatTimer()-> + GetCurrentValueOfTimerById( timerIdentifier ); + if ( KDeactivateTimer == cmdQualifier && KErrNotFound != ret ) + { + //deactivate timer + retValue = iSatMessaging->GetSatTimer()-> + DeleteTimerById( timerIdentifier ); + } + //if timer is found convert timer value to semi-octets + if ( KErrNotFound != ret && KErrNotFound != retValue ) + { + generalResult = RSat::KSuccess; + TInt num[3]; + num[0] = ret/3600; //hours + num[1] = ( ret%3600 )/60; //minutes + num[2] = ( ret%3600 )%60; //seconds + TInt i( 0 ); + for ( i = 0; i < 3; i++ ) + { + //convert to semi-octet + time[i] = TSatUtility::ConvertToSemiOctet( num[i] ); + } + } + else + { + generalResult = RSat::KContradictionWithTimerState; + } + } + else + { + generalResult = RSat::KCmdTypeNotUnderstood; + } + } + } + else + { + generalResult = RSat::KErrorRequiredValuesMissing; + } + iSatMessHandler->TimerMgmtTerminalResp( aIsiMessage.Get8bit( + ISI_HEADER_OFFSET_TRANSID ), iCommandDetails, generalResult, + time, timerIdentifier, KNoCause ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyTimerMgmt::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a TimerManagement PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyTimerMgmt::Notify + ( + const TTsyReqHandle /*aReqHandle*/, // Request handle + TDes8* /*aDataPtr*/ // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_NOTIFY, "CSatNotifyTimerMgmt::Notify" ); + // TimerManagement is completely implemented by SimAtkTsy. Client + // insn't notified about the command. + } + +// ----------------------------------------------------------------------------- +// CSatNotifyTimerMgmt::ConvertToSeconds +// Converts to seconds semi-octet presented value of timer, +// expressed using the format hour, minute, second +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TUint32 CSatNotifyTimerMgmt::ConvertToSeconds + ( + TPtrC8 time + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_CONVERTTOSECONDS, "CSatNotifyTimerMgmt::ConvertToSeconds" ); + TFLOGSTRING("CSatNotifyTimerMgmt::ConvertToSeconds"); + TUint32 timeValue( 0 ); + // value of a timer, expressed using + // the format hour, minute, second + // Semi-octec presentation used (23.040) + // time[0] is hours + // time[1] is minutes + // time[2] is seconds + TInt i( 0 ); + for ( i = 0; i < 3; i++ ) + { + TUint value = ( time[i] & 0x0F )*10 + ( ( time[i] & 0xF0 ) >> 4 ); + timeValue = timeValue * 60 + value; + } + return timeValue; + + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyMoreTime::CSatNotifyMoreTime +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyMoreTime::CSatNotifyMoreTime + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_CSATNOTIFYMORETIME, "CSatNotifyMoreTime::CSatNotifyMoreTime" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyMoreTime::~CSatNotifyMoreTime +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyMoreTime::~CSatNotifyMoreTime() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYMORETIME_CSATNOTIFYMORETIME, "CSatNotifyMoreTime::~CSatNotifyMoreTime" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyMoreTime::MessageReceived +// Handles a MoreTime proactive command ISI message, +// Etel SAT request not required. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyMoreTime::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_MESSAGERECEIVED, "CSatNotifyMoreTime::MessageReceived" ); + TFLOGSTRING("CSatNotifyMoreTime::MessageReceived"); + //get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + //get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iSatMessHandler->MoreTimeTerminalResp( + aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ), + iCommandDetails, + RSat::KSuccess ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyMoreTime::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a MoreTime PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyMoreTime::Notify + ( + const TTsyReqHandle /*aReqHandle*/, // Request handle + TDes8* /*aDataPtr*/ // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_NOTIFY, "CSatNotifyMoreTime::Notify" ); + // MoreTime is completely implemented by SimAtkTsy. Client + // insn't notified about the command. + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyLanguageNotification::CSatNotifyLanguageNotification +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyLanguageNotification::CSatNotifyLanguageNotification + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iLanguageNotificationV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION, "CSatNotifyLanguageNotification::CSatNotifyLanguageNotification" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION, "CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLanguageNotification::MessageReceived +// Handles a LanguageNotification proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyLanguageNotification::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED, "CSatNotifyLanguageNotification::MessageReceived" ); + TFLOGSTRING("TSY: CSatNotifyLanguageNotification::MessageReceived"); + TInt ret( KErrNone ); + TInt returnValue( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + returnValue = berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if( !iReqHandle ) + { + iSatMessHandler->LanguageNotificationTerminalResp( + iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + KNoCause ); // KNoCause: 0 + } + else + { + + RSat::TLanguageNotificationV2& languageNotificationV2 = + ( *iLanguageNotificationV2Pckg )(); + // Command number + languageNotificationV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Initialisate + languageNotificationV2.iNotificationType = RSat::ENotificationTypeNotSet; + // Get command qualifier + TUint8 cmdQualifier( + commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + if ( !cmdQualifier ) + { + // No specific language used + languageNotificationV2.iNotificationType = + RSat::ENonSpecificLangNotification; + } + else if ( KSpecificLanguage == cmdQualifier ) + { + // Currently used language + languageNotificationV2.iNotificationType = + RSat::ESpecificLangNotification; + } + else + { + TFLOGSTRING("TSY: \ + CSatNotifyLanguageNotification::MessageReceived, \ + Command qualifier did not match."); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED, "CSatNotifyLanguageNotification::MessageReceived, Command qualifier did not match." ); + } + CTlv language; + returnValue = berTlv.TlvByTagValue( &language, + KTlvLanguageTag ); + // If the Language tag is found + if ( KErrNone == returnValue ) + { + languageNotificationV2.iLanguage = language.GetLongInfo( ETLV_Language ); + } + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLanguageNotification::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a LanguageNotification PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyLanguageNotification::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_NOTIFY, "CSatNotifyLanguageNotification::Notify" ); + TFLOGSTRING("CSatNotifyLanguageNotification::Notify"); + iReqHandle = aReqHandle; + iLanguageNotificationV2Pckg = + static_cast< RSat::TLanguageNotificationV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KLanguageNotification ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyLanguageNotification::TerminalResponse +// Handles a LanguageNotification terminal response provided by an ETel SAT +// client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyLanguageNotification::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_TERMINALRESPONSE, "CSatNotifyLanguageNotification::TerminalResponse" ); + TFLOGSTRING("CSatNotifyLanguageNotification::TerminalResponse"); + TUint8 additionalInfo( 0 ); + RSat::TLanguageNotificationRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TLanguageNotificationRspV2Pckg* >( aRsp ); + RSat::TLanguageNotificationRspV2& rspV1 = ( *aRspPckg ) (); + iSatMessHandler->LanguageNotificationTerminalResp( + iTransId, + iCommandDetails, + rspV1.iGeneralResult, + additionalInfo ); + + return iAllowedResults == rspV1.iGeneralResult ? KErrNone : KErrCorrupt; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::CSatNotifyOpenChannel +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyOpenChannel::CSatNotifyOpenChannel + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iOpenBaseChannelV2Pckg( NULL ), + iOpenCsChannelV2Pckg( NULL ), + iOpenGprsChannelV4Pckg( NULL ), + iOpenLocalLinksChannelV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL, "CSatNotifyOpenChannel::CSatNotifyOpenChannel" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPerformedWithModifications+ RSat::KPSessionTerminatedByUser + + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser + + RSat::KInteractionWithCCTemporaryError + + RSat::KErrorRequiredValuesMissing + RSat::KBearerIndepProtocolError + + RSat::KAccessTechUnableProcessCmd; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::~CSatNotifyOpenChannel +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyOpenChannel::~CSatNotifyOpenChannel() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL, "CSatNotifyOpenChannel::~CSatNotifyOpenChannel" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::MessageReceived +// Handles a OpenChannel proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyOpenChannel::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived" ); + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived"); + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Request Off"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Request Off" ); + // Request not on, returning response immediately + TBuf8<1> noBearer( 0 ); + TBuf8<1> noAdditionalInfo( 0 ); + TUint16 noBufferSize( 0 ); + iSatMessHandler->OpenChannelTerminalResp( + iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + noAdditionalInfo, + TUint8( RSat::EBearerTypeNotSet ), + noBearer, + noBufferSize ); + ret = KErrCorrupt; + } + else + { + RSat::TOpenChannelBaseV2& openChannelV2 + = ( *iOpenBaseChannelV2Pckg ) (); + + // Bearer Description & Buffer Size ( Mandatory ) + CTlv bearerDescriptionTlv; + CTlv bufferSizeTlv; + + if ( KErrNone == berTlv.TlvByTagValue( &bearerDescriptionTlv, + KTlvBearerDescriptionTag ) + && KErrNone == berTlv.TlvByTagValue( &bufferSizeTlv, + KTlvBufferSizeTag ) ) + { + // Command details + openChannelV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + + // Link Establishment, obtained + // from Command details Bit 1 + // Get command qualifier + TUint8 cmdQualifier( commandDetails.GetShortInfo( + ETLV_CommandQualifier ) ); + if ( KLinkEstablishmentMask & cmdQualifier ) + { + openChannelV2.iLinkEst = RSat::EImmediate; + } + else + { + openChannelV2.iLinkEst = RSat::EOnDemand; + } + + // Reconnection mode, obtained from Command + // details Bit 2 + if ( KReconnectionModeMask & cmdQualifier ) + { + openChannelV2.iReconnectionMode = + RSat::EAutomaticReconnection; + } + else + { + openChannelV2.iReconnectionMode = + RSat::ENoAutomaticReconnection; + } + + // Buffer size + openChannelV2.iBufferSize = bufferSizeTlv.GetLongInfo( + ETLV_BufferSize ); + + // Handling of + // Bearer type + // Bearer parameters + GetBearerTypeAndParams( bearerDescriptionTlv, + openChannelV2.iBearer ); + + // Alpha Identifier ( Optional ) + TPtrC8 sourceString; // Used with conversions + CTlv alphaIdentifierTlv; + // Get Alpha Identifier tlv from berTlv + TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifierTlv, + KTlvAlphaIdentifierTag ) ); + // If Alpha Identifier string exist + if ( KErrNone == returnValue ) + { + if ( alphaIdentifierTlv.GetLength() ) + { + // 8-bit string to 16-bit string + sourceString.Set( + alphaIdentifierTlv.GetData( ETLV_AlphaIdentifier ) ); + // Convert and set the Alpha Identifier + TSatUtility::SetAlphaId( + sourceString, openChannelV2.iAlphaId.iAlphaId ); + // Set Alpha Identifier status + openChannelV2.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + openChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Alpha Identifier not present + else + { + openChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + } + + // Icon Identifier ( optional ) + TSatUtility::FillIconStructure( berTlv, + openChannelV2.iIconId ); + + // Handling of + // SIM/ME interface transport level ( Optional ) + // Other Address - Set Destination Address + TInt retValueLocalAdd = SimMeInterfaceAndDataDestinationAddress( + berTlv, + openChannelV2.iSimMeInterface, + openChannelV2.iDestinationAddress ); + + // Switch according to bearer type + // + switch ( openChannelV2.iBearer.iType ) + { + case RSat::EGPRSBearer: + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - GPRS Bearer"); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - GPRS Bearer" ); + // Fill in TOpenGprsChannelV4 + RSat::TOpenGprsChannelV4& openGprsChannelV4 + = ( *iOpenGprsChannelV4Pckg )(); + openGprsChannelV4 + = static_cast( openChannelV2 ); + openGprsChannelV4.iPCmdType = RSat::EGprsBearer; + + // Handling of + // Other Address - Local Address ( Optional ) + if ( KErrNone == retValueLocalAdd ) + { + LocalAddress( berTlv, openGprsChannelV4.iLocalAddress ); + } + else + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived -\ + Local Adress - not present"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Local Adress - not present" ); + openGprsChannelV4.iLocalAddress.iType = + RSat::EAddressNotPresent; + } + + // Handling GPRS bearer specific data + // + // Network Access Point Name ( Optional ) + // Text string - User Login ( Optional ) + // Text string - User Password ( Optional ) + GprsBearerSpecific( berTlv, openGprsChannelV4 ); + break; + } + case RSat::EDefaultBearer: + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Default Bearer"); + OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Default Bearer" ); + // Fill in TOpenChannelBaseV2 + openChannelV2.iPCmdType = RSat::EAnyBearer; + break; + } + case RSat::ECSDBearer: + case RSat::EBTBearer: + case RSat::EIrDaBearer: + case RSat::ERS232Bearer: + case RSat::EUSBBearer: + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Bearer not supported"); + OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" ); + // Bearer not supported + TBuf8<1> noAdditionalInfo( 0 ); + iSatMessHandler->OpenChannelTerminalResp( + iTransId, + iCommandDetails, + RSat::KCmdBeyondMeCapabilities, + noAdditionalInfo, + openChannelV2.iBearer.iType, + openChannelV2.iBearer.iParams, + openChannelV2.iBufferSize ); + ret = KErrCorrupt; + break; + } + default: + { + // Bearer not supported (RFU) + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Bearer not supported"); + OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" ); + // Required values missing + TBuf8<1> noBearer( 0 ); + TBuf8<1> noAdditionalInfo( 0 ); + TUint16 noBufferSize( 0 ); + iSatMessHandler->OpenChannelTerminalResp( + iTransId, + iCommandDetails, + RSat::KCmdDataNotUnderstood, + noAdditionalInfo, + TUint8( RSat::EBearerTypeNotSet ), + noBearer, + noBufferSize ); + ret = KErrCorrupt; + break; + } + } // End of switch according to bearer type + } + else + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Required values missing"); + OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Required values missing" ); + // Required values missing + TBuf8<1> noBearer( 0 ); + TBuf8<1> noAdditionalInfo( 0 ); + TUint16 noBufferSize( 0 ); + iSatMessHandler->OpenChannelTerminalResp( + iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + noAdditionalInfo, + TUint8( RSat::EBearerTypeNotSet ), + noBearer, + noBufferSize ); + ret = KErrCorrupt; + } // End of Bearer Description & Buffer Size ( Mandatory ) + + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a OpenChannel PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyOpenChannel::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_NOTIFY, "CSatNotifyOpenChannel::Notify" ); + TFLOGSTRING("CSatNotifyOpenChannel::Notify"); + iReqHandle = aReqHandle; + iOpenBaseChannelV2Pckg = + static_cast< RSat::TOpenChannelBaseV2Pckg* >( aDataPtr ); + iOpenCsChannelV2Pckg = + static_cast< RSat::TOpenCsChannelV2Pckg* >( aDataPtr ); + iOpenGprsChannelV4Pckg = + static_cast< RSat::TOpenGprsChannelV4Pckg* >( aDataPtr ); + iOpenLocalLinksChannelV2Pckg = + static_cast< RSat::TOpenLocalLinksChannelV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KOpenChannel ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::TerminalResponse +// Handles a OpenChannel terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyOpenChannel::TerminalResponse + ( + TDes8* aRsp // Response + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_TERMINALRESPONSE, "CSatNotifyOpenChannel::TerminalResponse" ); + TFLOGSTRING("CSatNotifyOpenChannel::TerminalResponse"); + TInt ret( KErrNone ); + TBuf8 additionalInfo; + additionalInfo.Zero(); + RSat::TOpenChannelRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TOpenChannelRspV2Pckg* >( aRsp ); + RSat::TOpenChannelRspV2& rspV2 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + // Check fo additional info type + // - If there is Me (Mobile Equipment) error, additional info is needed + // - Channel Status Info is sent through additional info + if ( ( RSat::KMeProblem == rspV2.iInfoType ) + || ( RSat::KChannelStatusInfo == rspV2.iInfoType ) + ) + { + // Check the length of additional info + if ( !rspV2.iAdditionalInfo.Length() ) + { + // Invalid additional info field + ret = KErrCorrupt; + } + else + { + TIsiUtility::CopyToBigEndian( rspV2.iAdditionalInfo, additionalInfo ); + } + } + // Send Terminal Response + iSatMessHandler->OpenChannelTerminalResp( + iTransId, + iCommandDetails, + TUint8( rspV2.iGeneralResult ), + additionalInfo, + TUint8( rspV2.iBearer.iType ), + rspV2.iBearer.iParams, + rspV2.iBufferSize); + return ret; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::GetBearerTypeAndParams +// Handles a OpenChannel Bearer type and parameters specific data. +// ----------------------------------------------------------------------------- +// +void CSatNotifyOpenChannel::GetBearerTypeAndParams + ( + CTlv& aBearerDescriptionTlv, + RSat::TBearer& aBearer + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_GETBEARERTYPEANDPARAMS, "CSatNotifyOpenChannel::GetBearerTypeAndParams" ); + TFLOGSTRING("TSY: CSatNotifyOpenChannel::GetBearerTypeAndParams"); + TUint8 bearerType( aBearerDescriptionTlv.GetShortInfo( ETLV_BearerType ) ); + + // Switch for setting bearer type values + switch( bearerType ) + { + case KBipCsdBearer: + { + aBearer.iType = RSat::ECSDBearer; + break; + } + case KBipGprsBearer: + { + aBearer.iType = RSat::EGPRSBearer; + break; + } + case KBipDefaultBearer: + { + aBearer.iType = RSat::EDefaultBearer; + break; + } + case KBipBluetoothBearer: + { + aBearer.iType = RSat::EBTBearer; + break; + } + case KBipIrDABearer: + { + aBearer.iType = RSat::EIrDaBearer; + break; + } + case KBipRS232Bearer: + { + aBearer.iType = RSat::ERS232Bearer; + break; + } + case KBipUSBBearer: + { + aBearer.iType = RSat::EUSBBearer; + break; + } + // Currently Local link technology independent bearer type is missing from + // Etel SAT API ( EtelSat.h) + case KBipLocalLinkTechnologyIndependentBearer: + default: + { + aBearer.iType = RSat::EBearerTypeNotSet; + break; + } + } + + // Bearer parameters + aBearer.iParams = aBearerDescriptionTlv.GetData( ETLV_BearerParameters ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress +// Handles a OpenChannel SIM/ME Interface transport level and Data Destination +// Address specific data. +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress + ( + CBerTlv& aBerTlv, + RSat::TSimMeInterface& aSimMeInterface, + RSat::TOtherAddress& aDestinationAddress + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress" ); + TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress"); + + // SIM/ME Interface transport level ( Optional ) + CTlv simMeInterfaceTlv; + + if ( KErrNone == aBerTlv.TlvByTagValue( &simMeInterfaceTlv, + KTlvSimMeTransportLevelTag ) ) + { + TFLOGSTRING("CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\ + SIM/ME Interface"); + OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - SIM/ME Interface" ); + + aSimMeInterface.iPrtNumber = simMeInterfaceTlv.GetLongInfo( + ETLV_PortNumber ); + TUint8 protocol( simMeInterfaceTlv.GetShortInfo( + ETLV_TransportProtocolType ) ); + + if ( KProtocolUdp == protocol ) + { + aSimMeInterface.iTransportProto = RSat::EUdp; + } + else if ( KProtocolTcp == protocol ) + { + aSimMeInterface.iTransportProto = RSat::ETcp; + } + else + { + aSimMeInterface.iTransportProto = RSat::EProtocolNotSet; + } + } + else + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\ + SIM/ME Interface - Not present"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -SIM/ME Interface - Not present" ); + aSimMeInterface.iTransportProto = RSat::EProtocolNotPresent; + } + + // Data destination address + // The Data Destination Address is the end point destination + // address of sent data. This data destination address is + // requested when a SIM/ME Interface transport is present, + // otherwise it is ignored. + + // Determine the number of Other Address tags. + // - If there is one and no SIM/ME Interface then this is a Local Address. + // - If there is one and SIM/ME Interface, this is a Destination Address. + // - If there are two and SIM/ME Interface, then the last one is + // the Destination Address. + CTlv* dataDestAddressTlv = NULL; + CTlv localAddress1; + CTlv localAddress2; + + TInt retValueLocalAdd( KErrNotFound ); + TInt retValAddr1( aBerTlv.TlvByTagValue( &localAddress1, + KTlvOtherAddressTag ) ); + TInt retValAddr2( aBerTlv.TlvByTagValue( &localAddress2, + KTlvOtherAddressTag, 1 ) ); + + if ( ( RSat::EProtocolNotPresent != + aSimMeInterface.iTransportProto ) + && ( KErrNone == retValAddr1 ) + && ( KErrNotFound == retValAddr2 ) ) + { + // Destination Address is localAddress1 + dataDestAddressTlv = &localAddress1; + // There can not be a Local Address + } + else if ( ( RSat::EProtocolNotPresent != + aSimMeInterface.iTransportProto ) + && ( KErrNone == retValAddr1 ) + && ( KErrNone == retValAddr2 ) ) + { + // Local Address is localAddress1 + retValueLocalAdd = retValAddr1; + // Destination Address is localAddress2 + dataDestAddressTlv = &localAddress2; + } + else if ( ( RSat::EProtocolNotPresent == + aSimMeInterface.iTransportProto ) + && ( KErrNone == retValAddr1 ) ) + { + // There is only a Local Address + // Local Address is localAddress1 + retValueLocalAdd = retValAddr1; + } + else + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress,\ + Transport protocol did not match."); + OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress, Transport protocol did not match." ); + } + + // Other Address - Set Destination Address + if( dataDestAddressTlv ) + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\ + Destination Address"); + OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address" ); + TUint8 typeOfAddress( dataDestAddressTlv->GetShortInfo( + ETLV_TypeOfAddress ) ); + switch( typeOfAddress ) + { + case KIPV4: // IPv4 + { + aDestinationAddress.iType = RSat::EIPv4Address; + break; + } + case KIPV6: // IPv6 + { + aDestinationAddress.iType = RSat::EIPv6Address; + break; + } + default: + { + aDestinationAddress.iType = RSat::EAddressNotSet; + break; + } + } + // Is there an address + if( dataDestAddressTlv->GetLength() - 1 ) + { + aDestinationAddress.iAddress = + dataDestAddressTlv->GetData( ETLV_Address ); + } + } + else + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\ + Destination Address - Not present"); + OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address - Not present" ); + aDestinationAddress.iType = RSat::EAddressNotPresent; + } // End of Other Address - Set Destination Address + + return retValueLocalAdd; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::LocalAddress +// Handles a OpenChannel Local Address specific data. +// ----------------------------------------------------------------------------- +// +void CSatNotifyOpenChannel::LocalAddress + ( + CBerTlv& aBerTlv, + RSat::TOtherAddress& aLocalAddress + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_LOCALADDRESS, "CSatNotifyOpenChannel::LocalAddress" ); + TFLOGSTRING("TSY: CSatNotifyOpenChannel::LocalAddress"); + + // Other Address - Set Local Address ( Optional ) + CTlv localAddressTlv; + + if ( KErrNone == aBerTlv.TlvByTagValue( &localAddressTlv, + KTlvOtherAddressTag ) ) + { + // If Other local address present + if ( localAddressTlv.GetLength() ) + { + aLocalAddress.iAddress = localAddressTlv.GetData( ETLV_Address ); + // Type of address + TUint8 typeOfAddress( localAddressTlv.GetShortInfo( + ETLV_TypeOfAddress ) ); + + if ( KIPV4 == typeOfAddress ) + { + aLocalAddress.iType = RSat::EIPv4Address; + } + else if ( KIPV6 == typeOfAddress ) + { + aLocalAddress.iType = RSat::EIPv6Address; + } + else + { + aLocalAddress.iType = RSat::EAddressNotSet; + } + } + else + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::LocalAddress - not present"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_LOCALADDRESS, "CSatNotifyOpenChannel::LocalAddress - not present" ); + aLocalAddress.iType = RSat::EAddressNotPresent; + } // End of If Other local address present + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyOpenChannel::GprsBearerSpecific +// Handles a OpenChannel GPRS bearer specific data. +// ----------------------------------------------------------------------------- +// +void CSatNotifyOpenChannel::GprsBearerSpecific + ( + CBerTlv& aBerTlv, + RSat::TOpenGprsChannelV4& aOpenGprsChannelV4 + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC, "CSatNotifyOpenChannel::GprsBearerSpecific" ); + TFLOGSTRING("TSY: CSatNotifyOpenChannel::GprsBearerSpecific"); + + // Network Access Point Name ( Optional ) + CTlv nanTlv; + // If Network Access Point Name present + if ( KErrNone == aBerTlv.TlvByTagValue( &nanTlv, + KTlvNetworkAccessNameTag ) ) + { + TFLOGSTRING("TSY: CSatNotifyOpenChannel::GprsBearerSpecific -\ + Access Point name"); + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC, "CSatNotifyOpenChannel::GprsBearerSpecific - Access Point name" ); + aOpenGprsChannelV4.iAccessName = + nanTlv.GetData( ETLV_NetworkAccessName ); + } + + // Text string - User Login ( Optional ) + // Text string - User Password ( Optional ) + TSatUtility::SetUserLoginAndUserPassword( aBerTlv, + aOpenGprsChannelV4.iUserLogin, + aOpenGprsChannelV4.iUserPassword ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iGetChannelStatusRspV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS, "CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KPSessionTerminatedByUser + + RSat::KErrorRequiredValuesMissing; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS, "CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetChannelStatus::MessageReceived +// Handles a GetChannelStatus proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyGetChannelStatus::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // Received isi-message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_MESSAGERECEIVED, "CSatNotifyGetChannelStatus::MessageReceived" ); + TFLOGSTRING("CSatNotifyGetChannelStatus::MessageReceived"); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details TLV + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + TBuf8<1> empty(0); + iSatMessHandler->GetChannelStatusTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + empty ); + } + else + { + // Fill the Get Channel status structure + RSat::TGetChannelStatusV2& channelStatusV2 = + ( *iGetChannelStatusRspV2Pckg )(); + // Store transaction ID + channelStatusV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Complete request + CompleteRequest( KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetChannelStatus::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a GetChannelStatus PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyGetChannelStatus::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_NOTIFY, "CSatNotifyGetChannelStatus::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifyGetChannelStatus::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iGetChannelStatusRspV2Pckg = + static_cast< RSat::TGetChannelStatusV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KGetChannelStatus ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyGetChannelStatus::TerminalResponse +// Handles a GetChannelStatus terminal response provided by an ETel SAT client +// via ETel server, +// transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyGetChannelStatus::TerminalResponse + ( + TDes8* aRsp // Response package + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_TERMINALRESPONSE, "CSatNotifyGetChannelStatus::TerminalResponse" ); + TFLOGSTRING("CSatNotifyGetChannelStatus::TerminalResponse"); + TInt ret( KErrNone ); + TBuf8 additionalInfo; + additionalInfo.Zero(); + RSat::TGetChannelStatusRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TGetChannelStatusRspV2Pckg* >( aRsp ); + RSat::TGetChannelStatusRspV2& rspV2 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + if ( ( RSat::KChannelStatusInfo == rspV2.iInfoType ) + || ( RSat::KMeProblem == rspV2.iInfoType ) ) + { + if( !rspV2.iAdditionalInfo.Length() + && rspV2.iAdditionalInfo.Length()) + { + ret = KErrCorrupt; + } + else + { + TIsiUtility::CopyToBigEndian( rspV2.iAdditionalInfo, additionalInfo ); + } + } + iSatMessHandler->GetChannelStatusTerminalResp( + iTransId, + iCommandDetails, + TUint8( rspV2.iGeneralResult ), + additionalInfo ); + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyCloseChannel::CSatNotifyCloseChannel +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyCloseChannel::CSatNotifyCloseChannel + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iCloseChannelRspV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL, "CSatNotifyCloseChannel::CSatNotifyCloseChannel" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing + + RSat::KBearerIndepProtocolError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCloseChannel::~CSatNotifyCloseChannel +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyCloseChannel::~CSatNotifyCloseChannel() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL, "CSatNotifyCloseChannel::~CSatNotifyCloseChannel" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCloseChannel::MessageReceived +// Handles a CloseChannel proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyCloseChannel::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // Received isi-message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_MESSAGERECEIVED, "CSatNotifyCloseChannel::MessageReceived" ); + TFLOGSTRING("CSatNotifyCloseChannel::MessageReceived"); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details TLV + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + TBuf8<1> empty(0); + iSatMessHandler->CloseChannelTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + empty ); + } + else + { + // Fill the Close Channel structure + RSat::TCloseChannelV2& closeChannelV2 = + ( *iCloseChannelRspV2Pckg )(); + // Store transaction ID + closeChannelV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Store Channel Id + CTlv deviceIds; + TInt returnValue( berTlv.TlvByTagValue( &deviceIds, + KTlvDeviceIdentityTag ) ); + if ( KErrNotFound != returnValue ) + { + closeChannelV2.iDestination = (RSat::TDeviceId) deviceIds.GetShortInfo( + ETLV_DestinationDeviceIdentity ); + } + // Alpha Id (Optional) + CTlv alphaIdentifier; + returnValue = berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ) ; + closeChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + if ( KErrNotFound != returnValue ) + { + TUint16 alphaIdLength = alphaIdentifier.GetLength(); + if ( alphaIdLength ) + { + // get the alpha id + TPtrC8 sourceString; + sourceString.Set( + alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceString , + closeChannelV2.iAlphaId.iAlphaId ); + } + + // Set Alpha ID status + if ( closeChannelV2.iAlphaId.iAlphaId.Length() ) + { + closeChannelV2.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + closeChannelV2.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Icon Id (Optional) + TSatUtility::FillIconStructure( berTlv, + closeChannelV2.iIconId ); + // Complete request + CompleteRequest( KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCloseChannel::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a CloseChannel PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyCloseChannel::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_NOTIFY, "CSatNotifyCloseChannel::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifyCloseChannel::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iCloseChannelRspV2Pckg = + static_cast< RSat::TCloseChannelV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KCloseChannel ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyCloseChannel::TerminalResponse +// Handles a CloseChannel terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyCloseChannel::TerminalResponse + ( + TDes8* aRsp // Response package + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_TERMINALRESPONSE, "CSatNotifyCloseChannel::TerminalResponse" ); + TFLOGSTRING("CSatNotifyCloseChannel::TerminalResponse"); + TInt ret( KErrNone ); + TBuf8 additionalInfo; + additionalInfo.Zero(); + RSat::TCloseChannelRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TCloseChannelRspV2Pckg* >( aRsp ); + RSat::TCloseChannelRspV2& rspV2 = ( *aRspPckg ) (); + + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + if ( RSat::KMeProblem == rspV2.iInfoType ) + { + if( rspV2.iAdditionalInfo.Length() ) + { + additionalInfo.Append( TUint8( rspV2.iAdditionalInfo[0] ) ); + } + else + { + ret = KErrCorrupt; + } + } + iSatMessHandler->CloseChannelTerminalResp( + iTransId, + iCommandDetails, + TUint8( rspV2.iGeneralResult ), + additionalInfo ); + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifySendData::CSatNotifySendData +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifySendData::CSatNotifySendData + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iSendDataRspV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA, "CSatNotifySendData::CSatNotifySendData" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KNetworkUnableToProcessCmd + + RSat::KErrorRequiredValuesMissing + RSat::KBearerIndepProtocolError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendData::~CSatNotifySendData +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifySendData::~CSatNotifySendData() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA, "CSatNotifySendData::~CSatNotifySendData" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendData::MessageReceived +// Handles a SendData proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendData::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // Received isi-message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_MESSAGERECEIVED, "CSatNotifySendData::MessageReceived" ); + TFLOGSTRING("CSatNotifySendData::MessageReceived"); + // return value for completion of the request + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details TLV + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + TBuf8<1> empty(0); + TUint8 channelDataLength( 0 ); + iSatMessHandler->SendDataTerminalResp( + iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + empty, + channelDataLength ); + } + else + { + // Fill the Send Data structure + RSat::TSendDataV2& sendDataV2 = + ( *iSendDataRspV2Pckg )(); + // Store transaction ID + sendDataV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Store Channel Id + CTlv deviceIds; + if ( KErrNotFound != berTlv.TlvByTagValue( &deviceIds, + KTlvDeviceIdentityTag ) ) + { + sendDataV2.iDestination = (RSat::TDeviceId) deviceIds.GetShortInfo( + ETLV_DestinationDeviceIdentity ); + } + // Channel data (Mandatory) + // When the length is greater than 127, the byte 0x81 is appended before + // the actual length. + CTlv channelData; + if ( KErrNone == berTlv.TlvByTagValue( &channelData, + KTlvChannelDataTag ) ) + { + // Set channel data + sendDataV2.iChannelData.Copy( + channelData.GetData( ETLV_ChannelDataString ) ); + //Set Data mode using command qualifier + TUint8 cmdQualifier( + commandDetails.GetShortInfo( ETLV_CommandQualifier ) ); + if ( KBipSendDataImmediately & cmdQualifier ) + { + // bit 1 = 1 + sendDataV2.iMode = RSat::ESendDataImmediately; + } + else + { + // bit 1 = 0 + sendDataV2.iMode = RSat::EStoreDataInTxBuffer; + } + // Alpha Id (Optional) + sendDataV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + CTlv alphaIdentifier; + TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ) ); + if ( KErrNotFound != returnValue ) + { + TUint16 alphaIdLength = alphaIdentifier.GetLength(); + if ( alphaIdLength ) + { + // get the alpha id + TPtrC8 sourceString; + sourceString.Set( + alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceString , + sendDataV2.iAlphaId.iAlphaId ); + sendDataV2.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + sendDataV2.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Icon Id (Optional) + TSatUtility::FillIconStructure( berTlv, + sendDataV2.iIconId ); + } + else + { + // Required values missing + TBuf8<1> noAdditionalInfo( 0 ); + TUint8 channelDataLength( 0 ); + iSatMessHandler->SendDataTerminalResp( + iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + noAdditionalInfo, + channelDataLength ); + ret = KErrCorrupt; + } + // Complete request + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendData::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a SendData PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifySendData::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDDATA_NOTIFY, "CSatNotifySendData::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifySendData::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iSendDataRspV2Pckg = + static_cast< RSat::TSendDataV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KSendData ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifySendData::TerminalResponse +// Handles a SendData terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifySendData::TerminalResponse + ( + TDes8* aRsp // Response package + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_TERMINALRESPONSE, "CSatNotifySendData::TerminalResponse" ); + TFLOGSTRING("CSatNotifySendData::TerminalResponse"); + TInt ret( KErrNone ); + TBuf8 additionalInfo; + additionalInfo.Zero(); + RSat::TSendDataRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TSendDataRspV2Pckg* >( aRsp ); + RSat::TSendDataRspV2& rspV2 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + + if ( RSat::KMeProblem == rspV2.iInfoType ) + { + if( rspV2.iAdditionalInfo.Length() ) + { + additionalInfo.Append( TUint8( rspV2.iAdditionalInfo[0] ) ); + } + else + { + ret = KErrCorrupt; + } + } + iSatMessHandler->SendDataTerminalResp( + iTransId, + iCommandDetails, + TUint8( rspV2.iGeneralResult ), + additionalInfo, + rspV2.iChannelDataLength ); + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyReceiveData::CSatNotifyReceiveData +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyReceiveData::CSatNotifyReceiveData + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) + : + CSatNotificationsBase( aSatMessHandler, aSatMessaging ), + iReceiveDataRspV2Pckg( NULL ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA, "CSatNotifyReceiveData::CSatNotifyReceiveData" ); + // Following results are also allowed for this command: + // (in addition to result declared in base class constructor) + iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed + + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing + + RSat::KBearerIndepProtocolError; + } + +// ----------------------------------------------------------------------------- +// CSatNotifyReceiveData::~CSatNotifyReceiveData +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyReceiveData::~CSatNotifyReceiveData() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA, "CSatNotifyReceiveData::~CSatNotifyReceiveData" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyReceiveData::MessageReceived +// Handles a ReceiveData proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyReceiveData::MessageReceived + ( + const TIsiReceiveC& aIsiMessage // Received isi-message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_MESSAGERECEIVED, "CSatNotifyReceiveData::MessageReceived" ); + TFLOGSTRING("CSatNotifyReceiveData::MessageReceived"); + // return value for completion of the request + TInt ret( KErrNone ); + // Get ber tlv + CBerTlv berTlv; + berTlv.BerTlv( aIsiMessage ); + // Get command details tlv + CTlv commandDetails; + berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag ); + // Store command details TLV + iCommandDetails.Copy( commandDetails.Data() ); + iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ); + if ( !iReqHandle ) + { + // Request not on, returning response immediately + TBuf8<1> empty(0); + TUint8 channelDataLength( 0 ); + iSatMessHandler->ReceiveDataTerminalResp( iTransId, + iCommandDetails, + RSat::KMeUnableToProcessCmd, + empty, + channelDataLength ); + } + else + { + // Fill the Receive Data structure + RSat::TReceiveDataV2& receiveDataV2 = + ( *iReceiveDataRspV2Pckg )(); + // Store transaction ID + receiveDataV2.SetPCmdNumber( + commandDetails.GetShortInfo( ETLV_CommandNumber ) ); + // Store Channel Id + CTlv deviceIds; + if ( KErrNotFound != berTlv.TlvByTagValue( &deviceIds, + KTlvDeviceIdentityTag ) ) + { + receiveDataV2.iDestination = (RSat::TDeviceId) deviceIds.GetShortInfo( + ETLV_DestinationDeviceIdentity ); + } + // Channel data length (Mandatory) + CTlv channelDataLengthTlv; + if ( KErrNone == berTlv.TlvByTagValue( &channelDataLengthTlv, + KTlvChannelDataLengthTag ) ) + { + receiveDataV2.iChannelDataLength = + channelDataLengthTlv.GetShortInfo( ETLV_ChannelDataLength ); + // Alpha Id (Optional) + receiveDataV2.iAlphaId.iStatus = RSat::EAlphaIdNotPresent; + CTlv alphaIdentifier; + TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier, + KTlvAlphaIdentifierTag ) ); + if ( KErrNotFound != returnValue ) + { + TUint16 alphaIdLength = alphaIdentifier.GetLength(); + if ( alphaIdLength ) + { + // get the alpha id + TPtrC8 sourceString; + sourceString.Set( + alphaIdentifier.GetData( ETLV_AlphaIdentifier ) ); + // convert and set the alpha id + TSatUtility::SetAlphaId( sourceString , + receiveDataV2.iAlphaId.iAlphaId ); + receiveDataV2.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + receiveDataV2.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + } + // Icon Id (Optional) + TSatUtility::FillIconStructure( berTlv, + receiveDataV2.iIconId ); + } + else + { + // Required values missing + TBuf8<1> noAdditionalInfo( 0 ); + TUint8 channelDataLength( 0 ); + iSatMessHandler->ReceiveDataTerminalResp( + iTransId, + iCommandDetails, + RSat::KErrorRequiredValuesMissing, + noAdditionalInfo, + channelDataLength ); + ret = KErrCorrupt; + } + // Complete request + CompleteRequest( ret ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyReceiveData::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a ReceiveData PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyReceiveData::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace1( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_NOTIFY, "CSatNotifyReceiveData::Notify Handle: %u", aReqHandle ); + TFLOGSTRING2("CSatNotifyReceiveData::Notify. \n\t\t\t Handle:%d\n\t\t\t", + aReqHandle ); + iReqHandle = aReqHandle; + iReceiveDataRspV2Pckg = + static_cast< RSat::TReceiveDataV2Pckg* >( aDataPtr ); + iSatMessaging->SatReady( KReceiveData ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyReceiveData::TerminalResponse +// Handles a ReceiveData terminal response provided by an ETel SAT client via +// ETel server, transforms it into an ISI message, and passes it to domestic OS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CSatNotifyReceiveData::TerminalResponse + ( + TDes8* aRsp // Response package + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_TERMINALRESPONSE, "CSatNotifyReceiveData::TerminalResponse" ); + TFLOGSTRING("CSatNotifyReceiveData::TerminalResponse"); + TInt ret( KErrNone ); + TBuf8 additionalInfo; + additionalInfo.Zero(); + RSat::TReceiveDataRspV2Pckg* aRspPckg = + reinterpret_cast< RSat::TReceiveDataRspV2Pckg* >( aRsp ); + RSat::TReceiveDataRspV2& rspV2 = ( *aRspPckg ) (); + // Check that general result value is valid + if ( iAllowedResults != rspV2.iGeneralResult ) + { + // Invalid general result + ret = KErrCorrupt; + } + if ( ( RSat::KMeProblem == rspV2.iInfoType ) + || ( RSat::KChannelData == rspV2.iInfoType ) ) + { + if( rspV2.iAdditionalInfo.Length() ) + { + // Channel Data available and sent using Additional info + // Data are received in unicode format: 0x00XX where XX is + // meaningful. + additionalInfo.Copy( rspV2.iAdditionalInfo ); + } + else + { + ret = KErrCorrupt; + } + } + iSatMessHandler->ReceiveDataTerminalResp( + iTransId, + iCommandDetails, + TUint8( rspV2.iGeneralResult ), + additionalInfo, + rspV2.iChannelDataLength ); + return ret; + } + + +// ----------------------------------------------------------------------------- +// CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest + ( + CSatMessHandler* aSatMessHandler, //Pointer to the message handler + CTsySatMessaging* aSatMessaging //Pointer to satmessaging class + ) : CSatNotificationsBase( aSatMessHandler, aSatMessaging ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST, "CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest" ); + } + +// ----------------------------------------------------------------------------- +// CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest +// Destructor +// ----------------------------------------------------------------------------- +// +CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest() + { + OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST, "CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest" ); + // None + } + +// ----------------------------------------------------------------------------- +// CSatNotifyMoSmControlRequest::MessageReceived +// Handles a MoSmControlRequest proactive command ISI message, +// and completes a pending ETel request. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyMoSmControlRequest::MessageReceived + ( + const TIsiReceiveC& /*aIsiMessage*/ // ISI message + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_MESSAGERECEIVED, "CSatNotifyMoSmControlRequest::MessageReceived" ); + // In S60 phones, the MoSm control request is received via an ISI + // message coming from the SMS server. That's why the body + // of this method is empty, see the class CSatMoSmCtrl. The Etel Sat API is used + // to pass to S60 Sat Server the alpha identifier provided by the SIM, + // if any. The SIM can provide such an alpha id to tell the user that the + // number to which the SMS has to be sent, has been modified by the SIM. + } + +// ----------------------------------------------------------------------------- +// CSatNotifyMoSmControlRequest::CompleteNotification +// Completes an ETel server Mo-Sms Control notification +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyMoSmControlRequest::CompleteNotification + ( + TDesC& aAlphaId, // Alpha Id + RSat::TControlResult aResult // Call Control result + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyMoSmControlRequest::CompleteNotification" ); + TFLOGSTRING("CSatNotifyMoSmControlRequest::CompleteNotification"); + //check that a client has requested this notifications + if ( iReqHandle ) + { + // Fill the call control structure + RSat::TMoSmControlV1& moSmControlV1 = ( *iMoSmControlV1Pckg )(); + // Set Alpha id status + if ( aAlphaId. Length() ) + { + moSmControlV1.iAlphaId.iStatus = RSat::EAlphaIdProvided; + } + else + { + moSmControlV1.iAlphaId.iStatus = RSat::EAlphaIdNull; + } + //set control result + moSmControlV1.iResult = aResult; + // set alpha id + moSmControlV1.iAlphaId.iAlphaId.Append( aAlphaId ); + //Complete notification + CompleteRequest( KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CSatNotifyMoSmControlRequest::Notify +// An ETel SAT client can call this method via ETel server to set a pending +// request in SimAtkTsy for a MoSmControlRequest PCmd. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CSatNotifyMoSmControlRequest::Notify + ( + const TTsyReqHandle aReqHandle, // Request handle + TDes8* aDataPtr // Pointer to data + ) + { + OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_NOTIFY, "CSatNotifyMoSmControlRequest::Notify" ); + TFLOGSTRING("CSatNotifyMoSmControlRequest::Notify"); + iReqHandle = aReqHandle; + iMoSmControlV1Pckg = static_cast< RSat::TMoSmControlV1Pckg* >( aDataPtr ); + } + +// End of File