/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

*

*/

// INCLUDE FILES

#include "satmesshandler.h"     // sat message handler class

#include "satmessaging.h"       // sat messaging 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 "cmmphonetsender.h"    // phonet sender

#include "terminalprofile.h"    // terminal profile

#include "satflightmodestatus.h"// flight mode status

#include <pn_const.h>           // server id constants

#include <tisi.h>               // isi message

#include <ss_wmisi.h>           // ss server

#include <infoisi.h>            // info server

#include <net_modemisi.h>       // net server

#include <gssisi.h>             // gss server

#include <call_modemisi.h>      // Call Modem server

#include <smsisi.h>             // sms server

#include <uiccisi.h>            // UICC server

#include <gpdsisi.h>            // GPDS server

#include <atk_sharedisi.h>

#include <call_sharedisi.h>

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

// CONSTANTS

const TUint8 KOneByteLengthLimit                = 0x7F;

// Maximum value for get input string

const TUint8 KGetInputStringMaxSize             = 0xEF;

// No transaction ongoing

const TInt KNoTransactionOngoing                = -1;

// Time zone not available

const TUint8 KTimeZoneNotAvailable              = 0xFF;

// Access Technology unknown

const TUint8 KAccTechUnknown                    = 0xFF;

// This is a common length constant (2 bytes)

const TUint8 KLengthTwoBytes                    = 0x02;

// Maximum polling interval of legacy phones

const TUint8 KMaxLegacyPollInterval             = 0x19; // 25 decimal

// Size of one clut entry in bytes

const TUint16 KClutEntrySize                    = 3;

// Padding bytes for UICC messages

const TUint8 KUiccPadding                       = 0x00;

// Size of terminal profile subblock

const TUint8 KSizeOfTerminalProfileSb           = 40;

// Offset of UICC_APPL_CMD_REQ message for adding subblocks

const TUint8 KUiccApplCmdReqOffset(

    ISI_HEADER_SIZE + SIZE_UICC_APPL_CMD_REQ );

// Size of UICC_SB_APPL_PATH

const TUint8 KUiccSbApplPathSize(

    SIZE_UICC_SB_APPL_PATH + KUiccFilePathLength );

// UICC file IDs

const TUint16 KUiccMasterFileId( 0x3F00 );

const TUint16 KUiccElemFileServiceTable( 0x6F38 );

const TUint16 KUiccDedicatedFileTelecom( 0x7F10 );

const TUint16 KUiccDedicatedFileGraphics( 0x5F50 );

const TUint16 KUiccElemFileImg( 0x4F20 );

const TUint8 KUiccSfiServiceTable( 4 );

// Number of subblocks in UICC_APPL_CMD_REQ

const TUint8 KNumOfSbsInUiccApplCmdReq( 3 );

// Max size of UICC_SB_TERMINAL_PROFILE

const TUint16 KMaxSizeOfUiccSbTerminalResponse( 264 );

// Length of device identity TLV data object

const TUint8 KTlvDeviceIdentityLength( 2 );

// Max length of UICC_SB_AID

const TUint16 KMaxLengthUiccSbAid( 260 );

// Elementary file ID length

const TUint8 KUiccFileIdLength( 2 );

// Maximum size of envelope

const TUint16  KMaxSizeOfEnvelope( 256 );

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

// -----------------------------------------------------------------------------

// CSatMessHandler::CSatMessHandler

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CSatMessHandler::CSatMessHandler

        (

        CTsySatMessaging*   aTsySatMessaging,

        CMmPhoNetSender*    aPnSend

        )

        :

        iTsySatMessaging( aTsySatMessaging ),

        iPnSend( aPnSend )

    {

    OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CSATMESSHANDLER, "CSatMessHandler::CSatMessHandler" );

    // >= 0 if there is ongoing transaction

    iTerminalRespTraId              = KNoTransactionOngoing;

    iGetIconSimReadFieldTraId       = KNoTransactionOngoing;

    iDataDownloadSimReadFieldTraId  = KNoTransactionOngoing;

    iCardId                         = KZero;

    // By default, there's no need to request routing from SMS server

    iSmsCbRoutingComplete           = ETrue;

    iRefreshRequestIsOn             = EFalse;

    iTimingAdvance                  = GSS_TIMING_ADVANCE_NOT_AVAILABLE;

    iTaStatus                       = GSS_TIMING_ADVANCE_NOT_VALID;

    iTimeZone                       = KTimeZoneNotAvailable;

    iSimServerObjectId              = KZero;

    iCurrentAccTech                 = KAccTechUnknown;

    // Set polling status to the use of the default value (25 sec.)

    iPollingOff                     = ETrue;

    iSsStatus                       = ENotBusy;

    // No long poll interval requests yet

    iLongPollIntervalReq            = EFalse;

#ifdef INFO_PP_ATK_MO_SM_CONTROL

    // MO SMS support not yet read from product profile

    iMoSmsSupportedInPp             = EFalse;

#endif // INFO_PP_ATK_MO_SM_CONTROL

#ifdef INFO_PP_ENHANCED_NETWORK_SELECTION

    // ENS support not yet read from product profile

    iEnsSupportedInPp               = EFalse;

    // SET UP EVENT LIST TR not yet sent

    iSetUpEventListTrSent           = EFalse;

#endif // INFO_PP_ENHANCED_NETWORK_SELECTION

    // Init location info structure

    iLocInfo.iOperatorCode.FillZ( iLocInfo.iOperatorCode.MaxLength() );

    iLocInfo.iLac.FillZ( iLocInfo.iLac.MaxLength() );

    iLocInfo.iCellId.FillZ( iLocInfo.iCellId.MaxLength() );

    iLocInfo.iRegStatus = NET_NO_COVERAGE;

    // Init IMEI of the ME

    iIMEI.FillZ( 16 ); // KSerialNumberLength + 1

    // Clear NMR (Network Measurement result)

    iNMR.Zero();

    // Clear BCCH channel list

    iBCCHChannelList.Zero();

    // Clear UTRAN measurement result

    iUtranNMR.Set( KNullDesC8 );

    // ME is not yet in service during startup

    iPreviousRegistrationStatus = NET_REG_STATUS_NOSERV_SEARCHING;

    // INFO_PP_SIM_OLD_POLL_INTERVAL flag not read yet

    iOldPollIntervalSupportedInPp = ETrue;

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::~CSatMessHandler

// Destructor.

// -----------------------------------------------------------------------------

//

CSatMessHandler::~CSatMessHandler()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_CSATMESSHANDLER, "CSatMessHandler::~CSatMessHandler" );

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CSatMessHandler* CSatMessHandler::NewL

        (

        CTsySatMessaging*   aTsySatMessaging,

        CMmPhoNetSender*    aPnSend

        )

    {

    OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NEWL, "CSatMessHandler::NewL" );

    TFLOGSTRING("TSY:CSatMessHandler::NewL");

    CSatMessHandler* self = new( ELeave ) CSatMessHandler( aTsySatMessaging,

        aPnSend );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::ConstructL

// Symbian 2nd phase constructor can leave

// -----------------------------------------------------------------------------

//

void CSatMessHandler::ConstructL()

    {

    TFLOGSTRING("TSY:CSatMessHandler::ConstructL");

    OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_CONSTRUCTL, "CSatMessHandler::ConstructL" );

    // This flag is set to 'true' when indication ESatUsatClientReadyIndication

    // is received from SAT server. CAT can be enabled when the state of this

    // flag is 'true' and also UICC server is ready.

    iSatReady = EFalse;

    // Application ID will be set when UICC_APPLICATION_IND is received

    iApplicationId = 0xFF;

    // UICC client ID will be set when UICC_APPLICATION_RESP is received

    iUiccClientId = 0;

    // Terminal profile status flag is set 'true' when terminal profile has been

    // sent to prevent CAT enabling request to be sent before terminal profile

    iTerminalProfileSent = EFalse;

    // Card type is not known yet

    iCardType = UICC_CARD_TYPE_UNKNOWN;

    // Application file id is initialize to 'FFFF'

    TBuf8<2> unknownFileId;

    unknownFileId.Append( 0xFF );

    unknownFileId.Append( 0xFF );

    iApplFileId.Copy( unknownFileId );

    iPollingInterval = KDefaultPollInterval;

    iImageCodingScheme = KBlackAndWhite;

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::ProactiveProcedureMessageReceivedL

// Called SatMessHandler::ReceivedL, handles Event download,

// Call control, Data Download and MO-SMS Control related messages

// -----------------------------------------------------------------------------

//

void CSatMessHandler::ProactiveProcedureMessageReceivedL

        (

        const TIsiReceiveC& aIsiMessage

        )

    {

    OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_PROACTIVEPROCEDUREMESSAGERECEIVEDL, "CSatMessHandler::ProactiveProcedureMessageReceivedL" );

    TFLOGSTRING("TSY:CSatMessHandler::ProactiveProcedureMessageReceivedL");

    // handle event download and related messages

    iTsySatMessaging->EventDownloadReceived( aIsiMessage );

    // handle call control and releated messages

    iTsySatMessaging->CallControlReceivedL( aIsiMessage );

    // handle Data Download and related messages

    iTsySatMessaging->DataDownloadReceivedL( aIsiMessage );

    // handle MO-SMS Control related messages

    iTsySatMessaging->MoSmsControlReceived( aIsiMessage );

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::NetServerMessageReceived

// Called from SatMessHandler::ReceivedL, handles Net Server related messages

// -----------------------------------------------------------------------------

//

void CSatMessHandler::NetServerMessageReceived

        (

        const TIsiReceiveC& aIsiMessage // ISI message

        )

    {

    OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_NETSERVERMESSAGERECEIVED, "CSatMessHandler::NetServerMessageReceived" );

    TFLOGSTRING("TSY:CSatMessHandler::NetServerMessageReceived");

    TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

    switch ( messageId )

        {

        case NET_CELL_INFO_IND:

            {

            StoreNetServiceStatus( aIsiMessage );

            // If SMS CB routing is still pending, regenerate routing request.

            // This might be the case if CS was inactive or SIM is not ready

            // during the first request.

            if ( !iSmsCbRoutingComplete )

                {

                TFLOGSTRING("TSY:CSatMessHandler::NetServerMessageReceived \

                    Sending delayed SMS CB routing request.");

                OstTrace0( TRACE_NORMAL, DUP1_CSATMESSHANDLER_NETSERVERMESSAGERECEIVED, "CSatMessHandler::NetServerMessageReceived Sending delayed SMS CB routing request." );

                SmsCbRoutingReq(

                    iTsySatMessaging->GetTransactionId(), SMS_ROUTING_SET );

                }

            break;

            }

        case NET_NEIGHBOUR_CELLS_RESP:

            {

            NetNeighbourCellResp( aIsiMessage );

            break;

            }

        case NET_CELL_INFO_GET_RESP:

            {

            NetCellInfoGetResp( aIsiMessage );

            break;

            }

        case NET_TIME_IND:

            {

            NetTimeInd( aIsiMessage );

            break;

            }

        case NET_RAT_RESP:

            {

            NetRatResp( aIsiMessage );

            break;

            }

        case NET_RAT_IND:

            {

            NetRatInd( aIsiMessage );

            break;

            }

        default:

            {

            // Do nothing

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::PhoneInfoMessageReceived

// Called from SatMessHandler::ReceivedL, handles Phone Info related messages

// -----------------------------------------------------------------------------

//

void CSatMessHandler::PhoneInfoMessageReceived

        (

        const TIsiReceiveC& aIsiMessage // ISI message

        )

    {

    OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_PHONEINFOMESSAGERECEIVED, "CSatMessHandler::PhoneInfoMessageReceived" );

    TFLOGSTRING("TSY:CSatMessHandler::PhoneInfoMessageReceived");

    TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

    switch ( messageId )

        {

        case INFO_SERIAL_NUMBER_READ_RESP:

            {

            InfoSerialNumberReadResp( aIsiMessage );

            break;

            }

        case INFO_PP_READ_RESP:

            {

            InfoPpReadResp( aIsiMessage );

            break;

            }

        default:

            {

            // do nothing

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::UiccServerMessageReceived

// Called from SatMessHandler::ReceivedL, handles UICC Server messages

// -----------------------------------------------------------------------------

//

TBool CSatMessHandler::UiccServerMessageReceived(

    const TIsiReceiveC& aIsiMessage )

    {

    TUint8 messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

    OstTraceExt1( TRACE_NORMAL, DUP3_CSATMESSHANDLER_UICCSERVERMESSAGERECEIVED, "CSatMessHandler::UiccServerMessageReceived;messageId=%hhu", messageId );

    TFLOGSTRING2("TSY:CSatMessHandler::UiccServerMessageReceived, message ID: %d", messageId );

    TBool handled( EFalse );

    switch ( messageId )

        {

        case UICC_CAT_IND:

            {

            UiccCatInd( aIsiMessage );

            break;

            }

        case UICC_CAT_RESP:

            {

            TUint8 serviceType(

                aIsiMessage.Get8bit(

                    ISI_HEADER_SIZE + UICC_CAT_RESP_OFFSET_SERVICETYPE ) );

            TUint8 status(

                aIsiMessage.Get8bit(

                    ISI_HEADER_SIZE + UICC_CAT_RESP_OFFSET_STATUS ) );

            TFLOGSTRING3("TSY:CSatMessHandler:: KUiccCatResp: service type %d, status %d", serviceType, status);

            OstTraceExt2( TRACE_NORMAL, DUP2_CSATMESSHANDLER_UICCSERVERMESSAGERECEIVED, "CSatMessHandler::KUiccCatResp;serviceType=%hhu;status=%hhu", serviceType, status );

            // If terminal profile was sent succesfully and SAT is ready,

            // start fetching proactive commands

            if ( UICC_CAT_TERMINAL_PROFILE == serviceType &&

                UICC_STATUS_OK == status )

                {

                // If SAT is not ready, CAT enable request cannot be sent yet.

                // When indication of SAT ready is received by satmessaging,

                // CAT enable request is sent if this flag is set to 'true'.

                iTerminalProfileSent = ETrue;

                // Enable or disable proactive command fetching depending on

                // flight mode status

                if ( iSatReady )

                    {

                    // Get instance of CSatFlightModeStatus for flight mode

                    // status

                    CSatFlightModeStatus* satFlightModeStatus(

                        iTsySatMessaging->GetSatFlightModeStatus() );

                    if ( ! satFlightModeStatus->FlightModeStatusValue() )

                        {

                        UiccCatReq( UICC_CAT_ENABLE );

                        }

                    else

                        {

                        UiccCatReq( UICC_CAT_DISABLE );

                        }

                    }

                }

            // Response for refresh command

            else if ( UICC_CAT_REFRESH == serviceType )

                {

                RefreshResult( status );

                }

            // Response for polling set command

            else if ( UICC_CAT_POLLING_SET == serviceType  )

                {

                SetPollingResult(

                    status,

                    aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ),

                    iPollingInterval );

                }

            // Response for envelope

            else if ( UICC_CAT_ENVELOPE == serviceType )

                {

                handled = UiccCatRespEnvelope( aIsiMessage );

                }

            // Response for terminal response

            else if ( UICC_CAT_TERMINAL_RESPONSE  == serviceType )

                {

                handled = UiccCatRespTerminalResponse( aIsiMessage );

                }

            break;

            }

        case UICC_APPLICATION_RESP:

            {

            TUint uiccSbClientOffset( 0 );

            if ( KErrNone == aIsiMessage.FindSubBlockOffsetById(

                ISI_HEADER_SIZE + SIZE_UICC_APPLICATION_RESP,

                UICC_SB_CLIENT,

                EIsiSubBlockTypeId16Len16,

                uiccSbClientOffset ) )

                {

                iUiccClientId = aIsiMessage.Get8bit(

                    uiccSbClientOffset + UICC_SB_CLIENT_OFFSET_CLIENTID );

                }

            break;

            }

        case UICC_APPLICATION_IND:

            {

            // Application ID is needed when reading data from UICC

            iApplicationId = aIsiMessage.Get8bit(

                ISI_HEADER_SIZE + UICC_APPLICATION_IND_OFFSET_APPLID );

            // Access to UICC files is possible when application is active

            TUint8 serviceType( aIsiMessage.Get8bit(

                ISI_HEADER_SIZE + UICC_APPLICATION_IND_OFFSET_SERVICETYPE ) );

            if ( UICC_APPL_ACTIVATED == serviceType )

                {

                // USIM and SIM: Read SMS-PP DD and Call Control from byte 4.

                // Only USIM: MO-SMS control from byte 4

                UiccReadServiceTableReq( KUiccTrIdServiceTableByte4, 3 );

                if ( UICC_CARD_TYPE_UICC == iCardType )

                    {

                    // USIM: Read call control GPRS from byte 7

                    UiccReadServiceTableReq( KUiccTrIdServiceTableByte7, 6 );

                    }

                else if ( UICC_CARD_TYPE_ICC == iCardType )

                    {

                    // SIM: Read MO-SMS control from byte 5

                    UiccReadServiceTableReq( KUiccTrIdServiceTableByte5, 4 );

                    }

                }

            break;

            }

        case UICC_APPL_CMD_RESP:

            {

            UiccApplCmdResp( aIsiMessage );

            }

        } // End of switch ( messageId )

    return handled;

    }

// -----------------------------------------------------------------------------

// CSatMessHandler::SmsServerMessageReceived

// Called from SatMessHandler::ReceivedL, handles SMS Server messages

// -----------------------------------------------------------------------------

//

void CSatMessHandler::SmsServerMessageReceived

        (

        const TIsiReceiveC& aIsiMessage // ISI message from SMS server

        )

    {

    OstTrace0( TRACE_NORMAL, CSATMESSHANDLER_SMSSERVERMESSAGERECEIVED, "CSatMessHandler::SmsServerMessageReceived" );

    TFLOGSTRING("TSY:CSatMessHandler::SmsServerMessageReceived");

    TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

    switch ( messageId )

        {