--- /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 <tisi.h> // isi message
+#include <net_modemisi.h> // net server
+#include <gssisi.h> // gss server
+#include <atkisi.h> // atk server
+#include <uiccisi.h> // uicc server
+#include <satcs.h>
+#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<TInt64>( 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<RSat::TDisplayTextRspV1Pckg*>( 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<TUint8>( 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<RSat::TGetInkeyRspV2Pckg&>( *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<TUint8> (timeIntv / 10 );
+ }
+ else
+ {
+ anIntervalInSeconds = static_cast<TUint8> ( (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<TUint8>( 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<RSat::TSetUpMenuRspV1Pckg*>( 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<TUint8>( 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<TUint8>( 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<RSat::KTextStringMaxSize> 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<RSat::TSelectItemRspV1Pckg*>( 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<TUint8>( 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<RSat::KMaxMobileTelNumberSize> 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<RSat::KStringMaxSize> 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<RSat::KAdditionalInfoMaxSize> additionalInfo;
+
+ RSat::TSendSsRspV2Pckg* aRspPckg =
+ reinterpret_cast<RSat::TSendSsRspV2Pckg*>( 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<ussdStringLengthInBytes)
+ || ( ( ESms8BitDcs==decodedDcs )
+ && RSat::KStringMaxSize<ussdStringLengthInBytes)
+ || ( ( ESms7BitDcs==decodedDcs )
+ && RSat::KStringMaxSize<8*ussdStringLengthInBytes/7))
+ {
+ // The Ussd text string is too long.
+ TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \
+ USSD String too long");
+ OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, USSD String too long" );
+ ret = KErrCorrupt;
+ TUint8 noCause( 0 );
+ TBuf<1> 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<RSat::KStringMaxSize> 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<RSat::KMaxMobileTelNumberSize> 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<TUint8>( 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<RSat::KStringMaxSize> 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<RSat::KMaxMobileTelNumberSize> 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<RSat::TCallControlV5Pckg*>( 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<RSat::KBearerListMaxSize> 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<RSat::TOpenGprsChannelV4&>( 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<RSat::KAdditionalInfoMaxSize> 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<RSat::KAdditionalInfoMaxSize> 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<RSat::KAdditionalInfoMaxSize> 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<RSat::KAdditionalInfoMaxSize> 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<RSat::KAdditionalInfoMaxSize> 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