// 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        : CSatCcTsy.cpp

// Part of     : Common SIM ATK TSY / commonsimatktsy

// Call control-related functionality of Sat Tsy

// Version     : 1.0

//

//INCLUDES

#include "etelsat.h"                // SAT specific Etel definitions

#include "CSatDataPackage.h"        // Parameter packing 

#include "CSatCCTsy.h"              // Class header

#include "CSatTsy.h"                // SAT TSY general class

#include "CSatNotificationsTsy.h"   // SAT TSY Notifications class

#include "cmmmessagemanagerbase.h"  // Message manager class for forwarding req.

#include "TfLogger.h"               // For TFLOGSTRING

#include "msattsy_ipcdefs.h"		// Sat Tsy specific request types

#include "TSatUtility.h"			// Utility class

#include "TTlv.h"					// TTlv class

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

// CSatCCTsy::NewL

// Two-phased constructor.

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

//

CSatCCTsy* CSatCCTsy::NewL

        (    

        CSatTsy* aSatTsy,

        CSatNotificationsTsy* aNotificationsTsy   

        )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::NewL");

    CSatCCTsy* const satCcTsy = new ( ELeave ) CSatCCTsy( aNotificationsTsy );

    CleanupStack::PushL( satCcTsy );

    satCcTsy->iSatTsy = aSatTsy;

    satCcTsy->ConstructL();

    CleanupStack::Pop( satCcTsy );

    TFLOGSTRING("CSAT: CSatCCTsy::NewL, end of method");

    return satCcTsy;

    }

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

// CSatCCTsy::~CSatCCTsy

// Destructor

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

//    

CSatCCTsy::~CSatCCTsy

        (    

        //None   

        )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::~CSatCCTsy");

    // Unregister.

    iSatTsy->MessageManager()->RegisterTsyObject(

		CMmMessageManagerBase::ESatCCTsyObjType, NULL );

    }

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

// CSatCCTsy::ConstructL

// Symbian 2nd phase constructor. Initialises internal attributes.

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

//

void CSatCCTsy::ConstructL

        (    

        //None

        )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::ConstructL\n" );

    // Register.

    iSatTsy->MessageManager()->RegisterTsyObject(

		CMmMessageManagerBase::ESatCCTsyObjType, this );

	iBearerData.Zero();

	// Initialize to false

	iTonNpiPresent = EFalse;

	// Clean the address buffer

	iProactiveCommandAddress.Zero();

	// Initialize USSD TLV support to not supported

	iUssdTlvSupported = EFalse;

    }

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

// CSatCCTsy::CSatCCTsy

// C++ constructor

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

//

CSatCCTsy::CSatCCTsy

        (    

        CSatNotificationsTsy* aNotificationsTsy 

        ) : iNotificationsTsy ( aNotificationsTsy )

    {

    // None

    }

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

// CSatCCTsy::CompleteBearerCapability

// Saves default bearer data for voice call.

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

//

void CSatCCTsy::CompleteBearerCapability

         (

		 CSatDataPackage* aDataPackage, 

		 TInt /*aResult*/

		 )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::CompleteBearerCapability");

    TPtrC8* bearerData = NULL;

    // Unpack parameters 

    aDataPackage->UnPackData( &bearerData );

    iBearerData.Copy( *bearerData );

	}

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

// CSatCCTsy::CreateEnvelope

// Identifies the type of envelope and calls appropriate method.

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

void CSatCCTsy::CreateEnvelopeL

        (

        CSatDataPackage* aDataPackage

        )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::CreateEnvelope");

    TCCInfo* ccInfo;

    // Unpack parameters

    aDataPackage->UnPackData( &ccInfo );

    switch ( ccInfo->iTag )

        {

        case KTlvAddressTag:

            {

            CreateCallEnvelopeL( ccInfo );

            break;

            }

        case KTlvSsStringTag:

            {

            CreateSSEnvelopeL( ccInfo );

            break;

            }

        case KTlvUssdStringTag:

            {

            CreateUSSDEnvelopeL( ccInfo );

            break;

            }

        default:

            {

            TFLOGSTRING2("CSAT: CSatCCTsy::CreateEnvelope,\

                Unidentified tag: %d", ccInfo->iTag );

            }

        }

    }

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

// CSatCCTsy::CheckIfAlphaIdPresent

// Notifies client if alpha ID was present in incoming data notification.

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

//

void CSatCCTsy::CheckIfAlphaIdPresent

        (

        CSatDataPackage* aDataPackage

        )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::CheckIfAlphaIdPresent"); 

    TDesC8* atkData;            

    RSat::TControlResult* result;

    // Unpack parameters

    aDataPackage->UnPackData( &atkData, &result );

    TUint16 envLength( 0 );

    TInt lengthOfLength( 1 );

    TInt index( 1 );

    // Check first that the data exists

    if ( 1 < atkData->Length() )

        {

        // Check if length is taking two bytes or not.

        if ( KTwoByteLengthCoding != ( *atkData )[ index ] ) 

            {

            // It takes one

            envLength = ( ( *atkData )[ index ] );

            }

        else

            {

            // It takes two. ( Actually it takes only one, but first byte is 

            // meaningless. See ETSI 11.14 Annex D )

            envLength = ( ( *atkData )[ index + 1 ] );

            lengthOfLength = 2;

            }

        index += lengthOfLength;

        if ( envLength != 0 )

            {

            while ( index < envLength )

                {

    	        // Check next tag

    	        TUint8 nextTag( ( *atkData )[ index ] );

                switch ( nextTag & KTagValueMask )

                    {

                    case KTlvAddressTag:

                    case KTlvCapabilityConfigurationParametersTag:

                    case KTlvSubaddressTag:

                    case KTlvSsStringTag:

                    case KTlvUssdStringTag:

                    case KTlvBcRepeatIndicatorTag:

                        {

                        TUint16 length( 0 );

                        TUint8 localLengthOfLength( 1 );

                        index++;

                        // Check if length is taking two bytes or not.

                        if ( KTwoByteLengthCoding  != ( *atkData )[ index ] )

                            {

                            // It takes one

                            length = ( ( *atkData )[ index ] );

                            }

                        else

                            {

                            // It takes two

                            length = ( ( *atkData )[ index + 1 ] );

                            localLengthOfLength = 2;

                            }

                        index += localLengthOfLength + length;

                        break;

                        }

                    case KTlvAlphaIdentifierTag:

                        {

                        TUint16 alphaIdLength( 0 );

                        lengthOfLength = 1;

                        index++;

                        // Check if length is taking two bytes or not

                        if ( KTwoByteLengthCoding != ( *atkData )[ index ] )

                            {

                            alphaIdLength = ( *atkData )[ index ];

                            }

                        else

                            {

                            alphaIdLength = ( *atkData )[ index + 1 ];

                            lengthOfLength = 2;

                            }

                        // If the alpha identifier is provided by the NAA and is 

                        // not a null data object, the ME shall use it to inform  

                        // the user. The ME shall then not display the destination 

                        // address or SS string given by the NAA. This is also an 

                        // indication that the ME should not give any other 

                        // information to the user on the changes made by the NAA 

                        // to the initial user request. Design decision: If alpha 

                        // identifier is not given or it is NULL, client will not 

                        // be notified. Specs leaves this open so this decision 

                        // can be made.

                        if ( 0 != alphaIdLength )

                            {

                            TFLOGSTRING("CSAT: CSatCCTsy::CheckIfAlphaIdPresent.\

                                inform user.");

                            TPtrC8 sourceString;

                            sourceString.Set( ( *atkData ).Mid( index + 

                                lengthOfLength, alphaIdLength ) );

                            RSat::TAlphaIdBuf alphaId;                       

                            // Convert and set the alpha id

    						TSatUtility::SetAlphaId( sourceString, alphaId ); 

                            iNotificationsTsy->NotifyClientForAlphaId( alphaId, 

                                *result );

                            }

                        else

                            {

                            TFLOGSTRING("CSAT: CSatCCTsy::CheckIfAlphaIdPresent.\

                                AlphaID length: 0.");

                            }

                        // Update index

                        index += alphaIdLength + lengthOfLength;

                        break;

                        }

                    default:

                        {

                        TFLOGSTRING("CSAT: CSatCCTsy::CheckIfAlphaIdPresent\

                            Unknown tag.");

                        index = envLength;

                        break;

                        }

                    }

                }

            }

        }

    else

        {

        TFLOGSTRING("CSAT: CSatCCTsy::CheckIfAlphaIdPresent. \

            Input data missing!");

        }

    }

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

// CSatCCTsy::CompleteCCEventL

// Completes the received call control event data notification

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

//

void CSatCCTsy::CompleteCCEventL

        (

        TInt aIpc,

        CSatDataPackage* aDataPackage 

        )

    {

    TFLOGSTRING2("CSAT: CSatCCTsy::CompleteCCEventL, aIpc: %d", aIpc);

    TCCInfo* ccInfo;

    // Unpack parameters

    aDataPackage->UnPackData( &ccInfo );

    switch ( aIpc )

        {

        case ESatTsyCallEvent:

            {

            // 3GPP TS 11.14 V8.17.0 (2004-09):

            // It is possible that NAA requests ME to set up an emergency call by 

            // supplying "112" as called party number. If NAA supplies a number 

            // stored in EFECC, this shall not result in an emergency call.

            //

            // The number included in the SET UP CALL proactive command is never

            // checked against FDN list. So no need to done it here.

            if ( HasProactiveOrigin( ccInfo->iAddress ) )

                {

                // Match! Address can be reset and envelope sent

                iProactiveCommandAddress.Zero();            		

                CreateCallEnvelopeL( ccInfo );

                }

            else

                {

                // Check if this is a emergency call creation attempt. Although 

                // emergency calls made through TSY always use emergency flag 

                // and emergency mode and are therefore passed straight through

                // guardians, emergency calls made by AT commands and bypassing 

                // TSY do not use emergency flag and mode. A possility that NAA 

                // would alter the emergency call to something else cannot be 

                // tolerated. Forward request to the DOS

                iSatTsy->MessageManager()->HandleRequestL( 

            		ESatTsyEmergencyNbrCheck );

                }  

            break;

            }

        case ESatTsySSEvent:

            {

            // 3GPP TS 11.14 V8.17.0 (2004-09):

            // The SS control string included in the SEND SS proactive cmd is 

            // never checked against FDN list. So make sure this wont happen.

            if ( HasProactiveOrigin( ccInfo->iAddress ) )

                {

                // Match! Address can be reset and envelope sent without FDN 

                // check.

                iProactiveCommandAddress.Zero();

                CreateSSEnvelopeL( ccInfo );

                }

            // Not proactive originated, check if FDN is activated.

            else

                {

                // Forward request to the DOS

                iSatTsy->MessageManager()->HandleRequestL( 

            		ESatTsyFdnStatusCheck );

                }  

            break;

            }

        case ESatTsyUSSDEvent:

            {

            // Send envelope right away, there's no difference whether the CC 

            // event was originated by proactive command or not.

            CreateUSSDEnvelopeL( ccInfo );

            break;

            }

        default:

            {

            TFLOGSTRING("CSAT: CSatCCTsy::CompleteCCEventL, Unknown event!");

            }

        }

    }   

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

// CSatCCTsy::SetTonNpiForSS

// Set CSatCC internal Ton and Npi

// Called by CSatNotifySendSs::CompleteNotifyL when SEND SS proactive command 

// arrives

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

//

void CSatCCTsy::SetTonNpiForSS

        ( 

        const TUint8 aTonNpi 

        )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::SetTonNpiForSS");

    iTonNpiForSS = aTonNpi;

    iTonNpiPresent = ETrue;

    }

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

// CSatCCTsy::SetUssdStatus

// Set internal flag according to EF-SST.

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

//

void CSatCCTsy::SetUssdStatus

		( 

    	CSatDataPackage* aDataPackage

    	)

    { 

    TFLOGSTRING("CSAT: CSatCCTsy::SetUssdStatus." );    

    // Unpack parameters 

    aDataPackage->UnPackData( iUssdTlvSupported ); 

    }  

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

// CSatCCTsy::StoreAddressForCC

// 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 CSatCCTsy::StoreAddressForCC

        ( 

        const TDesC8& aAddress 

        )

    {

    TFLOGSTRING("CSAT: CSatCCTsy::StoreAddressForCC");

    if ( NULL == &aAddress )

        {

        iProactiveCommandAddress.Zero();

        TFLOGSTRING("CSAT: CSatCCTsy::StoreAddressForCC, address cleared");

        }

    else

        {

        iProactiveCommandAddress.Copy( aAddress );

        // Remove the '+' sign from the the beginning of the address

        // if it exists. Otherwise the comparison does not work.     

        if ( 0 < iProactiveCommandAddress.Length() )

            {

            if ( '+' == iProactiveCommandAddress[0] )

                {

                iProactiveCommandAddress.Delete( 0, 1 );

                }

            }

        TFLOGSTRING("CSAT: CSatCCTsy::StoreAddressForCC, Address stored");

        }

    }     

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

// CSatCCTsy::CreateCallEnvelopeL

// Creates call Envelope.

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

//

void CSatCCTsy::CreateCallEnvelopeL

		( 

		const TCCInfo* aCCInfo

		)

    {

    TFLOGSTRING("CSAT: CSatCCTsy::CreateCallEnvelopeL" );

    // Create envelope

    TTlv envelope;

    envelope.Begin( KBerTlvCallControlTag );

    // Device identities

    envelope.AddTag( KTlvDeviceIdentityTag );

    envelope.AddByte( KMe );

    envelope.AddByte( KSim );

    // Address

    envelope.AddTag( KTlvAddressTag );

    envelope.AddByte( aCCInfo->iTonNpi ); 

    // Must be converted to BCD number

    TBuf8<KAddrMaxLength> address;

    TSatUtility::AsciiToBCD( aCCInfo->iAddress, address );

    envelope.AddData( address );

    // Optional

    envelope.AddTag( KTlvCapabilityConfigurationParametersTag );

    if ( 0 != aCCInfo->iBcc1.Length() )

        {

        if ( 2 > aCCInfo->iBcc1.Length() )

            {

            TBuf8<KMaxBccLength> bcc;

            bcc.Append( 0x01 );

            bcc.Append( aCCInfo->iBcc1 );

            envelope.AddData( bcc );

            }

        else

            {

            envelope.AddData( aCCInfo->iBcc1 );

            }

        }

    // Although this field is not mandatory, it could help testing.  

    // Therefore field is included to enable wider testability.

    else

        {  

        if ( iBearerData.Length() < 2 )

            {

            iBearerData.Append( 0x01 );

            // Add the length

            envelope.AddByte( static_cast<TUint8>( iBearerData.Length() ) );

            envelope.AddData( iBearerData );

            }

        // Design decision: if bearer data is bigger than capability field, 

        // then this field is not added.

        else if ( KMaxBccLength >= iBearerData.Length() )

            {

            // Add the length

            envelope.AddByte( static_cast<TUint8>( iBearerData.Length() ) );

            envelope.AddData( iBearerData ); 

            }

        else