// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// Name        : CSatTsy.cpp
// Part of     : Common SIM ATK TSY / commonsimatktsy
// Main entry point for Etel requests
// Version     : 1.0  
//



//  INCLUDE FILES
#include <etelsat.h>                // Etel SAT API
#include <satcs.h>                  // Etel SAT API
//#include "CMmPhoneTsy.h"			// Phone Tsy class
#include "CSatDataPackage.h"		// For data packages
//#include "MmTsy_numberOfSlots.h"    // Number of Slots
#include "cmmmessagemanagerbase.h"	// Message manager base
#include <ctsy/pluginapi/mmessagerouter.h>
#include <ctsy/serviceapi/mctsysatservice.h>
//#include "CMmMessageRouterBase.h"	// Message router

//#include "CMmSmsTsy.h"              // MmSmsTsy
//#include "CMmMessageManager.h"      // Message manager

#include "CSatTsy.h"				// Messaging class
#include "CSatCCTsy.h"              // SatCallControl class
#include "CSatIconTsy.h"            // SatIcon class
#include "CSatNotificationsTsy.h"   // SatNotifications class
#include "CSatNotifySetUpCall.h"    // CSatNotifySetUpCall    
#include "CSatEventDownloadTsy.h"   // SatEventDownload class
#include "CSatDataDownloadTsy.h"    // SatDataDownload class

#include "msattsy_ipcdefs.h"		// Sat Tsy specific request types
#include "TfLogger.h"               // For TFLOGSTRING
#include "TSatUtility.h"		    // Sat Tsy Utility class
#include "TTlv.h"					// TTlv class
#include "CSatTsyReqHandleStore.h"  // Request handle storage

#include "stktsy_number_of_slots.h"

// -----------------------------------------------------------------------------
// CSatTsy::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSatTsy* CSatTsy::NewL
		(
		MMessageRouter& aMmMessageRouter,
		MCtsySatService& aSatService
		)
    {
    TFLOGSTRING("CSAT: CSatTsy::NewL");

	// Create subsession
    CSatTsy* subsession = new ( ELeave ) CSatTsy( aMmMessageRouter, aSatService );

    CleanupStack::PushL( subsession );
    subsession->ConstructL();
    CleanupStack::Pop();

	TFLOGSTRING("CSAT: CSatTsy::NewL, end of method");
    return subsession;
    }

// -----------------------------------------------------------------------------
// CSatTsy::~CSatTsy
// Destructor
// -----------------------------------------------------------------------------
// 
CSatTsy::~CSatTsy
		(
		// None
		)
    {
    TFLOGSTRING("CSAT: CSatTsy::~CSatTsy");

    // Unregister.
    iMessageManager->RegisterTsyObject(
		CMmMessageManagerBase::ESatTsyObjType, NULL );

    // Delete also specific TSY objects
    delete iSatCCTsy;
    delete iSatIconTsy;
    delete iSatNotificationsTsy;
    delete iSatDataDownloadTsy;
    delete iSatEventDownloadTsy;
	// Message router and message manager are deleted here
    delete iMessageManager;
    // Request handle store
    delete iSatReqHandleStore;
    TFLOGSTRING("CSAT: CSatTsy::~CSatTsy, end of method");
    }

// -----------------------------------------------------------------------------
// CSatTsy::CSatTsy
// C++ constructor
// -----------------------------------------------------------------------------
//
CSatTsy::CSatTsy
		( 
        MMessageRouter& aMmMessageRouter,
        MCtsySatService& aSatService
		): 
		iMessageRouter ( aMmMessageRouter ),
		iSatService(aSatService)
    {
    // None
    }

// -----------------------------------------------------------------------------
// CSatTsy::ConstructL
// Symbian 2nd phase constructor. Initialises internal attributes.
// -----------------------------------------------------------------------------
//
void CSatTsy::ConstructL
		( 
        )
    { 
    TFLOGSTRING("CSAT: CSatTsy::ConstructL");
    
    // Set pointer to the message router 
    iMessageManager = CMmMessageManagerBase::NewL(iMessageRouter);
   
    // Register
    iMessageManager->RegisterTsyObject(
		CMmMessageManagerBase::ESatTsyObjType, this );

    // Create request handle store
    iSatReqHandleStore = CSatTsyReqHandleStore::NewL( 
        ESatMaxNumOfRequests, iSatReqHandles );

	// Create IconTsy instance
	iSatIconTsy = CSatIconTsy::NewL( this );
	// Create NotificationsTsy instance
	iSatNotificationsTsy = CSatNotificationsTsy::NewL( 
        this, iSatReqHandleStore );              
    // Create CCTsy instance
    iSatCCTsy = CSatCCTsy::NewL( this, iSatNotificationsTsy );
    // Create DataDownloadTsy instance
    iSatDataDownloadTsy = CSatDataDownloadTsy::NewL( this );
    // Create EventDownloadTsy instance
	iSatEventDownloadTsy = CSatEventDownloadTsy::NewL( this );
	
    // Request to read Cbmids
#ifdef USING_CTSY_DISPATCHER
	//Commented out due to not seemingly doing anything as the STK TSY does not hold EF_cbmid cache
    //iSatDataDownloadTsy->CompleteReadCbmidsL( );
    // Request Network status (removed as no known completion)   
    //iMessageManager->HandleRequestL( ESatTsyNetStatus );
    // Check if guardians should be activated (removed as no known completion)
	//iMessageManager->HandleRequestL( ESatTsyCallControlActivation );
	//Check if the SIM card suppords USSD tlv's in the call control envelopes (removed as no known completion)
	//iMessageManager->HandleRequestL( ESatTsyUssdControlActivation );
	// Get the default bearer data
	iMessageManager->HandleRequestL( ESatTsyGetBearerCapability );
	//prime the cached version of this setting
	iMessageManager->HandleRequestL( ESatTsyUssdStatus);
#else
	iSatDataDownloadTsy->CompleteReadCbmidsL( );
	// Request Network status    
	iMessageManager->HandleRequestL( ESatTsyNetStatus );
	// Check if guardians should be activated
	iMessageManager->HandleRequestL( ESatTsyCallControlActivation );
	//Check if the SIM card suppords USSD tlv's in the call control envelopes
	iMessageManager->HandleRequestL( ESatTsyUssdControlActivation );
	// Get the default bearer data
	iMessageManager->HandleRequestL( ESatTsyGetBearerCapability );
#endif //USING_CTSY_DISPATCHER
	// Notify Licencee SIM ATK TSY that we are ready to receive messages
	iMessageManager->HandleRequestL( ESatTsyReady );
	// Get SMS Point to Point Data Download support status
    iMessageManager->HandleRequestL( ESatTsySmsPpDdlStatus );
	
	TFLOGSTRING("CSAT: CSatTsy::ConstructL, end of method");
    }
    
// -----------------------------------------------------------------------------
// CSatTsy::ExtFunc
// TRAP's all CSatTsy related Etel API requests in cases that they fail.
// -----------------------------------------------------------------------------
//
TInt CSatTsy::ExtFunc
		( 
		const TTsyReqHandle aTsyReqHandle,  
		const TInt aIpc,           
		const TDataPackage& aPackage        
		)
    {
    TFLOGSTRING3("CSAT: CSatTsy::ExtFunc ReqHandle=%d IPC=%d", aTsyReqHandle, 
        aIpc);
	TInt ret( KErrNone );

    // Some SAT functions need trapping so we 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 if after IPC handling function has called ReqComplete, 
    // then it doesn't Leave.
    TInt trapError( KErrNone );

    TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ) );

    if ( KErrNone != trapError )
        {
        TFLOGSTRING2("CSAT: CSatTsy::ExtFunc, trapError: %d", trapError );
        ReqCompleted( aTsyReqHandle, trapError );
        }
	else if ( KErrNone != ret )
        {
        TFLOGSTRING2("CSAT: CSatTsy::ExtFunc, ret: %d", ret);
        ReqCompleted( aTsyReqHandle, ret );
        }
    else										
	    {
        // Reset last Tsy request type
        iReqHandleType = ESatReqHandleUnknown;
        }

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CSatTsy::SaveReqHandle
// Saves the request handle
// -----------------------------------------------------------------------------
//
void CSatTsy::SaveReqHandle
		( 
		const TTsyReqHandle aTsyReqHandle,  
        const TSatRequestTypes aSatRequestType
		)
    {
    TFLOGSTRING3("CSAT: CSatTsy::SaveReqHandle ReqHandle=%d ReqHandleType=%d", 
        aTsyReqHandle, aSatRequestType);
    
    // Don't save the request handle if the type is unknown.
    if ( ESatReqHandleUnknown != aSatRequestType )
        {
        iSatReqHandleStore->SetTsyReqHandle( aSatRequestType, aTsyReqHandle );
        }
    }

// -----------------------------------------------------------------------------
// CSatTsy::ReqModeL
// Mode service function used by ETel, request mode. ReqModeL is called from 
// the server's CTelObject::ReqAnalyserL in order to check the type of request
// it has.
// -----------------------------------------------------------------------------
//
CTelObject::TReqMode CSatTsy::ReqModeL
		( 
		const TInt aIpc    
		)
    {
    TFLOGSTRING("CSAT: CSatTsy::ReqModeL.");
    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 ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:        
        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 ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyReceiveDataPCmd:               
            {
            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:
            {
            break;
            }
        default:
            {
            TFLOGSTRING2("CSAT: CSatTsy::ReqModeL unsupported IPC %d", aIpc);
            User::Leave( KErrNotSupported );
            break;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CSatTsy::CancelService
// Cancels Sat requests
// -----------------------------------------------------------------------------
//
TInt CSatTsy::CancelService
		( 
		const TInt aIpc,           
		const TTsyReqHandle aTsyReqHandle   
		)
    {
    TFLOGSTRING3("CSAT: CSatTsy::CancelService ReqHandle=%d IPC=%d", 
        aTsyReqHandle, aIpc);
    TInt ret( KErrNotSupported );

	// When the clients close their sub-sessions (eg. by calling RLine::Close), 
    // they may not have cancelled all their outstanding asynchronous requests 
    // before closing.  It is up to the ETel server to clean up in this 
    // situation, so the server will find the list of outstanding requests 
    // related to that sub-session object and pass these outstanding IPC 
    // request numbers, one at a time, to the CancelService method in the TSY.

    switch ( aIpc )
        {
        case ESatTerminalRsp:
        case ESatMenuSelection:
        //case ESatSendMessageNoLogging:
            {
            ret = KErrNone;
            break;
            }
        case ESatNotifyCallControlRequest:
		case ESatNotifyMoSmControlRequest:        
        case ESatNotifyDisplayTextPCmd:
        case ESatNotifyGetInkeyPCmd:
        case ESatNotifyGetInputPCmd:
        case ESatNotifyPlayTonePCmd:
        case ESatNotifySetUpMenuPCmd:
        case ESatNotifySelectItemPCmd:
        case ESatNotifySetUpCallPCmd:
        case ESatNotifySendSmPCmd:
        case ESatNotifySendSsPCmd:
        case ESatNotifySendUssdPCmd:   
        case ESatNotifyRefreshPCmd:
        case ESatNotifyRefreshRequiredParam:
        case ESatNotifySetUpIdleModeTextPCmd:
        case ESatNotifySendDtmfPCmd:
        case ESatNotifyLaunchBrowserPCmd:
        case ESatNotifyLocalInfoPCmd:
        case ESatNotifyLanguageNotificationPCmd:
        case ESatNotifySetUpEventListPCmd:
        case ESatNotifyProactiveSimSessionEnd:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyReceiveDataPCmd:       
            {
            ret = iSatNotificationsTsy->CancelService ( aIpc, aTsyReqHandle );
            break;
            }
        
        case ESatEventDownload:
            {
            ret = iSatEventDownloadTsy->CancelService ( aIpc, aTsyReqHandle );
            break;
            }
        
        // Following functions are not supported, hence they are completed
        // by DoExtFuncL function at once.
        // ETel server will not pass cancel function to SAT, because the 
        // request is not 'ON' in ETel.
        // They are listed here for future reference.
        //

        // ESatNotifyMoSmControlRequest
        // ESatEventDownload
        // ESatGetMeSideSatProfile

        default:
            {
            TFLOGSTRING2("CSAT: CSatTsy::CancelService invalid IPC %d", aIpc);
            ret = KErrGeneral; 
            break;           	
            }
        }
    return ret;

    }
        
// -----------------------------------------------------------------------------
// CSatTsy::RegisterNotification
// ETel Server subscribe notifications from NOS. RegisterNotification is called
// when the server recognises that this notification is being posted for the 
// first time on this sub-session object. It enables the TSY to "turn on" any 
// regular notification messages that it may receive from the phone.
// -----------------------------------------------------------------------------
//
TInt CSatTsy::RegisterNotification
		( 
		const TInt aIpc    // IPC number of request
		)
    {
    TFLOGSTRING("CSAT: CSatTsy::RegisterNotification.");
    // 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 ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:        
        case ESatNotifyProactiveSimSessionEnd:
        case ESatNotifySetUpIdleModeTextPCmd:
        case ESatNotifyLaunchBrowserPCmd:
        case ESatNotifyCallControlRequest:
		case ESatNotifySendDtmfPCmd:
        case ESatNotifySetUpEventListPCmd:
        case ESatNotifyLanguageNotificationPCmd:
        case ESatNotifyLocalInfoPCmd:
        case ESatNotifyMoSmControlRequest:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyReceiveDataPCmd:      
            {
            // Ret already set to KErrNone
            break;
            }
        default:
            {
            // Unknown or invalid IPC
            TFLOGSTRING2("CSAT: CSatTsy::RegisterNotification, \
                Unsupported IPC %d", aIpc);
            ret = KErrNotSupported;
            break;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CSatTsy::DeregisterNotification
// ETel server unsubscribe notifications from NOS. DeregisterNotification is 
// called when the server recognizes that this notification will not be posted 
// again because the last client to have a handle on this sub-session object  
// has just closed the handle. It enables the TSY to "turn off" any regular 
// notification messages that it may receive from the phone.
// -----------------------------------------------------------------------------
//
TInt CSatTsy::DeregisterNotification
		( 
		const TInt aIpc    // IPC number of request
		)
    {
    TFLOGSTRING("CSAT: CSatTsy::DeregisterNotification.");
    // 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 ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:        
        case ESatNotifyProactiveSimSessionEnd:
        case ESatNotifySetUpIdleModeTextPCmd:
        case ESatNotifyLaunchBrowserPCmd:
        case ESatNotifyCallControlRequest:
		case ESatNotifySendDtmfPCmd:		
        case ESatNotifySetUpEventListPCmd:
        case ESatNotifyLanguageNotificationPCmd:
        case ESatNotifyLocalInfoPCmd:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyMoSmControlRequest:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyReceiveDataPCmd:       
            {
            // Ret already set to KErrNone
            break;
            }
        default:
            {
            // Unknown or invalid IPC
            TFLOGSTRING2("CSAT: CSatTsy::DeregisterNotification, \
                Unsupported IPC %d", aIpc);
            ret = KErrNotSupported;
            break;            	
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CSatTsy::NumberOfSlotsL
// Returns number of slots to be used for given IPC. NumberOfSlotsL is called 
// by the server when it is registering a new notification. It enables the TSY 
// to tell the server how many buffer slots to allocate for "repost 
// immediately" notifications that may trigger before clients collect them.
// -----------------------------------------------------------------------------
//
TInt CSatTsy::NumberOfSlotsL
		( 
		const TInt aIpc    // IPC number of request
		)
    {
    TFLOGSTRING("CSAT: CSatTsy::NumberOfSlotsL.");
    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 is set to one
        	break;        	
        	}
        default:
            {
            // Unknown or invalid IPC
            TFLOGSTRING2("CSAT: CSatTsy::NumberOfSlotsL, Unsupported IPC %d", 
                aIpc);
            User::Leave( KErrNotSupported );
            break;
            }
        }  
    return numberOfSlots;
    }

// -----------------------------------------------------------------------------
// CSatTsy::ReqCompleted
// Completes requests to ETel
// -----------------------------------------------------------------------------
//
void CSatTsy::ReqCompleted
		( 
		TTsyReqHandle aReqHandle,
        TInt aRet 
        )
	{
	TFLOGSTRING2("CSAT: CSatTsy::ReqCompleted, ReqHandle=%d ", aReqHandle);
#ifdef USING_CTSY_DISPATCHER
	CTelObject::ReqCompleted( aReqHandle, aRet );
#else
	ReqCompleted( aReqHandle, aRet );
#endif //USING_CTSY_DISPATCHER
	}
	
// -----------------------------------------------------------------------------
// CSatTsy::StoreCallConnectedEvent
// Cache call connected envelope to CSatNotifySetUpCall class
// -----------------------------------------------------------------------------
//
void CSatTsy::StoreCallConnectedEvent
        (
        const TDesC8& aEnvelope
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::StoreCallConnectedEvent");
    iSatNotificationsTsy->SatNotifySetUpCall()->StoreCallConnectedEvent( 
        aEnvelope );
    }

// -----------------------------------------------------------------------------
// CSatTsy::SetSetUpCallStatus
// Set Status of SetUpCall command to the CSatEventDownloadTsy class
// -----------------------------------------------------------------------------
//
void CSatTsy::SetSetUpCallStatus
        (
        const TBool aStatus
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::SetSetUpCallStatus");
    iSatEventDownloadTsy->SetSetUpCallStatus( aStatus );
    }

// -----------------------------------------------------------------------------
// CSatTsy::SetUpEventList
// Sets events that are reported to NAA
// -----------------------------------------------------------------------------
//
void CSatTsy::SetUpEventList
        (
        TUint32 aEvents     // events to be monitored
        ) 
    {
    TFLOGSTRING("CSAT: CSatTsy::SetUpEventList");
    iSatEventDownloadTsy->SetUpEventList( aEvents );
    }

// -----------------------------------------------------------------------------
// CSatTsy::MessageManager
// This method returns a pointer to iMessageManager object.
// -----------------------------------------------------------------------------
//
CMmMessageManagerBase* CSatTsy::MessageManager
        (
        // none
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::MessageManager");
    return iMessageManager;
    }

// -----------------------------------------------------------------------------
// CSatTsy::SatCCTsy
// This method returns a pointer to Call Control TSY object.
// -----------------------------------------------------------------------------
//
CSatCCTsy* CSatTsy::SatCCTsy
        (
        // none
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::SatCCTsy");
    return iSatCCTsy;
    }  

// -----------------------------------------------------------------------------
// CSatTsy::GetSatReqHandleStore
// Returns iSatReqHandleStore pointer and control to calling object
// -----------------------------------------------------------------------------
//
CSatTsyReqHandleStore* CSatTsy::GetSatReqHandleStore
	    (
	    //none
	    )
	{
    TFLOGSTRING("CSAT: CSatTsy::GetSatReqHandleStore");
	return iSatReqHandleStore;
	}

// -----------------------------------------------------------------------------
// CSatTsy::GetReqHandleType
// Returns pointer to request handle type
// -----------------------------------------------------------------------------
//
CSatTsy::TSatRequestTypes* CSatTsy::GetReqHandleType
	    (
	    //none
	    )
	{
    TFLOGSTRING("CSAT: CSatTsy::GetReqHandleType");
	return &iReqHandleType;
	}

// -----------------------------------------------------------------------------
// CSatTsy::CompleteSendSmsMessage
// Message from MMSMS side that message sending has been completed
// -----------------------------------------------------------------------------
//
TInt CSatTsy::CompleteSendSmsMessage
        (
        TInt aStatus 
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::CompleteSendSmsMessage");
    
    // Reset req handle. Returns the deleted req handle
    TTsyReqHandle reqHandle = iSatNotificationsTsy->RequestHandleStore()->
        ResetTsyReqHandle( CSatTsy::ESatSendMessageNoLoggingReqType );
		
	// In case the request was ongoing, continue..
    if ( CSatTsy::ESatReqHandleUnknown != reqHandle )
        {
    	ReqCompleted( reqHandle, aStatus );
        }
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CSatTsy::IsMoSmControlBySimActivated
// This method is required by CommonTSY, which needs to know whether the 
// MoSmControlBySim is activated or not.
// -----------------------------------------------------------------------------
//
TBool CSatTsy::IsMoSmControlBySimActivated
		(
		void
		)
    {
    TFLOGSTRING("CSAT: CSatTsy::IsMoSmControlBySimActivated");
    return iSatNotificationsTsy->IsMoSmControlActivated();
    }

#ifdef USING_CTSY_DISPATCHER
    /**
     * From MStkTsyCallOrigin 
     * Dummy implementation for IsSimOriginatedCall function
     *          
     * @param aAddress The number whose origin is required.
     * @return ETrue if call originates from a Proactive Command
     */ 
TBool CSatTsy::IsSimOriginatedCall
			(
			const TDesC8& aAddress
			)
	{
	TFLOGSTRING("CSAT: CSatTsy::IsSimOriginatedCall");
	TBool ret = EFalse;
	if (iSatCCTsy)
		{
		ret = iSatCCTsy->HasProactiveOrigin(aAddress);
		}
	return ret;
	}
#endif //USING_CTSY_DISPATCHER

// -----------------------------------------------------------------------------
// CSatTsy::StoreProactiveAddress
// Stores latest address of Send SS/Setup call proactive command to CSatCC
// (other items were commented in a header). Method is also called when 
// proactive session is over with parameter NULL.
// -----------------------------------------------------------------------------
//    
void CSatTsy::StoreProactiveAddress
        ( 
        const TDesC8* aAddress 
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::StoreProactiveAddress");
    iSatCCTsy->StoreAddressForCC( *aAddress );
    }  
    
// -----------------------------------------------------------------------------
// CSatTsy::SetTonNpi
// Stores Ton Npi to CSatCC
// -----------------------------------------------------------------------------
//    
void CSatTsy::SetTonNpi
        ( 
        const TUint8 aTonNpi 
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::SetTonNpi");
    iSatCCTsy->SetTonNpiForSS( aTonNpi );
    }  
    
// -----------------------------------------------------------------------------
// CSatTsy::DoExtFuncL
// Dispatch to correct SAT Tsy/function according to the IPC
// -----------------------------------------------------------------------------
//
TInt CSatTsy::DoExtFuncL
		(
		const TTsyReqHandle aTsyReqHandle,  
		const TInt aIpc,           
		const TDataPackage& aPackage	
		)
    {
    TFLOGSTRING3("CSAT: CSatTsy::DoExtFuncL\t IPC:%d,\t Handle:%d",
           aIpc, aTsyReqHandle);
	TInt ret( KErrNone );

	// Add here ALL supported Sat request types, and call either the correct 
	//	Sat Tsy to handle the request, or a request directly here in CSatTsy.
    switch ( aIpc )
        {
        // General
        case ESatMenuSelection:
            {
            ret = MenuSelectionL( aTsyReqHandle, 
				reinterpret_cast<RSat::TMenuSelectionV1Pckg*>( 
				aPackage.Des1n() ) );
            break;
            }
        case ESatSendMessageNoLogging:
            {
            SendMessageNoLogging( aPackage.Des1n(), aTsyReqHandle );
            break;
            }
        // Icon
        case ESatGetIcon:
		case ESatGetImageInstance:
		case ESatGetClut:
            {
            ret = iSatIconTsy->DoExtFuncL ( aTsyReqHandle, aIpc, aPackage );
            break;
            }
        // Notifications
        case ESatTerminalRsp:
        case ESatNotifyCallControlRequest:
        case ESatNotifyDisplayTextPCmd:
        case ESatNotifyGetInkeyPCmd:
        case ESatNotifyGetInputPCmd:
        case ESatNotifyPlayTonePCmd:
        case ESatNotifySetUpMenuPCmd:
        case ESatNotifySelectItemPCmd:
        case ESatNotifySendSmPCmd:
        case ESatNotifySendSsPCmd:
        case ESatNotifySendUssdPCmd:
        case ESatNotifySetUpCallPCmd:
		case ESatNotifyRefreshPCmd:
        case ESatNotifyRefreshRequiredParam:
        case ESatRefreshAllowed:
        case ESatNotifySetUpEventListPCmd:
        case ESatNotifySetUpIdleModeTextPCmd:
        case ESatNotifySendDtmfPCmd:
        case ESatNotifyLanguageNotificationPCmd:
        case ESatNotifyLaunchBrowserPCmd:
        case ESatNotifyLocalInfoPCmd:   
        case ESatNotifyProactiveSimSessionEnd:
        case ESatNotifyOpenChannelPCmd:
        case ESatNotifyGetChannelStatusPCmd:
        case ESatNotifyCloseChannelPCmd:
        case ESatNotifySendDataPCmd:
        case ESatNotifyReceiveDataPCmd:
        case ESatNotifySmsPpDownload:
        case ESatNotifyCbDownload:
		case ESatNotifyMoSmControlRequest:                    
            {
            iSatNotificationsTsy->DoExtFuncL ( aTsyReqHandle, aIpc, aPackage );
            break;
            }
        // EventDownload
        case ESatEventDownload:
            {
            ret = iSatEventDownloadTsy->DoExtFuncL ( aTsyReqHandle, aIpc, 
                aPackage );
            break;
            }
        // Tsy internal requests
        // Not supported
        /*
        case ESatGetMeSideSatProfile:
        case ESatClientSatProfileIndication:
        case ESatUsatClientReadyIndication:
        case ESatGetProvisioningRefFile:
        case ESatNotifyRefreshRequired:
        // Notifications
        case ESatNotifyPerformCardApduPCmd:
        case ESatNotifyPowerOffCardPCmd:
        case ESatNotifyPowerOnCardPCmd:
        case ESatNotifyGetReaderStatusPCmd:
        case ESatNotifyRunAtCommandPCmd:
		case ESatNotifyPollingOff:
		case ESatNotifyPollingInterval:
        case ESatNotifyServiceSearchPCmd:
        case ESatNotifyGetServiceInfoPCmd:
        case ESatNotifyDeclareServicePCmd:
        case ESatNotifyProactiveSimSessionStart:
        case ESatNotifyTimerExpiration:
        case ESatNotifyTimerMgmtPCmd:
        case ESatNotifyTsyStateUpdated:
        */

		// Complete with KErrNotSupported, function not supported
		default:
			{
			TFLOGSTRING2("CSAT: CSatTsy::DoExtFuncL unsupported IPC %d", aIpc);
			ReqCompleted( aTsyReqHandle, KErrNotSupported );
			break;
			}
        }

    return ret;
    }

// -----------------------------------------------------------------------------
// CSatTsy::MenuSelection
// Passes a menu selection response to DOS
// -----------------------------------------------------------------------------
//
TInt CSatTsy::MenuSelectionL
		(
		TTsyReqHandle   aTsyReqHandle,			
		RSat::TMenuSelectionV1Pckg* aSelection	
		) 
    {
    TFLOGSTRING("CSAT: CSatTsy::MenuSelection");
    TInt ret( KErrNone );

	// It should not be possible that the request is asked more than once at 
	// time, therefore we do not need to check whether it is already ongoing

	RSat::TMenuSelectionV1& selectionV1 = ( *aSelection ) ();
	TFLOGSTRING3("CSAT:MenuSelection, iItemId %x, Help: %c", 
		selectionV1.iItemId, selectionV1.iHelp );

    TTlv tlvSpecificData;
    
    tlvSpecificData.Begin( KBerTlvMenuSelectionTag );
    tlvSpecificData.AddTag( KTlvDeviceIdentityTag );
    tlvSpecificData.AddByte( KKeypad );
    tlvSpecificData.AddByte( KSim );
    tlvSpecificData.AddTag( KTlvItemIdentifierTag );
    tlvSpecificData.AddByte( selectionV1.iItemId );

	// If user has requested help, add tag.
    if ( RSat::EHelpRequested == selectionV1.iHelp )
        {
        tlvSpecificData.AddTag( KTlvHelpRequestTag );
        }

	// Pack parameter for DOS call.
    TPtrC8 berTlv = tlvSpecificData.End();
	CSatDataPackage dataPackage;
	dataPackage.PackData( &berTlv );

	ret = iMessageManager->HandleRequestL( ESatMenuSelection, &dataPackage );

	if ( KErrNone == ret )
        {
    	// We must complete the request to the client right away, as an
    	// indication that the request has been handled
    	ReqCompleted( aTsyReqHandle, ret );    
        }
    
    return ret; 
    }

// -----------------------------------------------------------------------------
// CSatTsy::SendMessageNoLogging
// Called by ETel server, passes SMS message to MMSMS
// -----------------------------------------------------------------------------
//
TInt CSatTsy::SendMessageNoLogging
        (
        TDes8* aMsg,           
        TTsyReqHandle   aTsyReqHandle   
        )
    {
    TFLOGSTRING("CSAT: CSatTsy::SendMessageNoLogging");
    TInt ret( KErrNone );
	
	// Save the request handle
    SaveReqHandle( aTsyReqHandle, ESatSendMessageNoLoggingReqType );
	
    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;

        // Call SMS sending function from MMSMS
        ret = iSatService.SendSatMessage( *this, pdu, sca, &numberType, 
                &numberPlan, EFalse, aTsyReqHandle );
        TFLOGSTRING2("CSAT: CSatTsy::SendMessageNoLogging, \
                SendSmsMessage done, ret: %x", ret);
       
       
        }
    else // SCA missing
        {
        ret = KErrGeneral;
        TFLOGSTRING("CSAT: CSatTsy::SendMessageNoLogging, SCA missing");
        }

    // Failure in sending of SAT SMS, call complete method
    if ( KErrNone != ret )
        {
        CompleteSendSmsMessage( ret ); 
        TFLOGSTRING("CSAT: CSatTsy::SendMessageNoLogging, \
            failure sending SAT SMS, complete");
        }
    
    return KErrNone;

    }     

MmMessageManagerCallback* CSatTsy::GetMessageManagerCallback()    
{
	return iMessageManager->GetMessageManagerCallback();
}


//  End of File  
