/*

* 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 "satnotifications.h"   // sat notifications class

#include "satmessaging.h"       // sat messaging class

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

#include "sattimer.h"           // sat timer class

#include "ber_tlv.h"            // sat ber-tlv classes

#include "satutil.h"            // sat utility class

#include <tisi.h>               // isi message

#include <net_modemisi.h>       // net server

#include <gssisi.h>             // gss server

#include <atkisi.h>             // atk server

#include <uiccisi.h>            // uicc server

#include <satcs.h>

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

// CONSTANTS

// Character code

const TUint8 KPlusMarkCharacterCode                 = 0x2B;

// Send SM

const TUint8 KTPDUMandatoryFieldsSmsSubmitUdl       = 0x06;

const TUint8 KTPDUMandatoryFieldsSmsCommandUdl      = 0x07;

const TUint8 KTPDUMandatoryFieldsSmsSubmitDcs       = 0x05;

const TUint8 KSmsVPFEnhanced                        = 0x01;

const TUint8 KSmsVPFRelative                        = 0x02;

const TUint8 KSmsVPFAbsolute                        = 0x03;

const TUint8 KSmsVpFormatMask                       = 0x03;

const TUint8 KSATSmsMTISubmitOrSubmitReport         = 0x01;

const TUint8 KSmsDcsDefaultAlphabet                 = 0x00;

const TUint8 KMinSmsTpduLength                      = 0x07;

// Masks

const TUint8 KMask0                                 = 0x00;

const TUint8 KMask3                                 = 0x03;

const TUint8 KMaskC0                                = 0xC0;

const TUint8 KMaskF0                                = 0xF0;

const TUint8 KMaskF3                                = 0xF3;

const TUint8 KMaskFB                                = 0xFB;

// Additional info

const TUint8 KNoCause                               = 0x00;

// SetUpCall

const TUint8 KOnlyIfNotBusy                         = 0x00;

const TUint8 KOnlyIfNotBusyWithRedial               = 0x01;

const TUint8 KHoldOtherCalls                        = 0x02;

const TUint8 KHoldOtherCallsWithRedial              = 0x03;

const TUint8 KDisconnectOtherCalls                  = 0x04;

const TUint8 KDisconnectOtherCallsWithRedial        = 0x05;

// SetUpEventList

const TUint8 KMTCall                                = 0x00;

const TUint8 KCallConnected                         = 0x01;

const TUint8 KCallDisconnected                      = 0x02;

const TUint8 KLocationStatus                        = 0x03;

const TUint8 KUserActivity                          = 0x04;

const TUint8 KIdleScreenAvailable                   = 0x05;

const TUint8 KCardReaderStatus                      = 0x06;

const TUint8 KLanguageSelection                     = 0x07;

const TUint8 KBrowserTermination                    = 0x08;

const TUint8 KDataAvailable                         = 0x09;

const TUint8 KChannelStatus                         = 0x0A;

const TUint8 KAccessTechnologyChange                = 0x0B;

const TUint8 KDisplayParamsChanges                  = 0x0C;

const TUint8 KLocalConnection                       = 0x0D;

// Timer management

const TUint8 KMinTimerValue                         = 0;

const TUint  KMaxTimerValueInSeconds                = 86400;

// Launch browser

const TUint8 KLaunchBrowserCmdQualifierNotUsed      = 0x01;

const TUint8 KLaunchBrowserCmdQualifierReserved     = 0x04;

const TUint8 KCsdBearer                             = 0x01;

const TUint8 KGprsBearer                            = 0x03;

const TUint8 KDefaultBrowser                        = 0x00;

#if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )

const TUint8 KWMLBrowser                            = 0x01;

const TUint8 KHTMLBrowser                           = 0x02;

const TUint8 KXHTMLBrowser                          = 0x03;

const TUint8 KCHTMLBrowser                          = 0x04;

#endif

// Bearer independent protocol

const TUint8 KBipCsdBearer                          = 0x01;

const TUint8 KBipGprsBearer                         = 0x02;

const TUint8 KBipDefaultBearer                      = 0x03;

const TUint8 KBipLocalLinkTechnologyIndependentBearer  = 0x04;

const TUint8 KBipBluetoothBearer                    = 0x05;

const TUint8 KBipIrDABearer                         = 0x06;

const TUint8 KBipRS232Bearer                        = 0x07;

const TUint8 KBipUSBBearer                          = 0x10;

const TUint8 KBipSendDataImmediately                = 0x01;

// Language notification

const TUint8 KSpecificLanguage                      = 0x01;

// Elementary files

const TUint8 KRefresh1StLevelDedicatedFileHeader    = 0x7F;

const TUint8 KRefresh2StLevelDedicatedFileHeader    = 0x5F;

// SIM/ME Interface transport protocol type coding

const TUint8 KProtocolUdp                           = 0x01;

const TUint8 KProtocolTcp                           = 0x02;

// Link Establishment

const TUint8 KLinkEstablishmentMask                 = 0x01;

// Reconnection mode

const TUint8 KReconnectionModeMask                  = 0x02;

// LOCAL FUNCTION PROTOTYPES

// Declaration needed here for ARMV5 because method is used in Notifications

// base, but method implementation is bit later.

CSatNotificationsBase::TAllowedResults operator+(

    const RSat::TPCmdResult aResultA, const RSat::TPCmdResult aResultB );

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

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

// CSatNotificationsBase::CSatNotificationsBase

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

// might leave.

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

//

CSatNotificationsBase::CSatNotificationsBase

        (

        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler

        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class

        )

        :

        iSatMessHandler( aSatMessHandler ),

        iSatMessaging( aSatMessaging ),

        iTransId( KZero ),

        iReqHandle( NULL )

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::CSatNotificationsBase" );

    iCommandDetails.Zero();

    // Following results are accepted by all commands

    iAllowedResults = RSat::KSuccess + RSat::KPartialComprehension

        + RSat::KMissingInformation + RSat::KMeUnableToProcessCmd

        + RSat::KCmdBeyondMeCapabilities + RSat::KCmdTypeNotUnderstood

        + RSat::KCmdDataNotUnderstood + RSat::KCmdNumberNotKnown;

    }

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

// CSatNotificationsBase::~CSatNotificationsBase

// Destructor

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

//

CSatNotificationsBase::~CSatNotificationsBase()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::~CSatNotificationsBase" );

    // None

    }

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

// CSatNotificationsBase::CancelNotification

// Cancels the current notification request

// (other items were commented in a header).

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

//

TInt CSatNotificationsBase::CancelNotification

        (

        const TTsyReqHandle aReqHandle  // Request handle

        )

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CANCELNOTIFICATION, "CSatNotificationsBase::CancelNotification" );

    TFLOGSTRING("TSY: CSatNotificationsBase::CancelNotification");

    // Check that the handle is valid

    if ( aReqHandle == iReqHandle )

        {

        iSatMessaging->ReqCompleted( aReqHandle, KErrCancel );

        }

    else

        {

        // Handle is not valid

        iSatMessaging->ReqCompleted( aReqHandle, KErrCorrupt );

        }

    iReqHandle = NULL;

    return KErrNone;

    }

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

// CSatNotificationsBase::TerminalResponse

// Handles the terminal response of a proactive command

// (other items were commented in a header).

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

//

TInt CSatNotificationsBase::TerminalResponse

        (

        TDes8* /* aRsp */   // Response

        )

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TERMINALRESPONSE, "CSatNotificationsBase::TerminalResponse" );

    // Base class does not do anything

    return KErrNone;

    }

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

// CSatNotificationsBase::GetCmdDetails

// Returns a reference to member iCommandDetails

// (other items were commented in a header).

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

//

TDes8& CSatNotificationsBase::GetCmdDetails()

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETCMDDETAILS, "CSatNotificationsBase::GetCmdDetails" );

    return iCommandDetails;

    }

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

// CSatNotificationsBase::GetTransactionId

// Returns the transaction identifier of the current PCmd.

// This is a Nokia specific value found in ISI messages.

// (other items were commented in a header).

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

//

TUint8 CSatNotificationsBase::GetTransactionId()

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETTRANSACTIONID, "CSatNotificationsBase::GetTransactionId" );

    return iTransId;

    }

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

// CSatNotificationsBase::TsyReqHandle

// Returns the TsyReqHandle of a request

// (other items were commented in a header).

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

//

TTsyReqHandle CSatNotificationsBase::TsyReqHandle()

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TSYREQHANDLE, "CSatNotificationsBase::TsyReqHandle" );

    return iReqHandle;

    }

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

// CSatNotificationsBase::CompleteRequest

// Completes the Request notification

// (other items were commented in a header).

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

//

void CSatNotificationsBase::CompleteRequest

        (

        const TInt aError   // Possible error

        )

    {

    OstTraceExt2( TRACE_NORMAL, CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest, Handle: %d, Error: %d", (TInt)iReqHandle, aError );

    TFLOGSTRING3("CSatNotificationsBase::CompleteRequest. \n\t\t\t Handle:%d\n\t\t\t Error:%d",

               iReqHandle,

               aError);

    TTsyReqHandle tempReqHandle = iReqHandle;

    iReqHandle = NULL;

    iSatMessaging->ReqCompleted( tempReqHandle, aError );

    TFLOGSTRING("CSatNotificationsBase::CompleteRequest. Request is now completed");

    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest. Request is now completed" );

    }

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

// CSatNotificationsBase::TAllowedResults::TAllowedResults

// C++ default constructor of the nested class.

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

//

CSatNotificationsBase::TAllowedResults::TAllowedResults() : iResultField( 0 )

    {

    }

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

// TBool CSatNotificationsBase::TAllowedResults::operator==

// The equality operator (==) for TAllowedResults

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

//

TBool CSatNotificationsBase::TAllowedResults::operator==

        (

        const RSat::TPCmdResult aResult

        ) const

    {

    // Create mask from result for comparation

    TAllowedResults mask;

    mask = aResult;

    // Compare with bit-wise AND operation

    TBool match( iResultField & mask.iResultField );

    // Unfortunately AND operator does not seem to work if the mask contains a

    // value in the high order 32 bits of a 64 bit number. This case has to be

    // checked with following macro.

    if ( I64HIGH( mask.iResultField ) )

        {

        // Mask value is in the high order of the number so compare these.

        match = I64HIGH( iResultField ) & I64HIGH( mask.iResultField );

        }

    // Open System Trace doesn't support tracing in nested classes

    TFLOGSTRING3( "TAllowedResults::operator==: Bit Field: %08x %08x",

        I64HIGH( iResultField ), I64LOW( iResultField ) );

    TFLOGSTRING2( "TAllowedResults::operator==: Match: %d",

        ( match ? 1 : 0 ) );

    return match;

    }

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

// CSatNotificationsBase::TAllowedResults::operator!=

// The not-equal operator (!=) for TAllowedResults.

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

//

TBool CSatNotificationsBase::TAllowedResults::operator!=

        (

        const RSat::TPCmdResult aResult

        ) const

    {

    // Return the value of equals-operation (==) as inverted.

    return !( *this == aResult );

    }

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

// CSatNotificationsBase::TAllowedResults::operator=

// The assignment operator (=) for TAllowedResults

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

//

CSatNotificationsBase::TAllowedResults&

    CSatNotificationsBase::TAllowedResults::operator=

        (

        const RSat::TPCmdResult aResult

        )

    {

    // Convert result to bit field and assing internal field to it.

    iResultField = CreateBitField( aResult );

    // Return reference to this

    return *this;

    }

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

// CSatNotificationsBase::operator+=

// The increment operator (+=) for TAllowedResults.

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

//

CSatNotificationsBase::TAllowedResults&

    CSatNotificationsBase::TAllowedResults::operator+=

        (

        const RSat::TPCmdResult aResult

        )

    {

    // Append result to bit field by calling approriate plus operator

    // and return reference to this

    return *this = *this + aResult;

    }

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

// CSatNotificationsBase::operator+=

// The increment operator (+=) for TAllowedResults.

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

//

CSatNotificationsBase::TAllowedResults&

    CSatNotificationsBase::TAllowedResults::operator+=

        (

        const CSatNotificationsBase::TAllowedResults aResults

        )

    {

    // Append result fields together

    iResultField = iResultField | aResults.iResultField;

    // Return reference to this

    return *this;

    }

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

// CSatNotificationsBase::TAllowedResults::operator+

// The increment operator (+) for TAllowedResults.

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

//

CSatNotificationsBase::TAllowedResults&

    CSatNotificationsBase::TAllowedResults::operator+

        (

        const RSat::TPCmdResult aResult

        )

    {

    // Convert to bit field and append to result field.

    iResultField = iResultField | CreateBitField( aResult );

    // Return reference to this

    return *this;

    }

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

// operator+

// Friend increment operator (+) for adding two TPCmdResults together as

// bitfield.

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

//

CSatNotificationsBase::TAllowedResults operator+

        (

        const RSat::TPCmdResult aResultA,

        const RSat::TPCmdResult aResultB

        )

    {

    // Create temporary bit field and append values into it.

    // Because internal TAllowedResults is used, this method is declared as a

    // friend

    CSatNotificationsBase::TAllowedResults temp;

    temp = aResultA;

    temp += aResultB;

    return temp;

    }

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

// CSatNotificationsBase::CreateBitField

// Converts result code into bitfield representation.

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

//

inline TUint64

    CSatNotificationsBase::TAllowedResults::CreateBitField

        (

        const RSat::TPCmdResult aResult

        ) const

    {

    // Create a bitfield from a result by shifting '1' to the left.

    // Number of shifts depend on the result number:

    // ...0000 0001 = KSuccess (0x00)

    // ...0000 0010 = KPartialComprehension(0x01)

    // ...0001 0000 = KSuccessRequestedIconNotDisplayed(0x04)

    // and so forth.

    return static_cast<TInt64>( 1 ) << ( aResult );

    }

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

// CSatNotifyDisplayText::CSatNotifyDisplayText

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

// might leave.

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

//

CSatNotifyDisplayText::CSatNotifyDisplayText

        (

        CSatMessHandler*    aSatMessHandler, //Pointer to the message handler

        CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class

        )

        :

        CSatNotificationsBase( aSatMessHandler, aSatMessaging ),

        iDisplayTextV2Pckg( NULL )

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::CSatNotifyDisplayText" );

    // Following results are also allowed for this command:

    // (in addition to result declared in base class constructor)

    iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed

        + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser

        + RSat::KNoResponseFromUser + RSat::KErrorRequiredValuesMissing;

    }

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

// CSatNotifyDisplayText::~CSatNotifyDisplayText

// Destructor

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

//

CSatNotifyDisplayText::~CSatNotifyDisplayText()

    {

    OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::~CSatNotifyDisplayText" );

    // None

    }

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

// CSatNotifyDisplayText::MessageReceived

// Handles a DisplayText proactive command ISI message,

// and completes a pending ETel request.

// (other items were commented in a header).

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

//

void CSatNotifyDisplayText::MessageReceived( const TIsiReceiveC& aIsiMessage )

    {

    OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED, "CSatNotifyDisplayText::MessageReceived" );

    TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived");

    // Completion return value

    TInt ret( KErrNone );

    // Get ber tlv

    CBerTlv berTlv;

    berTlv.BerTlv( aIsiMessage );

    // Get command details tlv

    CTlv commandDetails;

    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );

    // Store command details tlv

    iCommandDetails.Copy( commandDetails.Data() );

    // Get command qualifier

    TUint8 cmdQualifier(

        commandDetails.GetShortInfo( ETLV_CommandQualifier ) );

    // Save ISA/CellMo transaction id

    iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );

    // Test if pending request

    if ( !iReqHandle )

        {

        TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived - Request Off");