/*
* Copyright (c) 2007-2010 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 "satmessaging.h"       // csatmessaging class
#include "satcc.h"              // sat call control class
#include "sattimer.h"           // sat timer class
#include "sateventdownload.h"   // sat event download class
#include "satdatadownload.h"    // sat data download class
#include "saticon.h"            // sat icon class
#include "satmosmsctrl.h"       // sat mo sms control class
#include "satnotifications.h"   // sat notifications class
#include "ber_tlv.h"            // sat ber-tlv classes
#include "satutil.h"            // sat utility class
#include "satflightmodestatus.h"// sat flight mode status class
#include "satnumberofslots.h"   // multimode tsy slot definitions

#include <satcs.h>              // etel sat ipc request definitions
#include <ctsy/serviceapi/cmmsmsutility.h>      // ton/npi constants, tsendsmsdataandattributes
#include "cmmmessagerouter.h"   // cmessagerouter class of nokiatsy component
#include <ctsy/pluginapi/cmmdatapackage.h>     // parameter packing
#include <ctsy/serviceapi/mmtsy_ipcdefs.h>      // for ipc
#include <tisi.h>               // isi message
#include <infoisi.h>            // isa cellmo info server
#include <uiccisi.h>            // UICC server

#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "satmessagingTraces.h"
#endif

#if (NCP_COMMON_S60_VERSION_SUPPORT==S60_VERSION_32)
#include <cmmsmstsy.h>          // sms functionality
#define __TFLOGGER_H__
#include <cmmphonetsy.h>

#undef __TFLOGGER_H__
#endif //NCP_COMMON_S60_VERSION_SUPPORT

// EXTERNAL DATA STRUCTURES
    //None

// EXTERNAL FUNCTION PROTOTYPES
    //None

// CONSTANTS
const TUint8 KHelp          = 1;
const TUint8 KNoHelp        = 0;

// MACROS
    //None

// LOCAL CONSTANTS AND MACROS
    //None

// MODULE DATA STRUCTURES
    //None

// LOCAL FUNCTION PROTOTYPES
    //None

// FORWARD DECLARATIONS
    //None

// ============================= LOCAL FUNCTIONS ===============================
    //None

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CTsySatMessaging::CTsySatMessaging
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
#if (NCP_COMMON_S60_VERSION_SUPPORT==S60_VERSION_32)
CTsySatMessaging::CTsySatMessaging
        (
        CMmPhoneTsy*        aMmPhone,
        CMmPhoNetSender*    aPnSend,
        CMmPhoNetReceiver*  aPnReceive,
        TName               aName
        ) : CTsySatMessagingBase(),
        iMmPhone( aMmPhone ),
        iPnSend( aPnSend ),
        iPnReceive( aPnReceive ),
        iSatAppName( aName ),
        iSendSmsTsyReqHandle( NULL )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_CTSYSATMESSAGING_TD, "CTsySatMessaging::CTsySatMessaging" );
    TFLOGSTRING("TSY: CTsySatMessaging::CTsySatMessaging");
    /* None */
    }
#else
CTsySatMessaging::CTsySatMessaging
        (
        CMmPhoNetSender*    aPnSend,
        CMmPhoNetReceiver*  aPnReceive,
        CMmMessageRouter* aRouter
        )

    {
    OstTrace0( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_CTSYSATMESSAGING_TD, "CTsySatMessaging::CTsySatMessaging" );

        iPnSend = aPnSend;
        iPnReceive = aPnReceive;
        iRouter = aRouter;
        iSendSmsTsyReqHandle = NULL;

    TFLOGSTRING("TSY: CTsySatMessaging::CTsySatMessaging");
    /* None */
    }
#endif //NCP_COMMON_S60_VERSION_SUPPORT


// -----------------------------------------------------------------------------
// CTsySatMessaging::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::ConstructL()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_CONSTRUCTL_TD, "CTsySatMessaging::ConstructL" );
    TFLOGSTRING("TSY: CTsySatMessaging::ConstructL");

    // Create message handler object, to receive ISI messages from ISA CellMo
    iSatMessHandler = CSatMessHandler::NewL( this, iPnSend );

    // Phonet receiver has to know the SatMessHandler.
    iPnReceive->SetSatMessHandler( iSatMessHandler );

    // Initialize Flight Mode Status handler
    iSatFlightModeStatus = CSatFlightModeStatus::NewL( iSatMessHandler, this );

    // Initialize SAT Notifications objects
    iNotifyMoSmControlRequest =
        new( ELeave )CSatNotifyMoSmControlRequest( iSatMessHandler, this );
    iNotifyDisplayText =
        new( ELeave )CSatNotifyDisplayText( iSatMessHandler, this );
    iNotifyGetInkey =
        new( ELeave )CSatNotifyGetInkey( iSatMessHandler, this );
    iNotifyGetInput =
        new( ELeave )CSatNotifyGetInput( iSatMessHandler, this );
    iNotifyPlayTone =
        new( ELeave )CSatNotifyPlayTone( iSatMessHandler, this );
    iNotifySetUpMenu =
        new( ELeave )CSatNotifySetUpMenu( iSatMessHandler, this );
    iNotifySelectItem =
        new( ELeave )CSatNotifySelectItem( iSatMessHandler, this );
    iNotifySendSm =
        new( ELeave )CSatNotifySendSm( iSatMessHandler, this );
    iNotifySendSs =
        new( ELeave )CSatNotifySendSs( iSatMessHandler, this );
    iNotifySendUssd =
        new( ELeave )CSatNotifySendUssd( iSatMessHandler, this );
    iNotifySetUpCall =
        new( ELeave )CSatNotifySetUpCall( iSatMessHandler, this );
    iNotifyRefresh =
        new( ELeave )CSatNotifyRefresh( iSatMessHandler, this );
    iNotifySimSessionEnd =
        new( ELeave )CSatNotifySimSessionEnd( iSatMessHandler, this );
    iNotifySetUpIdleModeText =
        new( ELeave )CSatNotifySetUpIdleModeText( iSatMessHandler, this );
    iNotifyLaunchBrowser =
        new( ELeave )CSatNotifyLaunchBrowser( iSatMessHandler, this );
    iNotifyCallControlRequest =
        new( ELeave )CSatNotifyCallControlRequest( iSatMessHandler, this );
    iNotifyPollInterval =
        new( ELeave )CSatNotifyPollInterval( iSatMessHandler, this );
    iNotifySendDtmf =
        new( ELeave )CSatNotifySendDtmf( iSatMessHandler, this );
    iNotifySetUpEventList =
        new( ELeave )CSatNotifySetUpEventList( iSatMessHandler, this );
    iNotifyPollingOff =
        new( ELeave )CSatNotifyPollingOff( iSatMessHandler, this );
    iNotifyLocalInfo =
        new( ELeave )CSatNotifyLocalInfo( iSatMessHandler, this );
    iNotifyTimerMgmt =
        new( ELeave )CSatNotifyTimerMgmt( iSatMessHandler, this );
    iNotifyMoreTime =
        new( ELeave )CSatNotifyMoreTime( iSatMessHandler, this );
    iNotifyOpenChannel =
        new( ELeave )CSatNotifyOpenChannel( iSatMessHandler, this );
    iNotifyLanguageNotification =
        new( ELeave )CSatNotifyLanguageNotification( iSatMessHandler, this );
    iNotifyGetChannelStatus =
        new( ELeave )CSatNotifyGetChannelStatus( iSatMessHandler, this );
    iNotifyCloseChannel =
        new( ELeave )CSatNotifyCloseChannel( iSatMessHandler, this );
    iNotifyReceiveData =
        new( ELeave )CSatNotifyReceiveData( iSatMessHandler, this );
    iNotifySendData =
        new( ELeave )CSatNotifySendData( iSatMessHandler, this );

    // Transaction id handling
    iTransIdMsg = new( ELeave )TTransIdMessage();

    // Initialize event download handler
    iEventDownload = CSatEventDownload::NewL( iSatMessHandler, this );

    // Initialize data download handler
    iSatDataDownload = CSatDataDownload::NewL( iSatMessHandler, this );

    // Initialize call control handler
    iSatCC = CSatCC::NewL( iSatMessHandler, this );

    // Initialize MO-SMS Control handler
    iSatMoSmsCtrl = CSatMoSmsCtrl::NewL( iSatMessHandler, this );

    // Initialize timer, this is used for implementing timer management
    iSatTimer = CSatTimer::NewL( iSatMessHandler, this );

    // Initialize SAT icon support implementation
    iSatIcon = CSatIcon::NewL( iSatMessHandler, this );

    // Request IMEI code. Needed in provide local info proactive command.
    /*iSatMessHandler->InfoSerialNumberReadReq(
        GetTransactionId(), INFO_SB_SN_IMEI_PLAIN );*/

    // Request IMEI-SV code. Needed in provide local info proactive command.
    /*iSatMessHandler->InfoSerialNumberReadReq(
        GetTransactionId(), INFO_SN_IMEI_SV_TO_NET );*/

    // Request Network status
    iSatMessHandler->NetCellInfoGetReq(
        GetTransactionId() );

    //Initalize flag, this is used to check if proactiveCommand is ongoing
    iSatTimer->SetProactiveCommandOnGoingStatus( EFalse );



/*#ifdef INFO_PP_SIM_OLD_POLL_INTERVAL
    // Check old poll interval is supported by ME's Product Profile
    iSatMessHandler->InfoPpReadReq( INFO_PP_SIM_OLD_POLL_INTERVAL );
#endif

#ifdef INFO_PP_ENHANCED_NETWORK_SELECTION
    // Check INFO_PP_ENHANCED_NETWORK_SELECTION status in product profile
    iSatMessHandler->InfoPpReadReq( INFO_PP_ENHANCED_NETWORK_SELECTION );
#endif*/
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
#if (NCP_COMMON_S60_VERSION_SUPPORT==S60_VERSION_32)
EXPORT_C CTsySatMessaging* CTsySatMessaging::NewL
        (
        CMmPhoneTsy*            aMmPhone,
        CMmMessageRouterBase*   aRouter,
        TName                   aName
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_NEWL_TD, "CTsySatMessaging::NewL" );

    TFLOGSTRING("TSY: CTsySatMessaging::NewL");
    // First check that given arguments are not NULL pointers
    if ( ( NULL == aMmPhone ) || ( NULL == aRouter ) )
        {
        TFLOGSTRING("TSY: CTsySatMessaging::NewL, NULL pointers were given \
            leaving!");
        OstTrace0( TRACE_NORMAL,  DUP2_CTSYSATMESSAGING_NEWL_TD, "CTsySatMessaging::NewL, NULL pointers were given leaving!" );

        User::Leave( KErrArgument );
        }
    CMmPhoNetSender* pnSend = NULL;
    CMmPhoNetReceiver* pnReceive = NULL;
    // Get the ISI message router (to handle ISA CellMo messages)
    CMmMessageRouter* licenseeMessageRouter =
        static_cast<CMmMessageRouter*>( aRouter );
    // Get the ISI message sender
    pnSend = licenseeMessageRouter->GetPhoNetSender();
    // Get the ISI message receivde
    pnReceive = licenseeMessageRouter->GetPhoNetReceiver();

    if ( ( NULL == pnSend ) || ( NULL == pnReceive ) )
        {
        // PhoNet is not correctly initialized. No conditions to survive.
        // This may happen if LicenseeTSY stub is used with real SIM_ATK_TSY
        TFLOGSTRING("TSY: CTsySatMessaging::NewL, Construction failed \
            PhoNet is not initialized, leaving!");
        OstTrace0( TRACE_NORMAL,  DUP5_CTSYSATMESSAGING_NEWL_TD, "CTsySatMessaging::NewL, Construction failed PhoNet is not initialized, leaving!" );

        User::Leave( KErrArgument );
        }
    // Create a SatMessaging session
    CTsySatMessaging* subsession = new (ELeave) CTsySatMessaging( aMmPhone,
        pnSend, pnReceive, aName );
    CleanupStack::PushL( subsession );
    subsession->ConstructL();
    CleanupStack::Pop( subsession );
    return subsession;
    }
#else
EXPORT_C CTsySatMessaging* CTsySatMessaging::NewL
        (
        CMmMessageRouter*   aRouter
        )
    {
    OstTrace0( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_NEWL_TD, "CTsySatMessaging::NewL" );

    TFLOGSTRING("TSY: CTsySatMessaging::NewL");
    // First check that given arguments are not NULL pointers
    if ( NULL == aRouter )
        {
        TFLOGSTRING("TSY: CTsySatMessaging::NewL, NULL pointers were given \
            leaving!");
        OstTrace0( TRACE_NORMAL,  DUP3_CTSYSATMESSAGING_NEWL_TD, "CTsySatMessaging::NewL, NULL pointers were given leaving!" );

        User::Leave( KErrArgument );
        }
    CMmPhoNetSender* pnSend = NULL;
    CMmPhoNetReceiver* pnReceive = NULL;
    // Get the ISI message router (to handle ISA CellMo messages)

    // Get the ISI message sender
    pnSend = aRouter->GetPhoNetSender();
    // Get the ISI message receivde
    pnReceive = aRouter->GetPhoNetReceiver();

    if ( ( NULL == pnSend ) || ( NULL == pnReceive ) )
        {
        // PhoNet is not correctly initialized. No conditions to survive.
        // This may happen if LicenseeTSY stub is used with real SIM_ATK_TSY
        TFLOGSTRING("TSY: CTsySatMessaging::NewL, Construction failed \
            PhoNet is not initialized, leaving!");
        OstTrace0( TRACE_NORMAL,  DUP4_CTSYSATMESSAGING_NEWL_TD, "CTsySatMessaging::NewL, Construction failed PhoNet is not initialized, leaving!" );

        User::Leave( KErrArgument );
        }
    // Create a SatMessaging session
    CTsySatMessaging* subsession = new (ELeave) CTsySatMessaging(
        pnSend, pnReceive, aRouter );
    CleanupStack::PushL( subsession );
    subsession->ConstructL();
    CleanupStack::Pop( subsession );
    return subsession;
    }
#endif //NCP_COMMON_S60_VERSION_SUPPORT

// -----------------------------------------------------------------------------
// CTsySatMessaging::~CTsySatMessaging
// Destructor.
// -----------------------------------------------------------------------------
//
CTsySatMessaging::~CTsySatMessaging()
    {
    OstTrace0( TRACE_NORMAL,  DUP2_CTSYSATMESSAGING_CTSYSATMESSAGING_TD, "CTsySatMessaging::~CTsySatMessaging" );
    TFLOGSTRING("TSY: CTsySatMessaging::~CTsySatMessaging");

    // Delete message handler object, SAT SMS sending
    delete iSatMessHandler;

    // Set pointer value to Null
    if( iPnReceive )
        {
        iPnReceive->SetSatMessHandler( NULL );
        }

    // Delete internal components
    delete iSatFlightModeStatus;
    delete iTransIdMsg;
    delete iEventDownload;
    delete iSatDataDownload;
    delete iSatCC;
    delete iSatMoSmsCtrl;
    delete iSatTimer;
    delete iSatIcon;

    // Delete Notifications objects
    delete iNotifyMoSmControlRequest;
    delete iNotifyDisplayText;
    delete iNotifyGetInkey;
    delete iNotifyGetInput;
    delete iNotifyPlayTone;
    delete iNotifySetUpMenu;
    delete iNotifySelectItem;
    delete iNotifySendSm;
    delete iNotifySendSs;
    delete iNotifySendUssd;
    delete iNotifySetUpCall;
    delete iNotifyRefresh;
    delete iNotifySimSessionEnd;
    delete iNotifySetUpIdleModeText;
    delete iNotifyLaunchBrowser;
    delete iNotifyCallControlRequest;
    delete iNotifyPollInterval;
    delete iNotifySendDtmf;
    delete iNotifySetUpEventList;
    delete iNotifyPollingOff;
    delete iNotifyLocalInfo;
    delete iNotifyTimerMgmt;
    delete iNotifyMoreTime;
    delete iNotifyOpenChannel;
    delete iNotifyLanguageNotification;
    delete iNotifyGetChannelStatus;
    delete iNotifyCloseChannel;
    delete iNotifyReceiveData;
    delete iNotifySendData;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::OpenNewObjectByNameL
// Opens a new object identified by a name.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CTelObject* CTsySatMessaging::OpenNewObjectByNameL
        (
        const TDesC& /* aName */    // Name of the object
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_OPENNEWOBJECTBYNAMEL_TD, "CTsySatMessaging::OpenNewObjectByNameL" );
    TFLOGSTRING("TSY: CTsySatMessaging::OpenNewObjectByNameL");
    User::Leave( KErrNotSupported );
    return NULL;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::OpenNewObjectL
// Opens a new object identified by new name. Can leave. Not in use.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CTelObject* CTsySatMessaging::OpenNewObjectL
        (
        TDes& /*aNewName*/  // Name of the new object
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_OPENNEWOBJECTL_TD, "CTsySatMessaging::OpenNewObjectL" );
    TFLOGSTRING("TSY: CTsySatMessaging::OpenNewObjectL");
    User::Leave( KErrNotSupported );
    return NULL;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::ExtFunc
// Command handler for ETel server messages. The IPC identifies
// the command to be executed if supported.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::ExtFunc
        (
        const TTsyReqHandle aTsyReqHandle,  // Request handle
        const TInt          aIpc,           // IPC number of request
        const TDataPackage& aPackage        // Contains parameters for request
        )
    {
    OstTraceExt2( TRACE_NORMAL,  CTSYSATMESSAGING_EXTFUNC_TD, "CTsySatMessaging::ExtFunc ReqHandle: %d IPC: %d", TInt(aTsyReqHandle), aIpc );

    TFLOGSTRING3("TSY: CTsySatMessaging::ExtFunc ReqHandle=%d IPC=%d",
        aTsyReqHandle, aIpc);
    // some SAT functions need trapping, use two level function where
    // first one is just a trap harness
    // It is responsibility of IPC handling functions to always handle
    // calling ReqComplete, ( it must either call it, or arrange it to
    // be called in some way), except in the case of Leave. It is also
    // assumed that after IPC handling function has called ReqComplete
    // it doesn't Leave.
    TInt trapError( KErrNone );
    TRAP( trapError, DoExtFuncL( aTsyReqHandle, aIpc, aPackage ) );
    if ( trapError != KErrNone )
        {
        ReqCompleted( aTsyReqHandle, trapError );
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::DoExtFuncL
// Handles extended ETel SAT client requests, received from ExtFunc
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::DoExtFuncL
        (
        const TTsyReqHandle aTsyReqHandle,  // Request handle
        const TInt          aIpc,           // IPC number of request
        const TDataPackage& aPackage        // Contains parameters for request
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_DOEXTFUNCL_TD, "CTsySatMessaging::DoExtFuncL" );
    TFLOGSTRING("TSY: CTsySatMessaging::DoExtFuncL");
    TAny* dataPtr=aPackage.Ptr1();
    TAny* dataPtr2=aPackage.Ptr2();
    switch ( aIpc )
        {
        case ESatNotifyDisplayTextPCmd:
            {
            iNotifyDisplayText->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySelectItemPCmd:
            {
            iNotifySelectItem->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyGetInkeyPCmd:
            {
            iNotifyGetInkey->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyGetInputPCmd:
            {
            iNotifyGetInput->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyPlayTonePCmd:
            {
            iNotifyPlayTone->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySetUpMenuPCmd:
            {
            iNotifySetUpMenu->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySendSmPCmd:
            {
            iNotifySendSm->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySendSsPCmd:
            {
            iNotifySendSs->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySendUssdPCmd:
            {
            iNotifySendUssd->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySetUpCallPCmd:
            {
            iNotifySetUpCall->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyRefreshPCmd:
            {
            iNotifyRefresh->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyRefreshRequiredParam:
            {
            iNotifyRefresh->NotifyRefreshRequired( aTsyReqHandle,
                aPackage.Des1n() );
            break;
            }
        case ESatRefreshAllowed:
            {
            ReqCompleted( aTsyReqHandle,
                iNotifyRefresh->RefreshAllowed( aPackage.Des1n() ) );
            break;
            }
        case ESatNotifyProactiveSimSessionEnd:
            {
            iNotifySimSessionEnd->Notify( aTsyReqHandle, NULL );
            break;
            }
        case ESatNotifySetUpIdleModeTextPCmd:
            {
            iNotifySetUpIdleModeText->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyLaunchBrowserPCmd:
            {
            iNotifyLaunchBrowser->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyCallControlRequest:
            {
            iNotifyCallControlRequest->Notify( aTsyReqHandle,
                aPackage.Des1n() );
            break;
            }
        case ESatNotifySendDtmfPCmd:
            {
            iNotifySendDtmf->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySetUpEventListPCmd:
            {
            iNotifySetUpEventList->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyOpenChannelPCmd:
            {
            iNotifyOpenChannel->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyCloseChannelPCmd:
            {
            iNotifyCloseChannel->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyReceiveDataPCmd:
            {
            iNotifyReceiveData->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifySendDataPCmd:
            {
            iNotifySendData->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatEventDownload:
            {
            iEventDownload->ExtFunc( aTsyReqHandle, aPackage );
            break;
            }
        // All IPC functions could be done the same way as Notifies are done:
        // a class instead of a bare function.
        case ESatTerminalRsp:
            {
            TerminalResponse( REINTERPRET_CAST( RSat::TPCmd*, dataPtr ),
                aPackage.Des2n(),
                aTsyReqHandle );
            break;
            }
        case ESatMenuSelection:
            {
            MenuSelection( aPackage.Des1n(), aTsyReqHandle );
            break;
            }
        case ESatNotifyCbDownload:
            {
            NotifyCbDownload( aPackage.Des1n(), aTsyReqHandle );
            break;
            }
        case ESatNotifySmsPpDownload:
            {
            NotifySmsPpDownload( aPackage.Des1n(), aTsyReqHandle );
            break;
            }
        case ESatSendMessageNoLogging:
            {
            SendMessageNoLoggingL( aPackage.Des1n(),
                REINTERPRET_CAST( TUint16*, dataPtr2 ),
                aTsyReqHandle );
            break;
            }
        case ESatGetIcon:
            {
            iSatIcon->GetIcon( REINTERPRET_CAST( TUint8*, dataPtr ),
                REINTERPRET_CAST( RSat::TIcon*, dataPtr2 ),
                aTsyReqHandle );
            break;
            }
        case ESatGetImageInstance:
            {
            iSatIcon->GetImageInstance( aPackage.Des1n(),
                aPackage.Des2n(), aTsyReqHandle );
            break;
            }
        case ESatGetClut:
            {
            iSatIcon->GetClut(
                REINTERPRET_CAST( RSat::TInstanceNumberAndOffset*, dataPtr ),
                aPackage.Des2n(),
                aTsyReqHandle);
            break;
            }
        case ESatNotifyLanguageNotificationPCmd:
            {
            iNotifyLanguageNotification->Notify( aTsyReqHandle,
                aPackage.Des1n() );
            break;
            }
        case ESatNotifyLocalInfoPCmd:
            {
            iNotifyLocalInfo->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyGetChannelStatusPCmd:
            {
            iNotifyGetChannelStatus->Notify( aTsyReqHandle, aPackage.Des1n() );
            break;
            }
        case ESatNotifyMoSmControlRequest:
            {
            iNotifyMoSmControlRequest->Notify( aTsyReqHandle,
                aPackage.Des1n() );
            break;
            }
        case ESatUsatClientReadyIndication:
            {
            UsatClientReadyIndication( aTsyReqHandle );
            break;
            }
        // Set ret to KErrNotSupported, function not supported
        default:
            {
            TFLOGSTRING2("TSY: CTsySatMessaging::DoExtFuncL unsupported IPC %d", aIpc);
            OstTrace1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_DOEXTFUNCL_TD, "CTsySatMessaging::DoExtFuncL unsupported IPC %d", aIpc );

            ReqCompleted( aTsyReqHandle, KErrNotSupported );
            break;
            }
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::CancelService
// Cancels the ongoing service
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::CancelService
        (
        const TInt          aIpc,           // IPC number of request
        const TTsyReqHandle aTsyReqHandle   // Request handle
        )
    {
    OstTraceExt2( TRACE_NORMAL,  CTSYSATMESSAGING_CANCELSERVICE_TD, "CTsySatMessaging::CancelService ReqHandle=%d, IPC=%d", TInt(aTsyReqHandle), aIpc );
    TFLOGSTRING3("TSY: CTsySatMessaging::CancelService ReqHandle=%d IPC=%d",aTsyReqHandle, aIpc);
    TInt ret( KErrNone );
    switch ( aIpc )
        {
        case ESatNotifyDisplayTextPCmd:
            {
            ret = iNotifyDisplayText->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyGetInkeyPCmd:
            {
            ret = iNotifyGetInkey->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyGetInputPCmd:
            {
            ret = iNotifyGetInput->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyPlayTonePCmd:
            {
            ret = iNotifyPlayTone->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySetUpMenuPCmd:
            {
            ret =  iNotifySetUpMenu->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySelectItemPCmd:
            {
            ret = iNotifySelectItem->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySendSmPCmd:
            {
            ret = iNotifySendSm->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySendSsPCmd:
            {
            ret = iNotifySendSs->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySendUssdPCmd:
            {
            ret = iNotifySendUssd->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySetUpCallPCmd:
            {
            ret = iNotifySetUpCall->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyRefreshPCmd:
            {
            ret = iNotifyRefresh->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyRefreshRequiredParam:
            {
            ret = iNotifyRefresh->CancelRefreshRequiredNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifyProactiveSimSessionEnd:
            {
            ret = iNotifySimSessionEnd->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySetUpIdleModeTextPCmd:
            {
            ret = iNotifySetUpIdleModeText->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyLaunchBrowserPCmd:
            {
            ret = iNotifyLaunchBrowser->CancelNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifyCallControlRequest:
            {
            ret = iNotifyCallControlRequest->CancelNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifySendDtmfPCmd:
            {
            ret = iNotifySendDtmf->CancelNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifySetUpEventListPCmd:
            {
            ret = iNotifySetUpEventList->CancelNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifyLanguageNotificationPCmd:
            {
            ret = iNotifyLanguageNotification->CancelNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifyLocalInfoPCmd:
            {
            ret = iNotifyLocalInfo->CancelNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifyOpenChannelPCmd:
            {
            iNotifyOpenChannel->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyMoSmControlRequest:
            {
            ret = iNotifyMoSmControlRequest->CancelNotification(
                aTsyReqHandle );
            break;
            }
        case ESatNotifyCloseChannelPCmd:
            {
            iNotifyCloseChannel->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyReceiveDataPCmd:
            {
            iNotifyReceiveData->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifySendDataPCmd:
            {
            iNotifySendData->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatNotifyGetChannelStatusPCmd:
            {
            iNotifyGetChannelStatus->CancelNotification( aTsyReqHandle );
            break;
            }
        case ESatEventDownload:
            {
            ret = iEventDownload->Cancel( aTsyReqHandle );
            break;
            }
        case ESatTerminalRsp:
        case ESatMenuSelection:
        case ESatSendMessageNoLogging:
        case ESatUsatClientReadyIndication:
            {
            ret = KErrNone;
            break;
            }
        // Following functions are not supported, hence they are completed
        // by DoExtFuncL function at once.
        // ETel server will not pass cancel function to MMSAT, because the
        // request is not 'ON' in ETel.
        // They are listed here for future reference.
        //
        // ESatGetMeSideSatProfile
        default:
            {
            TFLOGSTRING2("TSY: CTsySatMessaging::CancelService invalid IPC %d",aIpc);
            OstTrace1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_CANCELSERVICE_TD, "CTsySatMessaging::CancelService invalid IPC %d", aIpc );

            ret = KErrGeneral;
            break;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::ReqModeL
// ReqMode method for checking what modes this component supports
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CTelObject::TReqMode CTsySatMessaging::ReqModeL
        (
        const TInt aIpc     // IPC number of request
        )
    {
    OstTrace1( TRACE_NORMAL,  CTSYSATMESSAGING_REQMODEL_TD, "CTsySatMessaging::ReqModeL, IPC=%d", aIpc );
    TFLOGSTRING2("TSY: CTsySatMessaging::ReqModeL, IPC = %d",aIpc);
    CTelObject::TReqMode ret = 0;
    switch ( aIpc )
        {
        // Multiple Completion Services
        case ESatNotifyDisplayTextPCmd:
        case ESatNotifyGetInkeyPCmd:
        case ESatNotifyGetInputPCmd:
        case ESatNotifyPlayTonePCmd:
        case ESatNotifySetUpMenuPCmd:
        case ESatNotifySelectItemPCmd:
        case ESatNotifySendSmPCmd:
        case ESatNotifySendSsPCmd:
        case ESatNotifySendUssdPCmd:
        case ESatNotifySetUpCallPCmd:
        case ESatNotifyRefreshPCmd:
        case ESatNotifyCallControlRequest:
        case ESatNotifySendDtmfPCmd:
        case ESatNotifyMoSmControlRequest:
        case ESatNotifySetUpEventListPCmd:
        case ESatNotifySetUpIdleModeTextPCmd:
        case ESatNotifyProactiveSimSessionEnd:
        case ESatNotifyLaunchBrowserPCmd:
        case ESatNotifyPollingIntervalPCmd:
        case ESatNotifyPollingOffPCmd:
        case ESatNotifyLanguageNotificationPCmd:
        case ESatNotifyLocalInfoPCmd:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifyReceiveDataPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:
            {
            ret = KReqModeMultipleCompletionEnabled;
            break;
            }
        // Non-flow Controlled Services
        case ESatTerminalRsp:
        case ESatMenuSelection:
        case ESatEventDownload:
        case ESatGetIcon:
        case ESatGetImageInstance:
        case ESatGetClut:
        case ESatGetMeSideSatProfile:
        case ESatClientSatProfileIndication:
        case ESatSendMessageNoLogging:
        case ESatUsatClientReadyIndication:
            {
            break;
            }
        default:
            {
            TFLOGSTRING2( "TSY: CTsySatMessaging::ReqModeL unsupported IPC %d", aIpc );
            OstTrace1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_REQMODEL_TD, "CTsySatMessaging::ReqModeL unsupported IPC %d", aIpc );

            User::Leave( KErrNotSupported );
            break;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::Init
// Initializer method that is called by ETel Server
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::Init()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_INIT_TD, "CTsySatMessaging::Init" );
    TFLOGSTRING("TSY: CTsySatMessaging::Init");
    // none
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::RegisterNotification
// Register given command, checks if the given command is supported
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::RegisterNotification
        (
        const TInt aIpc     // IPC number of request
        )
    {
    OstTrace1( TRACE_NORMAL,  CTSYSATMESSAGING_REGISTERNOTIFICATION_TD, "CTsySatMessaging::RegisterNotification, IPC = %d", aIpc );
    TFLOGSTRING2("TSY: CTsySatMessaging::RegisterNotification, IPC = %d",aIpc);
    // Initialize return value
    TInt ret( KErrNone );
    switch ( aIpc )
        {
        case ESatNotifyDisplayTextPCmd:
        case ESatNotifyGetInkeyPCmd:
        case ESatNotifyGetInputPCmd:
        case ESatNotifyPlayTonePCmd:
        case ESatNotifySetUpMenuPCmd:
        case ESatNotifySelectItemPCmd:
        case ESatNotifySendSmPCmd:
        case ESatNotifySendSsPCmd:
        case ESatNotifySendUssdPCmd:
        case ESatNotifySetUpCallPCmd:
        case ESatNotifyRefreshPCmd:
        case ESatNotifyProactiveSimSessionEnd:
        case ESatNotifySetUpIdleModeTextPCmd:
        case ESatNotifyLaunchBrowserPCmd:
        case ESatNotifyCallControlRequest:
        case ESatNotifySendDtmfPCmd:
        case ESatNotifySetUpEventListPCmd:
        case ESatNotifyLanguageNotificationPCmd:
        case ESatNotifyLocalInfoPCmd:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifyReceiveDataPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyMoSmControlRequest:
        case ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:
            // ret already set to KErrNone
            break;
        // Following notifications are not supported,
        // hence listed here for future reference.
        //
        default:
            {
            // Unknown or invalid IPC
            TFLOGSTRING2("TSY: CTsySatMessaging::RegisterNotification, unsupported IPC %d", aIpc);
            OstTrace1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_REGISTERNOTIFICATION_TD, "CTsySatMessaging::RegisterNotification unsupported IPC %d", aIpc );

            ret = KErrNotSupported;
            break;
            }
        }
    return ret;

    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::DeregisterNotification
// DeRegister given command, checks if the given command is supported
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::DeregisterNotification
        (
        const TInt aIpc     // IPC number of request
        )
    {
    OstTrace1( TRACE_NORMAL,  CTSYSATMESSAGING_DEREGISTERNOTIFICATION_TD, "CTsySatMessaging::DeregisterNotification, IPC = %d", aIpc );
    TFLOGSTRING2( "TSY: CTsySatMessaging::DeregisterNotification\
        IPC = %d", aIpc );
    // Initialize return value
    TInt ret( KErrNone );
    switch ( aIpc )
        {
        case ESatNotifyDisplayTextPCmd:
        case ESatNotifyGetInkeyPCmd:
        case ESatNotifyGetInputPCmd:
        case ESatNotifyPlayTonePCmd:
        case ESatNotifySetUpMenuPCmd:
        case ESatNotifySelectItemPCmd:
        case ESatNotifySendSmPCmd:
        case ESatNotifySendSsPCmd:
        case ESatNotifySendUssdPCmd:
        case ESatNotifySetUpCallPCmd:
        case ESatNotifyRefreshPCmd:
        case ESatNotifyProactiveSimSessionEnd:
        case ESatNotifySetUpIdleModeTextPCmd:
        case ESatNotifyLaunchBrowserPCmd:
        case ESatNotifyCallControlRequest:
        case ESatNotifySendDtmfPCmd:
        case ESatNotifySetUpEventListPCmd:
        case ESatNotifyLanguageNotificationPCmd:
        case ESatNotifyLocalInfoPCmd:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifyReceiveDataPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyMoSmControlRequest:
        case ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:
            // ret already set to KErrNone
            break;
        // Following notifications are not supported,
        // hence listed here for future reference.
        //
        default:
            {
            // Unknown or invalid IPC
            TFLOGSTRING2("TSY: CTsySatMessaging::DeregisterNotification \
            unsupported IPC %d", aIpc);
            OstTrace1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_DEREGISTERNOTIFICATION_TD, "CTsySatMessaging::DeregisterNotification unsupported IPC %d", aIpc );

            ret = KErrNotSupported;
            break;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NumberOfSlotsL
// Returns number of slots to be used for given IPC
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::NumberOfSlotsL
        (
        const TInt aIpc        // IPC number of request
        )
    {
    OstTrace1( TRACE_NORMAL,  CTSYSATMESSAGING_NUMBEROFSLOTSL_TD, "CTsySatMessaging::NumberOfSlotsL IPC %d", aIpc );
    TFLOGSTRING2("TSY: CTsySatMessaging::NumberOfSlotsL IPC %d", aIpc);
    TInt numberOfSlots( 1 );
    switch ( aIpc )
        {
        case ESatNotifyDisplayTextPCmd:
            numberOfSlots = KSatNotifyDisplayTextPCmdSlots;
            break;
        case ESatNotifyGetInkeyPCmd:
            numberOfSlots = KSatNotifyGetInkeyPCmdSlots;
            break;
        case ESatNotifyGetInputPCmd:
            numberOfSlots = KSatNotifyGetInputPCmdSlots;
            break;
        case ESatNotifyPlayTonePCmd:
            numberOfSlots = KSatNotifyPlayTonePCmdSlots;
            break;
        case ESatNotifySetUpMenuPCmd:
            numberOfSlots = KSatNotifySetUpMenuPCmdSlots;
            break;
        case ESatNotifySelectItemPCmd:
            numberOfSlots = KSatNotifySelectItemPCmdSlots;
            break;
        case ESatNotifySendSmPCmd:
            numberOfSlots = KSatNotifySendSmPCmdSlots;
            break;
        case ESatNotifySendSsPCmd:
            numberOfSlots = KSatNotifySendSsPCmdSlots;
            break;
        case ESatNotifySendUssdPCmd:
            numberOfSlots = KSatNotifySendUssdPCmdSlots;
            break;
        case ESatNotifySetUpCallPCmd:
            numberOfSlots = KSatNotifySetUpCallPCmdSlots;
            break;
        case ESatNotifyRefreshPCmd:
            numberOfSlots = KSatNotifyRefreshPCmdSlots;
            break;
        case ESatNotifyProactiveSimSessionEnd:
            numberOfSlots = KSatNotifyProactiveSimSessionEndSlots;
            break;
        case ESatNotifySetUpIdleModeTextPCmd:
            numberOfSlots = KSatNotifySetUpIdleModeTextPCmdSlots;
            break;
        case ESatNotifyLaunchBrowserPCmd:
            numberOfSlots = KSatNotifyLaunchBrowserSlots;
            break;
        case ESatNotifyCallControlRequest:
            numberOfSlots = KSatNotifyCallControlRequestSlots;
            break;
        case ESatNotifySendDtmfPCmd:
            numberOfSlots = KSatNotifySendDtmfSlots;
            break;
        case ESatNotifySetUpEventListPCmd:
            numberOfSlots = KSatNotifySetUpEventListSlots;
            break;
        case ESatNotifyLanguageNotificationPCmd:
            numberOfSlots = KSatNotifySetUpEventListSlots;
            break;
        case ESatNotifyLocalInfoPCmd:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifyReceiveDataPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyMoSmControlRequest:
            numberOfSlots = KSatNotifySetUpEventListSlots;
            break;
        case ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:
            // default value: 1 slot
            break;
        // Following notifications are not supported,
        // hence listed here for future reference.
        //
        // For above, use numberOfSlots = 2
        default:
            {
            // Unknown or invalid IPC
            TFLOGSTRING2( "TSY: CTsySatMessaging::NumberOfSlotsL\
                unsupported IPC %d", aIpc );
            OstTrace1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_NUMBEROFSLOTSL_TD, "CTsySatMessaging::NumberOfSlotsL unsupported IPC %d", aIpc );

            User::Leave( KErrNotSupported );
            break;
            }
        }
    return numberOfSlots;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetSatMessHandler
// Returns pointer to the SatMessHandler instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatMessHandler* CTsySatMessaging::GetSatMessHandler()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETSATMESSHANDLER_TD, "CTsySatMessaging::GetSatMessHandler" );
    TFLOGSTRING("TSY:CTsySatMessaging::GetSatMessHandler");
    // Pointer to SAT message handler
    return iSatMessHandler;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetSatFlightModeStatus
// Returns pointer to the CSatFlightModeStatus instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatFlightModeStatus* CTsySatMessaging::GetSatFlightModeStatus()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETSATFLIGHTMODESTATUS_TD, "CTsySatMessaging::GetSatFlightModeStatus" );
    TFLOGSTRING("TSY:CTsySatMessaging::GetSatFlightModeStatus");
    // Pointer to SAT flight mode status
    return iSatFlightModeStatus;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::CompleteSendSmsMessage
// Completes a SAT Originated SMS sending request to Etel SAT client
// with the corresponding outcome.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::CompleteSendSmsMessage
        (
        TInt aStatus  // Message sending status from MMSMS
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_COMPLETESENDSMSMESSAGE_TD, "CTsySatMessaging::CompleteSendSmsMessage" );
    TFLOGSTRING("TSY: CTsySatMessaging::CompleteSendSmsMessage, entered");
    if ( iSendSmsTsyReqHandle )
        {
        ReqCompleted( iSendSmsTsyReqHandle, aStatus );
        iSendSmsTsyReqHandle = NULL;
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::MenuSelection
// Menu selection command handler from ETel SAT client application.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::MenuSelection
        (
        TDes8*          aSelection,     // Contains menu selection parameters
        TTsyReqHandle   aTsyReqHandle   // Request handle
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_MENUSELECTION_TD, "CTsySatMessaging::MenuSelection" );
    TFLOGSTRING("TSY:CTsySatMessaging::MenuSelection");
    TInt ret( KErrNone );
    RSat::TMenuSelectionV1Pckg* aPckg =
            REINTERPRET_CAST( RSat::TMenuSelectionV1Pckg*, aSelection );
    RSat::TMenuSelectionV1& selectionV1 = ( *aPckg ) ();
    TFLOGSTRING3("TSY:CTsySatMessaging::MenuSelection, iItemId %x, Help: %c",
        selectionV1.iItemId, selectionV1.iHelp );
    OstTraceExt1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_MENUSELECTION_TD, "CTsySatMessaging::MenuSelection iItemId: %hhu", selectionV1.iItemId );
    OstTrace1( TRACE_NORMAL,  DUP2_CTSYSATMESSAGING_MENUSELECTION_TD, "CTsySatMessaging::MenuSelection Help: %{THelpRequest}", selectionV1.iHelp );

    // Creating the menu selection message
    if ( selectionV1.iHelp == RSat::EHelpRequested )
        {
        // Help requested
        iSatMessHandler->MenuSelectionInd(
            GetTransactionId(),
            selectionV1.iItemId, KHelp ); // KHelp: 1
        }
    else
        {
        // No help requested
        iSatMessHandler->MenuSelectionInd(
            GetTransactionId(),
            selectionV1.iItemId, KNoHelp ); // KNoHelp: 0
        }
    ReqCompleted( aTsyReqHandle, ret );
    return ret;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NotifyCbDownload
// Cell broadcast data download from ETel SAT client application. Not in use.
// CellBroadcast DDL is handled in CSatDataDownload class.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::NotifyCbDownload
        (
        TDes8*          /*aPackage*/,     //package containing pointer to client
        TTsyReqHandle   aTsyReqHandle     //tsy request handle
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_NOTIFYCBDOWNLOAD_TD, "CTsySatMessaging::NotifyCbDownload" );
    TFLOGSTRING("TSY:CTsySatMessaging::NotifyCbDownload");
    TInt ret( KErrNone );
    ReqCompleted( aTsyReqHandle, ret );
    return ret;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NotifySmsPpDownload
// Sms-Pp data download from ETel SAT client application. Not in use.
// Sms-Pp DDL is handled in CSatDataDownload class.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::NotifySmsPpDownload
        (
        TDes8*          /*aPackage*/,   //package containing pointer to client
        TTsyReqHandle   aTsyReqHandle   //tsy request handle
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_NOTIFYSMSPPDOWNLOAD_TD, "CTsySatMessaging::NotifySmsPpDownload" );
    TFLOGSTRING("TSY:CTsySatMessaging::NotifySmsPpDownload");
    TInt ret( KErrNone );
    ReqCompleted( aTsyReqHandle, ret );
    return ret;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::SendMessageNoLoggingL
// Send SMS No Logging command handler from client application.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::SendMessageNoLoggingL
        (
        TDes8*          aMsg,           // Pointer to message
        TUint16*        /*aMsgRef*/,    // Message reference
        TTsyReqHandle   aTsyReqHandle   // Request handle
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_SENDMESSAGENOLOGGINGL_TD, "CTsySatMessaging::SendMessageNoLoggingL" );
    TFLOGSTRING("TSY: CTsySatMessaging::SendMessageNoLoggingL");
    TInt ret( KErrNone );
    // Save Reqhandle for CompleteSendSmsMessage
    iSendSmsTsyReqHandle = aTsyReqHandle;
    RSat::TSatSmsV1Pckg* aPckg = REINTERPRET_CAST( RSat::TSatSmsV1Pckg*, aMsg );
    RSat::TSatSmsV1& satSmsV1 = ( *aPckg ) ();
    // SMS GSM extension checks that SCA length is not over the max limit
    // that SMS allows
    // Check that we have a SCA address
    if ( 0x0 < satSmsV1.iServiceCenter.iTelNumber.Length() )
        {
        // SCA number conversion from unicode to GSM 3.40 format
        // is done by MMSMS dll
        // Set SCA pointer
        TDes16* sca;
        sca = &satSmsV1.iServiceCenter.iTelNumber;
        // Type of Number, mapping from ETelSat format to MMETel format
        RMobilePhone::TMobileTON numberType;
        switch ( satSmsV1.iServiceCenter.iTypeOfNumber )
            {
            case RSat::ETypeOfNumberNotSet:
            case RSat::EUnknownNumber:
                numberType = RMobilePhone::EUnknownNumber;
                break;
            case RSat::EInternationalNumber:
                numberType = RMobilePhone::EInternationalNumber;
                break;
            case RSat::ENationalNumber:
                numberType = RMobilePhone::ENationalNumber;
                break;
            case RSat::ENetworkSpecificNumber:
                numberType = RMobilePhone::ENetworkSpecificNumber;
                break;
            case RSat::EDedicatedNumber:
                numberType = RMobilePhone::ESubscriberNumber;
                break;
            default:
                // Unknown or invalid Type of Number
                numberType = RMobilePhone::EUnknownNumber;
                break;
            }
        // Numbering Plan, mapping from ETelSat format to MMETel format
        RMobilePhone::TMobileNPI numberPlan;
        switch ( satSmsV1.iServiceCenter.iNumberPlan )
            {
            case RSat::ENumberingPlanNotSet:
            case RSat::EUnknownNumberingPlan:
                numberPlan = RMobilePhone::EUnknownNumberingPlan;
                break;
            case RSat::EIsdnNumberPlan:
                numberPlan = RMobilePhone::EIsdnNumberPlan;
                break;
            case RSat::EDataNumberPlan:
                numberPlan = RMobilePhone::EDataNumberPlan;
                break;
            case RSat::ETelexNumberPlan:
                numberPlan = RMobilePhone::ETelexNumberPlan;
                break;
            case RSat::ENationalNumberPlan:
                numberPlan = RMobilePhone::ENationalNumberPlan;
                break;
            case RSat::EPrivateNumberPlan:
                numberPlan = RMobilePhone::EPrivateNumberPlan;
                break;
            default:
                // Unknown or invalid Numbering Plan
                numberPlan = RMobilePhone::EUnknownNumberingPlan;
                break;
            }
        // SMS message, Packet Data Unit
        TDes8* pdu;
        pdu = &satSmsV1.iBuf;

        #if (NCP_COMMON_S60_VERSION_SUPPORT==S60_VERSION_32)
        // Get SMS messaging class pointer for sending sms messages
        CMmSmsTsy* mmSmsTsy = iMmPhone->SmsSession();
        TFLOGSTRING2("TSY: CTsySatMessaging::SendMessageNoLoggingL, \
            mmSmsTsy: %x", mmSmsTsy );
        OstTrace1( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_SENDMESSAGENOLOGGINGL_TD, "CTsySatMessaging::SendMessageNoLoggingL, mmSmsTsy: %x", mmSmsTsy );

        if ( mmSmsTsy ) // Check that SMS session exist
            {
            // Call SMS sending function from MMSMS
            ret = mmSmsTsy->SendSatMessage( this, pdu, sca, &numberType,
                &numberPlan, EFalse, aTsyReqHandle );
            TFLOGSTRING2("TSY: CTsySatMessaging::SendMessageNoLoggingL, \
                SendSmsMessage done, ret: %x", ret );
            OstTrace1( TRACE_NORMAL,  DUP2_CTSYSATMESSAGING_SENDMESSAGENOLOGGINGL_TD, "CTsySatMessaging::SendMessageNoLoggingL, SendSmsMessage done, ret: %d", ret );
            }
        else
            {
            // No SMS session.
            ret = KErrNotReady;
            TFLOGSTRING("TSY: CTsySatMessaging::SendMessageNoLoggingL, \
            no SMS session!");
            OstTrace0( TRACE_NORMAL,  DUP3_CTSYSATMESSAGING_SENDMESSAGENOLOGGINGL_TD, "CTsySatMessaging::SendMessageNoLoggingL, no SMS session!" );
            }
        #else //NCP_COMMON_S60_VERSION_SUPPORT
        // Deliver attributes to message handler by using
        // TMobileSmsSendAttributesV1 class.
        RMobileSmsMessaging::TMobileSmsSendAttributesV1 msgAttrib;

        msgAttrib.iFlags = ( RMobileSmsMessaging::KSmsDataFormat |
        RMobileSmsMessaging::KGsmServiceCentre |
        RMobileSmsMessaging::KMoreToSend );

        msgAttrib.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;

        // if service center address length  > 20 digits plus "+" sign
        if ( sca->Length() > ( KMaxAmountOfDigits + 1 ) )
            {
            ret = KErrArgument;
            }
        else
            {
            msgAttrib.iGsmServiceCentre.iTelNumber.Copy( *sca );
            msgAttrib.iGsmServiceCentre.iTypeOfNumber = numberType;
            msgAttrib.iGsmServiceCentre.iNumberPlan = numberPlan;

            msgAttrib.iMore = EFalse;
            // create package
            CMmDataPackage package;

            // structure for all sms parameters and data
            TSendSmsDataAndAttributes sendData;

            sendData.iAttributes = &msgAttrib;
            sendData.iMsgData = pdu;
            sendData.iIpc = EMmTsySmsSendSatMessage;

            // Pack parameters
            package.PackData( &sendData );

            // send request to NTSY
            ret = iRouter->ExtFuncL( EMmTsySmsSendSatMessage, &package );
            }
        #endif //NCP_COMMON_S60_VERSION_SUPPORT
        }
    else // SCA missing
        {
        ret = KErrGeneral;
        TFLOGSTRING("TSY: CTsySatMessaging::SendMessageNoLoggingL, \
        SCA missing");
        OstTrace0( TRACE_NORMAL,  DUP4_CTSYSATMESSAGING_SENDMESSAGENOLOGGINGL_TD, "CTsySatMessaging::SendMessageNoLoggingL, SCA missing" );

        }
    // Failure in sending of SAT SMS, call complete method
    if ( KErrNone != ret )
        {
        CompleteSendSmsMessage( ret );
        TFLOGSTRING("TSY: CTsySatMessaging::SendMessageNoLoggingL, \
        failure sending SAT SMS, complete");
        OstTrace0( TRACE_NORMAL,  DUP5_CTSYSATMESSAGING_SENDMESSAGENOLOGGINGL_TD, "CTsySatMessaging::SendMessageNoLoggingL, failure sending SAT SMS, complete" );

        }
    return ret;

    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::TerminalResponse
// Terminal response command handler from ETel SAT client application.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::TerminalResponse
        (
        RSat::TPCmd*    aPCmd,          // SAT command identifier
        TDes8*          aRsp,           // Response
        TTsyReqHandle   aTsyReqHandle   // Request handle
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_TERMINALRESPONSE_TD, "CTsySatMessaging::TerminalResponse" );
    TFLOGSTRING("TSY: CTsySatMessaging::TerminalResponse");
    TInt ret( KErrNone );
    switch ( *aPCmd )
        {
        case RSat::EDisplayText:
            ret = iNotifyDisplayText->TerminalResponse( aRsp );
            break;
        case RSat::EGetInkey:
            ret = iNotifyGetInkey->TerminalResponse( aRsp );
            break;
        case RSat::EGetInput:
            ret = iNotifyGetInput->TerminalResponse( aRsp );
            break;
        case RSat::EPlayTone:
            ret = iNotifyPlayTone->TerminalResponse( aRsp );
            break;
        case RSat::ESetUpMenu:
            ret = iNotifySetUpMenu->TerminalResponse( aRsp );
            break;
        case RSat::ESelectItem:
            ret = iNotifySelectItem->TerminalResponse( aRsp );
            break;
        case RSat::ESendSm:
            ret = iNotifySendSm->TerminalResponse( aRsp );
            break;
        case RSat::ESendSs:
            ret = iNotifySendSs->TerminalResponse( aRsp );
            break;
        case RSat::ESendUssd:
            ret = iNotifySendUssd->TerminalResponse( aRsp );
            break;
        case RSat::ESetUpCall:
            ret = iNotifySetUpCall->TerminalResponse( aRsp );
            break;
        case RSat::ERefresh:
            ret = iNotifyRefresh->TerminalResponse( aRsp );
            break;
        case RSat::ESetUpIdleModeText:
            ret = iNotifySetUpIdleModeText->TerminalResponse(aRsp );
            break;
        case RSat::ELaunchBrowser:
            ret = iNotifyLaunchBrowser->TerminalResponse( aRsp );
            break;
        case RSat::ESendDtmf:
            ret = iNotifySendDtmf->TerminalResponse( aRsp );
            break;
        case RSat::ESetUpEventList:
            ret = iNotifySetUpEventList->TerminalResponse( aRsp );
            break;
        case RSat::ELocalInfo:
            ret = iNotifyLocalInfo->TerminalResponse( aRsp );
            break;
        case RSat::ELanguageNotification:
            ret = iNotifyLanguageNotification->TerminalResponse( aRsp );
            break;
        case RSat::EOpenChannelCs:
        case RSat::EOpenChannelGprs:
        case RSat::EOpenChannelLocal:
            ret = this->iNotifyOpenChannel->TerminalResponse( aRsp );
            break;
        case RSat::EGetChannelStatus:
            ret = iNotifyGetChannelStatus->TerminalResponse( aRsp );
            break;
        case RSat::ECloseChannel:
             ret = iNotifyCloseChannel->TerminalResponse( aRsp );
            break;
        case RSat::EReceiveData:
            ret = iNotifyReceiveData->TerminalResponse( aRsp );
            break;
        case RSat::ESendData:
            ret = iNotifySendData->TerminalResponse( aRsp );
            break;
        default:
            TFLOGSTRING("TSY: CTsySatMessaging::TerminalResponse, \
            PCmd not supported");
            OstTrace0( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_TERMINALRESPONSE_TD, "CTsySatMessaging::TerminalResponse, PCmd not supported" );

            ret =  KErrGeneral;
            break;
        }
    ReqCompleted( aTsyReqHandle, ret );
    return ret;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::PCmdReceivedL
// Handles an incoming proactive command from ISA CellMo SIM server
// Called by CSatMessHandler when it receives proactive command ISI msg
// originated by ISA CellMo SIM server.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::PCmdReceivedL( const TIsiReceiveC& aIsiMessage )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_PCMDRECEIVEDL_TD, "CTsySatMessaging::PCmdReceivedL" );
    TFLOGSTRING("TSY: CTsySatMessaging::PCmdReceivedL");
    CBerTlv berTlv;
    berTlv.BerTlv( aIsiMessage );
    CTlv commandDetails;
    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );
    //set flag on to indicate that proactive command is ongoing
    iSatTimer->SetProactiveCommandOnGoingStatus( ETrue );
    // Routes to a suitable MessageReceived method, in order to
    // process the PCmd ISI message.
    switch( commandDetails.GetShortInfo( ETLV_TypeOfCommand ) )
        {
        case KDisplayText:
            iNotifyDisplayText->MessageReceived( aIsiMessage );
            break;
        case KGetInkey:
            iNotifyGetInkey->MessageReceived( aIsiMessage );
            break;
        case KGetInput:
            iNotifyGetInput->MessageReceived( aIsiMessage );
            break;
        case KPlayTone:
            iNotifyPlayTone->MessageReceived( aIsiMessage );
            break;
        case KSetUpMenu:
            iNotifySetUpMenu->MessageReceived( aIsiMessage );
            break;
        case KSelectItem:
            iNotifySelectItem->MessageReceived( aIsiMessage );
            break;
        case KSendShortMessage:
            iNotifySendSm->MessageReceived( aIsiMessage );
            break;
        case KSendSs:
            iNotifySendSs->MessageReceived( aIsiMessage );
            break;
        case KSendUssd:
            iNotifySendUssd->MessageReceived( aIsiMessage );
            break;
        case KSetUpCall:
            iNotifySetUpCall->MessageReceived( aIsiMessage );
            break;
        case KRefresh:
            iNotifyRefresh->MessageReceived( aIsiMessage );
            break;
        case KSetUpIdleModeText:
            iNotifySetUpIdleModeText->MessageReceived( aIsiMessage );
            break;
        case KPollInterval:
            iNotifyPollInterval->MessageReceived( aIsiMessage );
            break;
        case KSendDtmf:
            iNotifySendDtmf->MessageReceived( aIsiMessage );
            break;
        case KSetUpEventList:
            iNotifySetUpEventList->MessageReceived( aIsiMessage );
            break;
        case KPollingOff:
            iNotifyPollingOff->MessageReceived( aIsiMessage );
            break;
        case KProvideLocalInformation:
            iNotifyLocalInfo->MessageReceived( aIsiMessage );
            break;
        case KTimerManagement:
            iNotifyTimerMgmt->MessageReceived( aIsiMessage );
            break;
        case KMoreTime:
            iNotifyMoreTime->MessageReceived( aIsiMessage );
            break;
        case KLaunchBrowser:
            iNotifyLaunchBrowser->MessageReceived( aIsiMessage );
            break;
        case KLanguageNotification:
            iNotifyLanguageNotification->MessageReceived( aIsiMessage );
            break;
        case KGetChannelStatus:
            iNotifyGetChannelStatus->MessageReceived( aIsiMessage );
            break;
        case KOpenChannel:
            iNotifyOpenChannel->MessageReceived( aIsiMessage );
            break;
        case KCloseChannel:
            iNotifyCloseChannel->MessageReceived( aIsiMessage );
            break;
        case KReceiveData:
            iNotifyReceiveData->MessageReceived( aIsiMessage );
            break;
        case KSendData:
            iNotifySendData->MessageReceived( aIsiMessage );
            break;
        default:
            {
            TFLOGSTRING("TSY: CTsySatMessaging::PCmdReceivedL, PCmd not supported");
            OstTrace0( TRACE_NORMAL,  DUP1_CTSYSATMESSAGING_PCMDRECEIVEDL_TD, "CTsySatMessaging::PCmdReceivedL, PCmd not supported" );

            // If proactive command is not supported, terminal response
            // with "Command is beyond ME's capabilities" information
            // will be send. ProactiveCommandOngoing status will be set
            // to EFalse in SendTerminalResponseL().
            TBuf8<5> cmdDetails;
            cmdDetails.Copy( commandDetails.Data() );
            TTlv tlvSpecificData;
            // Create General Result TLV here
            tlvSpecificData.AddTag( KTlvResultTag );
            // General result
            tlvSpecificData.AddByte( KCommandBeyondMeCapabilities );
            iSatMessHandler->UiccCatReqTerminalResponse(
                cmdDetails,
                tlvSpecificData.GetDataWithoutTopLevelTag() ,
                aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::TimerExpiration
// Timer Expiration handler
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::TimerExpiration
        (
        TInt aTimerId,
        TUint32 aTimerValue
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_TIMEREXPIRATION_TD, "CTsySatMessaging::TimerExpiration" );
    TFLOGSTRING("TSY: CTsySatMessaging::TimerExpiration");
    TUint8 time[3] = {0, 0, 0};
    TInt num[3];
    num[0] = aTimerValue/3600;         //hours
    num[1] = ( aTimerValue%3600 )/60;  //minutes
    num[2] = ( aTimerValue%3600 )%60;  //seconds
    for ( TInt i = 0; i < 3; i++)
        {
        //convert to semi-octet
        time[i] = TSatUtility::ConvertToSemiOctet( num[i] );
        }
    return iSatMessHandler->TimerExpirationInd(
            GetTransactionId(),
            (TUint8)aTimerId,
            time );

    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetSatTimer
// Returns pointer to the SatTimer instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatTimer* CTsySatMessaging::GetSatTimer()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETSATTIMER_TD, "CTsySatMessaging::GetSatTimer" );
    // Pointer to SAT timer
    return iSatTimer;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetNotifyRefresh
// Returns pointer to the CSatNotifyRefresh instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatNotifyRefresh* CTsySatMessaging::GetNotifyRefresh()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETNOTIFYREFRESH_TD, "CTsySatMessaging::GetNotifyRefresh" );
    return iNotifyRefresh;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetDataDownload
// Returns pointer to the CSatDataDownload instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatDataDownload* CTsySatMessaging::GetDataDownload()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETDATADOWNLOAD_TD, "CTsySatMessaging::GetDataDownload" );
    return iSatDataDownload;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetNotifyPollInterval
// Returns pointer to the NotifyPollInterval instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatNotifyPollInterval* CTsySatMessaging::GetNotifyPollInterval()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETNOTIFYPOLLINTERVAL_TD, "CTsySatMessaging::GetNotifyPollInterval" );
    return iNotifyPollInterval;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetMoSmsCtrl
// Returns pointer to the CSatMoSmsCtrl instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatMoSmsCtrl* CTsySatMessaging::GetMoSmsCtrl()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETMOSMSCTRL_TD, "CTsySatMessaging::GetMoSmsCtrl" );
    return iSatMoSmsCtrl;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetEventDownload
// Returns pointer to the CSatEventDownload instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatEventDownload* CTsySatMessaging::GetEventDownload()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETEVENTDOWNLOAD_TD, "CTsySatMessaging::GetEventDownload" );
    return iEventDownload;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetNotifyPollingOff
// Returns pointer to the NotifyPollingOff instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatNotifyPollingOff* CTsySatMessaging::GetNotifyPollingOff()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETNOTIFYPOLLINGOFF_TD, "CTsySatMessaging::GetNotifyPollingOff" );
    return iNotifyPollingOff;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetNotifyLocalInfo
// Returns pointer to the NotifyLocalInfo instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatNotifyLocalInfo* CTsySatMessaging::GetNotifyLocalInfo()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETNOTIFYLOCALINFO_TD, "CTsySatMessaging::GetNotifyLocalInfo" );
    return iNotifyLocalInfo;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::EventDownloadReceived
// Processes ISI messages that are relevant for event download
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::EventDownloadReceived
        (
        const TIsiReceiveC& aIsiMessage //Event download message
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_EVENTDOWNLOADRECEIVED_TD, "CTsySatMessaging::EventDownloadReceived" );
    iEventDownload->MessageReceived( aIsiMessage );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::SetUpEventList
// Set up requested events that have to be reported to the SIM
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::SetUpEventList
        (
        TUint32 aEvents //events to be monitored
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_SETUPEVENTLIST_TD, "CTsySatMessaging::SetUpEventList" );
    iEventDownload->SetUpEventList( aEvents );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::SessionEnd
// Notifies client about end of session
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::SessionEnd
        (
        const TIsiReceiveC& aIsiMessage //message ending session
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_SESSIONEND_TD, "CTsySatMessaging::SessionEnd" );
    iNotifySimSessionEnd->MessageReceived( aIsiMessage );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NotifyClientAboutCallControlEvent
// Notifies Etel SAT client about call control event
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::NotifyClientAboutCallControlEvent
        (
        TDesC&                  aAlphaId, //Alpha id of call control event
        RSat::TControlResult    aResult
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_NOTIFYCLIENTABOUTCALLCONTROLEVENT_TD, "CTsySatMessaging::NotifyClientAboutCallControlEvent" );
    iNotifyCallControlRequest->CompleteNotification( aAlphaId, aResult );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NotifyClientAboutCallControlEventL
// Notifies Etel SAT client about call control event
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::NotifyClientAboutCallControlEventL
        (
        const TUint8 aCcResult,
        TPtrC8 aEnvelopeResponse
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_NOTIFYCLIENTABOUTCALLCONTROLEVENTL_TD, "CTsySatMessaging::NotifyClientAboutCallControlEventL" );
    iNotifyCallControlRequest->CompleteNotificationL( aCcResult, aEnvelopeResponse );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NotifyClientAboutGprsCallControlEvent
// Notifies Etel SAT client about GPRS call control event
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::NotifyClientAboutGprsCallControlEvent
        (
        const TDesC&                aAlphaId,
        const RSat::TControlResult  aResult
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_NOTIFYCLIENTABOUTGPRSCALLCONTROLEVENT_TD, "CTsySatMessaging::NotifyClientAboutGprsCallControlEvent" );
    iNotifyCallControlRequest->CompleteNotification(
        aAlphaId,
        aResult );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::NotifyClientAboutMoSmControlEvent
// Notifies client about Mo-Sms control event
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::NotifyClientAboutMoSmControlEvent
        (
        TDesC&                  aAlphaId, //Alpha id of MO-SMS control event
        RSat::TControlResult    aResult
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_NOTIFYCLIENTABOUTMOSMCONTROLEVENT_TD, "CTsySatMessaging::NotifyClientAboutMoSmControlEvent" );
    iNotifyMoSmControlRequest->CompleteNotification( aAlphaId, aResult );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetTransactionId
// Get new transaction id
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TUint8 CTsySatMessaging::GetTransactionId()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETTRANSACTIONID_TD, "CTsySatMessaging::GetTransactionId" );
    return iTransIdMsg->GetTransactionId( );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::SatReady
// Sat ready indication
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::SatReady
        (
        TUint8 aMsg // Message to be retrieved
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_SATREADY_TD, "CTsySatMessaging::SatReady" );
    return iPnReceive->SatReady( aMsg );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::ClearCCArrays
// Clears the array containing call control event data, due to
// a refresh PCmd.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::ClearCCArrays()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_CLEARCCARRAYS_TD, "CTsySatMessaging::ClearCCArrays" );
    iSatCC->ClearArraysForRefresh();
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::CallControlReceivedL
// Processes ISI messages that are relevant for call control
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::CallControlReceivedL
        (
        const TIsiReceiveC& aIsiMessage
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_CALLCONTROLRECEIVEDL_TD, "CTsySatMessaging::CallControlReceivedL" );
    iSatCC->MessageReceivedL( aIsiMessage );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::DataDownloadReceivedL
// Processes ISI messages that are relevant for call control
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::DataDownloadReceivedL
        (
        const TIsiReceiveC& aIsiMessage
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_DATADOWNLOADRECEIVEDL_TD, "CTsySatMessaging::DataDownloadReceivedL" );
    iSatDataDownload->MessageReceivedL( aIsiMessage );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::MoSmsControlReceivedL
// Processes ISI messages that are relevant for MoSm control
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::MoSmsControlReceivedL
        (
        const TIsiReceiveC& aIsiMessage
        )
    {
    TFLOGSTRING("TSY: CTsySatMessaging::MoSmsControlReceivedL");
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_MOSMSCONTROLRECEIVEDL_TD, "CTsySatMessaging::MoSmsControlReceivedL" );
    if ( iSatMoSmsCtrl->IsActivated() )
        {
        iSatMoSmsCtrl->MessageReceivedL( aIsiMessage );
        }
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::IsMoSmControlBySimActivated
// This methods returns ETrue if MoSmControl
// is activated. Otherwise, it returns EFalse
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CTsySatMessaging::IsMoSmControlBySimActivated()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_ISMOSMCONTROLBYSIMACTIVATED_TD, "CTsySatMessaging::IsMoSmControlBySimActivated" );
    return iSatMoSmsCtrl->IsActivated();
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::GetSatIcon
// Returns pointer to the SatIcon instance
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CSatIcon* CTsySatMessaging::GetSatIcon()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETSATICON_TD, "CTsySatMessaging::GetSatIcon" );
    // Pointer to SAT timer
    return iSatIcon;
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::StoreCallConnectedEvent
// Cache call connected envelope
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::StoreCallConnectedEvent
        (
        const TDesC8& aEnvelope
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_STORECALLCONNECTEDEVENT_TD, "CTsySatMessaging::StoreCallConnectedEvent" );
    iNotifySetUpCall->StoreCallConnectedEvent( aEnvelope );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::SetSetUpCallStatus
// Updates the status of SetUpCall command in SatEventDownload instance.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::SetSetUpCallStatus
        (
        const TBool aStatus
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_SETSETUPCALLSTATUS_TD, "CTsySatMessaging::SetSetUpCallStatus" );
    iEventDownload->SetSetUpCallStatus( aStatus );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::SetStatusOfUssdSupport
// Set CSatCC internal flag according to EF-SimServiceTable.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::SetStatusOfUssdSupport
        (
        const TBool aStatus
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_SETSTATUSOFUSSDSUPPORT_TD, "CTsySatMessaging::SetStatusOfUssdSupport" );
    iSatCC->SetStatusOfUssdSupport( aStatus );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::SetTonNpi
// Set CSatCC internal Ton and Npi
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::SetTonNpi
        (
        const TUint8 aTonNpi
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_SETTONNPI_TD, "CTsySatMessaging::SetTonNpi" );
    iSatCC->SetTonNpi( aTonNpi );
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::StoreSms
// Request the storing of SMS from CommonTsy
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CTsySatMessaging::StoreSmsL
        (
        RMobileSmsStore::TMobileGsmSmsEntryV1& aSmsEntry
        )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_STORESMSL_TD, "CTsySatMessaging::StoreSmsL" );
    #if ( NCP_COMMON_S60_VERSION_SUPPORT == S60_VERSION_32 )
    RMobileSmsStore::TMobileGsmSmsEntryV1Pckg smsPckg( aSmsEntry );

    // Pack data and forward request to DOS
    TDesC8* data = reinterpret_cast<TDesC8*>( &smsPckg );

    CMmDataPackage package;
    package.PackData( &data, &aSmsEntry.iIndex );

    TRAPD( ret, ret = iMmPhone->MessageManager()->HandleRequestL(
        EMobilePhoneStoreWrite, &package ) );

    // Return leave code or return status of method.
    return ret;
    #else
    RMobileSmsStore::TMobileGsmSmsEntryV1Pckg smsPckg( aSmsEntry );
    TInt ret = KErrNone;

    // Pack data and forward request to DOS
    TDesC8* data = reinterpret_cast<TDesC8*>( &smsPckg );

    CMmDataPackage package;
    package.PackData( &data, &aSmsEntry.iIndex );

    ret = iRouter->ExtFuncL( EMobilePhoneStoreWrite, &package );

    return ret;
    #endif //NCP_COMMON_S60_VERSION_SUPPORT
    }

// -----------------------------------------------------------------------------
// CTsySatMessaging::UsatClientReadyIndication
// Inform SIMSON that (U)SAT client has sent all notifications and is ready to
// receive proactive commands or that flight mode is on and (U)SAT client cannot
// receive proactive commands.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CTsySatMessaging::UsatClientReadyIndication( TTsyReqHandle aTsyReqHandle )
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_USATCLIENTREADYINDICATION_TD, "CTsySatMessaging::UsatClientReadyIndication" );
    TFLOGSTRING("TSY: CTsySatMessaging::UsatClientReadyIndication");

    // Set SAT ready flag in satmesshandler
    iSatMessHandler->SetSatReadyStatus( ETrue );

    // If UICC server is ready, send command to enable or disable proactive
    // commands
    if ( iSatMessHandler->GetTerminalProfileStatus() )
        {
        if ( ! iSatFlightModeStatus->FlightModeStatusValue() )
            {
            iSatMessHandler->UiccCatReq( UICC_CAT_ENABLE );
            }
        else
            {
            iSatMessHandler->UiccCatReq( UICC_CAT_DISABLE );
            }
        }

    // Complete ReqHandle immediately for preventing blocking of Etel server
    // Client do not care about return value
    ReqCompleted( aTsyReqHandle, KErrNone );
    }

#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
// -----------------------------------------------------------------------------
// CTsySatMessaging::GetMessageRouter
// Returns pointer to message router
// (other items were commented in a header)
// -----------------------------------------------------------------------------
//
CMmMessageRouter* CTsySatMessaging::GetMessageRouter()
    {
    OstTrace0( TRACE_NORMAL,  CTSYSATMESSAGING_GETMESSAGEROUTER_TD, "CTsySatMessaging::GetMessageRouter" );
    return iRouter;
    }
#endif

// ================= OTHER EXPORTED FUNCTIONS ==================================

//  End of File
