/*

* 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:  Interface for sending messages.

*

*/

// INCLUDE FILES

#include <etelmm.h>

#include <f32file.h>

#include <charconv.h>

#include <gsmuelem.h>

#include <exterror.h>

#include <gsmerror.h>

#include <etelsat.h>

// CONSTANTS

const TUint8 KPhCltUssdDcsDefaultAlphabet = 0x0f; // 00001111

const TUint8 KPhCltUssdDcsAlphabetDefaultPrecededLanguage = 0x10; // 00010000 

const TUint8 KPhCltUssdDcsAlphabetDefaultPrecededLanguageSkipChars3 = 3;

const TUint8 KPhCltUssdDcsAlphabetDefaultPrecededLanguageSkipChars2 = 2;

const TUint8 KPhCltUssdDcsAlphabetDefaultPrecededLanguageStartBit = 5;

const TUint8 KPhCltUssdDcsAlphabetUCS2PrecededLanguage = 0x11;   // 00010001

const TUint8 KPhCltUssdDcsAlphabetUCS2PrecededLanguageSkipChars = 2;

const TUint8 KPhCltUssdDcsGeneralInformationMask = 0xc0;         // 11000000

const TUint8 KPhCltUssdDcsGeneralInformation = 0x40;             // 01xxxxxx

const TUint8 KPhCltUssdDcsGeneralInformationCompressed = 0x20;   // xx1xxxxx

const TUint8 KPhCltUssdDcsGeneralInformationSimMask = 0x13;      // 00010011

const TUint8 KPhCltUssdDcsGeneralInformationSim = 0x12;          // xxx1xx10

const TUint8 KPhCltUssdDcsGeneralInformationAlphabetMask = 0x0c; // 00001100

const TUint8 KPhCltUssdDcsGeneralInformationAlphabet8Bit = 0x04; // xxxx01xx 

const TUint8 KPhCltUssdDcsGeneralInformationAlphabetUCS2 = 0x08; // xxxx10xx 

const TUint8 KPhCltUssdDcsMessageHandlingAlphabetMask = 0xf4;    // 11110100

const TUint8 KPhCltUssdDcsMessageHandlingAlphabet8Bit = 0xf4;    // 1111x1xx 

const TUint8 KPhCltUssdCarriageReturn = 0x0d;

const TUint8 KPhCltUssdDcsNotSet  = 0x00; // not set

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

// CLASS DECLARATION

#ifndef TPHCLTUSSDALPHABETPACKER_H

#define TPHCLTUSSDALPHABETPACKER_H

/**

* Class for packing the Ussd string.

*/

class TPhCltUssdAlphabetPacker

    {

    public:  // Constructors and destructor

        /**

        * Constructor.

        *

        * @param aAlphabet The used Data Coding Scheme.

        * @param aIsBinary Is the data binary.

        * @param aStartBit The start bit of the conversion.

        */

        TPhCltUssdAlphabetPacker(

            TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

            TBool aIsBinary,

            TInt aStartBit );

    public:  // New functions

        /**

        * Pack the given string to the desired coding scheme.

        *

        * @param aOut The output string of packing

        * @param aIn The string to be packed.

        * @return The number of octets used.

        */

        TInt PackL(TDes8& aOut,const TDesC8& aIn);

        /**

        * Convert and pack the given string to the desired coding scheme.

        *

        * @param aCharacterSetConverter The character converter.

        * @param aFs Reference to file system.

        * @param aOut The output string of packing

        * @param aIn The string to be packed.

        * @param aConvertedNumUDUnits The number of converted units.

        * @return The number of octets used.

        */

        TInt ConvertAndPackL(

            CCnvCharacterSetConverter& aCharacterSetConverter,

            RFs& aFs,

            TDes8& aOut,

            const TDesC& aIn,

            TInt& aConvertedNumUDUnits );

        /**

        * Return information of how many octets are required when

        * the aNumUDUnits number of characters is packed.

        *

        * @param aNumUDUnits The number of characters to be packed.

        * @return The number of octets required.

        */

        TInt PackedOctetsRequiredL( TInt aNumUDUnits ) const;

    private:

        // Private helper methods

        TInt ElementSizeInBitsL() const;

    private:    // Data

        // The Data Coding Scheme of the conversion.

        TSmsDataCodingScheme::TSmsAlphabet iAlphabet;

        // Information is the given descriptor binary.

        TBool iIsBinary;

        // The start bit of the conversion.

        TInt iStartBit;

    };

#endif // TPHCLTUSSDALPHABETPACKER_H

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

// TPhCltUssdAlphabetPacker::TPhCltUssdAlphabetPacker

//

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

//

TPhCltUssdAlphabetPacker::TPhCltUssdAlphabetPacker(

    TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

    TBool aIsBinary,

    TInt aStartBit)

    : iAlphabet( aAlphabet ),

      iIsBinary( aIsBinary ),

      iStartBit( aStartBit )

    {

    }

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

// TPhCltUssdAlphabetPacker::PackL

//

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

//

TInt TPhCltUssdAlphabetPacker::PackL( TDes8& aOut,const TDesC8& aIn )

    {

    // Ensure we've got the right length

    TInt packedOctetsRequired = PackedOctetsRequiredL( aIn.Length() );

    if ( packedOctetsRequired > ( aOut.MaxLength() - aOut.Length() ) )

        {

        User::Leave( KErrOverflow );

        }

    // Do the conversion

    TInt elementSizeInBits = ElementSizeInBitsL();

    if ( elementSizeInBits == 8 ) // 8 bit data

        {

        // Straight copy here

        aOut.Append( aIn );

        }

    else if ( elementSizeInBits == 7 ) // Need packing to 7-bit

        {

        // Get raw pointers and do packing

        TUint8* outPtr = ( TUint8* )aOut.Ptr() + aOut.Length();

        const TUint8* inPtr = aIn.Ptr();

        outPtr[0] = 0;

        for ( TInt i = 0; i < aIn.Length() ; i++ )

            {

            TUint8 to = inPtr[i];

            *outPtr |= ( to << iStartBit );

            if ( iStartBit )

                {

                outPtr++;

                *outPtr = ( TUint8 ) ( to >> ( 8 - iStartBit ) );

                }

            iStartBit = ( iStartBit + 7 )%8; // roll 0,1,2,3,4,5,6,7,0,1,2,...

            if ( i == aIn.Length() - 1 ) // if this is the last time

                {

                if ( ( to == KPhCltUssdCarriageReturn && iStartBit == 0 ) || 

                     iStartBit == 1 )

                    {

                    //We have to add one CR more

                    *outPtr |= ( KPhCltUssdCarriageReturn << iStartBit );

                    if ( iStartBit )

                        {

                        outPtr++;

                        *outPtr = ( TUint8 ) (

                            KPhCltUssdCarriageReturn >> ( 8 - iStartBit ) );

                        }

                    else

                        {

                        packedOctetsRequired++;

                        }

                    iStartBit = ( iStartBit + 7 )%8;

                    }

                }

            }

        // Increment the length for the packed data

        aOut.SetLength( aOut.Length() + packedOctetsRequired );

        }

    else

        {

        User::Invariant();

        }

    // Return number of bytes used

    return packedOctetsRequired;

    }

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

// TPhCltUssdAlphabetPacker::ConvertAndPackL

//

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

//

TInt TPhCltUssdAlphabetPacker::ConvertAndPackL(

    CCnvCharacterSetConverter& aCharacterSetConverter,

    RFs& aFs,

    TDes8& aOut,

    const TDesC& aIn,

    TInt& aConvertedNumUDUnits )

    {

    // Do the conversion

    CSmsAlphabetConverter* converter = 

        CSmsAlphabetConverter::NewLC( 

            aCharacterSetConverter, aFs, iAlphabet, iIsBinary );

    TPtrC8 convertedPtr = converter->ConvertFromNativeL( aIn );

    aConvertedNumUDUnits = convertedPtr.Length();

    // Do the packing

    TInt octetsUsed = PackL( aOut,convertedPtr );

    // Cleanup and return

    CleanupStack::PopAndDestroy(); // converter

    return octetsUsed;

    }

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

// TPhCltUssdAlphabetPacker::PackedOctetsRequiredL

//

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

//

TInt TPhCltUssdAlphabetPacker::PackedOctetsRequiredL( TInt aNumUDUnits ) const

    {  

    TInt octetsRequired = 0;

    TInt elementSizeInBits = ElementSizeInBitsL();

    if ( elementSizeInBits == 8 )

        {

        octetsRequired=aNumUDUnits;

        }

    else

        {

        octetsRequired =

            ( iStartBit + aNumUDUnits*elementSizeInBits + 7 )/8;    // Rounds up

        }

    return octetsRequired;

    }

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

// TPhCltUssdAlphabetPacker::ElementSizeInBitsL

//

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

//

TInt TPhCltUssdAlphabetPacker::ElementSizeInBitsL() const

    {   

    if ( iIsBinary )

        return 8;

    switch ( iAlphabet )

        {

        case TSmsDataCodingScheme::ESmsAlphabet7Bit:

            {

            return 7;

            }

        case TSmsDataCodingScheme::ESmsAlphabet8Bit:

        case TSmsDataCodingScheme::ESmsAlphabetUCS2:

            {

            return 8;

            }

        default:

            {

            User::Leave( KErrGsmSMSDataCodingSchemeNotSupported );

            return 8;

            }

        }

    }

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

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

// CPhCltUssdImp::NewL

// Two-phased constructor.

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

//

CPhCltUssdImp* CPhCltUssdImp::NewL( TBool aShowNotes )

    {

    CPhCltUssdImp* self = new( ELeave ) CPhCltUssdImp;

    CleanupStack::PushL( self );

    self->ConstructL( aShowNotes );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CPhCltUssdImp::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPhCltUssdImp::ConstructL( TBool aShowNotes )

    {

    // The note controller is needed only if the notes are shown.

    iNoteController = NULL;

    if ( aShowNotes )

        {

        iNoteController = CPhCltUssdNoteController::NewL( 

        }

    iDCS = KPhCltUssdDcsDefaultAlphabet;

    iWait = new( ELeave ) CActiveSchedulerWait;

    // The one that send the request forward.

    iRequestHandler = CPhCltUssdRequestHandler::NewL( 

        *this, 

        CActive::EPriorityStandard );

    }

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

// CPhCltUssdImp::CPhCltUssdImp

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

// might leave.

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

//

CPhCltUssdImp::CPhCltUssdImp()

    {

    } 

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

// CPhCltUssdImp::~CPhCltUssdImp

// Destructor.

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

//

CPhCltUssdImp::~CPhCltUssdImp()

    {

    if ( iWait )

        {

        if ( iWait->IsStarted() )

            {

            iWait->AsyncStop();

            }

        delete iWait;

        iWait = NULL;

        }

    delete iRequestHandler;

    iRequestHandler = NULL;

    delete iNoteController;

    }

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

// CPhCltUssdImp::HandleSendEventL

// 

// Called when the Send request is completed. aError might be

// positive -> the Send is completed due received message.

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

//

void CPhCltUssdImp::HandleSendEventL( const TInt aError )

    {

    // iNoteController is allocated only if notes are shown.

    if ( iNoteController )

        {

        // Send request is completed, now destroy the wait note

        iNoteController->DestroyGlobalWaitNote();

        // Show a different note depenging on the error code.

        if ( aError <= 0 )

            {

            switch ( aError )

                {

                // All Ok.

                case KErrNone:

                    break;

                // Operation cancelled.

                case KErrCancel:

                    break;

                // Ongoing Ussd session or the string is barred due SS request

                // or Fixed Dialling feature.

                case KErrInUse:

                case KErrAccessDenied:

                case KErrGsmSSCallBarred:

                    break;

                // No network coverage.

                case KErrGsmSMSNoNetworkService:

                    break;

                // Offline mode.

                case KErrGsmOfflineOpNotAllowed:

                    break;

                case KErrSatControl:

                    break; 

                // Unknown error.

                default:

                    break;

                }

            }

        }

    // Let the original active object (one that did the send request) run again.

    if ( iWait->IsStarted() )

        {

        iWait->AsyncStop();

        }

    }

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

// CPhCltUssdImp::SendUssd

// 

// 16-bit buffer is packed into 7-bit stream and sent.

// Default alphabet is used.

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

//

TInt CPhCltUssdImp::SendUssd( const TDesC& aMsgData )

    {

    __ASSERT_ALWAYS( aMsgData.Length() <= KPhCltUssdMax8BitCharacters,

        User::Invariant() );

    TRAPD( err ,

        {

        HBufC8* buffer8 = HBufC8::NewLC( KPhCltUssdMax7BitCharacterOctets );

        TPtr8 ptr8 = buffer8->Des();

        EncodeL( aMsgData , ptr8 );

        User::LeaveIfError( SendUssd( ptr8 ) );

        CleanupStack::PopAndDestroy(); // ptr8

        });

    return err;

    }

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

// CPhCltUssdImp::SendUssd

// 

// Packed buffer is send to the network with default alphabet.

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

//

/*****************************************************

*   Series 60 Customer / ETel

*   Series 60  ETel API

*****************************************************/

TInt CPhCltUssdImp::SendUssd( const TDesC8& aMsgData )

    {

    __ASSERT_ALWAYS( aMsgData.Length() <= KPhCltUssdMax7BitCharacterOctets,

        User::Invariant() );