/*

* Copyright (c) 2002-2010 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:  USSD Manager.

*

*/

// INCLUDE FILES

#include "cphsrvussdmanager.h" 

#include "phsrvutils.h" 

#include "cphsrvussdsendhandler.h" 

#include "cphsrvussdreceivehandler.h" 

#include "cphsrvussdnotifynwrelease.h" 

#include "cphsrvresourcemanager.h" 

#include "cphsrvussdreplytimer.h" 

#include "mphsrvussdmessagesentobserver.h" 

#include "mphsrvphoneinterface.h" 

#include "cphsrvussdsessioncancelwaiter.h" 

#include <apacmdln.h>

#include <apgtask.h>

#include <bautils.h>

#include <textresolver.h>

#include <charconv.h>

#include <gsmuelem.h>

#include <exterror.h>

#include <rmmcustomapi.h>

#include <w32std.h>

#include <apgcli.h>

#include <cphcltussd.h> 

#include <hbtextresolversymbian.h>

#include <phoneserver.rsg> 

#include "phsrvdebuginfo.h" 

#include <e32property.h>

#include <centralrepository.h>

#include <coreapplicationuisdomainpskeys.h>

// CONSTANTS

const TInt KPhSrvDefaultValue = 0x00000000;

// See SharedDataKeysVariant.h or NcnListInternalPSKeys.h

// const TInt KPhSrvUssdNoTone = 0; 

// const TInt KPhSrvUssdTimeOutObserverGranularity = 2;

// const TInt KPhSrvUssdSentMessageObserverGranularity = 2;

// See KUssdSecureId in phcltclientserver.h

//const TInt KPhSrvUssdAppUID = 0x10005955; 

const TInt KPhSrvUssdMessageQueryInterval = 500000; // 0.5 sec

//const TInt KPhSrvUssdNoteExitPeriod = 500000; // 0.5 sec

//

const TUint KPhSrvUssdDefaultDCS = 0x0f;                        // 00001111

const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguage = 0x10;// 00010000

const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars3 = 3;

const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars2 = 2;

const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageStartBit = 5;

const TUint KPhSrvUssdDcsAlphabetUCS2PrecededLanguage = 0x11;   // 00010001

const TUint KPhSrvUssdDcsAlphabetUCS2PrecededLanguageSkipChars = 2;

const TUint KPhSrvUssdDcsGeneralInformationMask = 0xc0;         // 11000000

const TUint KPhSrvUssdDcsGeneralInformation = 0x40;             // 01xxxxxx

const TUint KPhSrvUssdDcsGeneralInformationCompressed = 0x20;   // xx1xxxxx

const TUint KPhSrvUssdDcsGeneralInformationSimMask = 0x13;      // 00010011

const TUint KPhSrvUssdDcsGeneralInformationSim = 0x12;          // xxx1xx10

const TUint KPhSrvUssdDcsGeneralInformationAlphabetMask = 0x0c; // 00001100

const TUint KPhSrvUssdDcsGeneralInformationAlphabet8Bit = 0x04; // xxxx01xx

const TUint KPhSrvUssdDcsGeneralInformationAlphabetUCS2 = 0x08; // xxxx10xx

const TUint KPhSrvUssdDcsMessageHandlingAlphabetMask = 0xf4;    // 11110100

const TUint KPhSrvUssdDcsMessageHandlingAlphabet8Bit = 0xf4;    // 1111x1xx

const TInt KPhrUssdNotifyArraySize = 1;

// Refers to HbPopup::NoDismiss = 0

const TInt KPhSrvUssdPopupDismissPolicy = 0; 

// The time out only for testing, from CPhSrvUssdReplyTimer.cpp

const TUint KPhSrvUssdTimeout = 300000000;

// Use QT style localization

_LIT(KUssdReply, "txt_ussd_button_reply"); // Reply

_LIT(KUssdExit, "txt_ussd_button_exit"); // Exit

_LIT(KUssdNext, "txt_ussd_button_next"); //Next

_LIT(KUssdYes, "txt_common_button_yes"); // Yes

_LIT(KUssdNo, "txt_common_button_no"); // No

_LIT(KUssdTitle, "txt_ussd_title_message"); // Message

_LIT(KUssdDone, "txt_ussd_dpopinfo_done"); // Done

_LIT(KUssdConfirm, "txt_ussd_info_there_are_still_unread_notifications");

// MACROS

#define _DPRINT_FLAGS() \

    _DDPRINT( 4, "PhSrv.FLAGS.MsgTypeReply ", iMsgTypeReply ); \

    _DDPRINT( 4, "PhSrv.FLAGS.NwReleased   ", iNetworkReleased ); \

    _DDPRINT( 4, "PhSrv.FLAGS.SendingAck   ", iSendingAck ); \

    _DDPRINT( 4, "PhSrv.FLAGS.AcksToBeSent ", iAcksToBeSent ); \

    _DDPRINT( 4, "PhSrv.FLAGS.iSendRelease ", iSendRelease ); \

    _DDPRINT( 4, "PhSrv.FLAGS.iClearArray  ", iClearArray ); \

    _DDPRINT( 4, "PhSrv.FLAGS.iLaunchGMQ   ", iLaunchGMQ ); \

    _DDPRINT( 4, "PhSrv.FLAGS.NotifyCount  ", NotifyCount() ); \

    _DDPRINT( 4, "PhSrv.FLAGS.iShowDone    ", iShowDone ); 

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

// CLASS DECLARATION

#ifndef TPHSRVUSSDALPHABETPACKER_H

#define TPHSRVUSSDALPHABETPACKER_H

// CONSTANTS

const TUint8 KPhSrvUssdCarriageReturn = 0x0d;

/**

*  Packs and unpacks data encoded in an Ussd alphabet.

*

*  @since 1.0

*/

class TPhSrvUssdAlphabetPacker

    {

    public:  // Constructors and destructor

        /**

        * Constructor.

        *

        * @param aAlphabet The alphabet that is used.

        * @param aIsBinary Is the data binary, that will be converted.

        * @param aStartBit The start bit for conversion.

        */

        TPhSrvUssdAlphabetPacker(

            TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

            TBool aIsBinary,

            TInt aStartBit );

    public: // New functions

        /**

        * Unpacks 7-bit buffer to 8-bit buffer.

        *

        * @param aIn Descriptor where the 7-bit buffer is.

        * @param aOut 8-bit buffer to set the result.

        * @param aNumUDUnits Buffer length.

        * @return Length of the result buffer.

        */

        TInt UnpackL(

            const TDesC8& aIn,

            TDes8& aOut,

            TInt aNumUDUnits );

        /**

        * Unpacks 7-bit buffer to 8-bit and converts to unicode.

        *

        * @param aCharacterSetConverter Does the converting.

        * @param aFs File server session.

        * @param aIn Packed 7-bit buffer.

        * @param aOut Unicode buffer.

        * @param aNumUDUnits Number of charahters.

        * @return Number of used octets in 8-bit buffer.

        */

        TInt UnpackAndConvertL(

            CCnvCharacterSetConverter& aCharacterSetConverter,

            RFs& aFs,

            const TDesC8& aIn,

            TDes& aOut,

            TInt aNumUDUnits );

        /**

        * Counts the needed octet amout.

        *

        * @param aNumUDUnits Number of source characters.

        * @return Octets needed.

        */

        TInt PackedOctetsRequiredL( TInt aNumUDUnits ) const;

    private:

        // Private helper methods

        TInt ElementSizeInBitsL() const;

    private:    // Data

        // The used coding alphabet.

        TSmsDataCodingScheme::TSmsAlphabet iAlphabet;

        // Is the packed data binary.

        TBool iIsBinary;

        // The start bit for packing.

        TInt iStartBit;

    };

#endif // TPHSRVUSSDALPHABETPACKER_H

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

// TPhSrvUssdAlphabetPacker::TPhSrvUssdAlphabetPacker

// Constructor.

//

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

//

TPhSrvUssdAlphabetPacker::TPhSrvUssdAlphabetPacker(

    TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

    TBool aIsBinary,

    TInt aStartBit)

    : iAlphabet( aAlphabet ),iIsBinary( aIsBinary ),iStartBit( aStartBit )

    {

    }

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

// TPhSrvUssdAlphabetPacker::UnpackL

// Unpacks user data units from aIn and appends to aOut.

//

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

//

TInt TPhSrvUssdAlphabetPacker::UnpackL(

    const TDesC8& aIn,

    TDes8& aOut,

    TInt aNumUDUnits )

    {

    TInt length = aNumUDUnits;

    // Ensure we've got enough  output buffer

    if ( aOut.Length() + length > aOut.MaxLength() )

        {

        User::Leave(KErrCorrupt);

        }

    TInt elementSizeInBits = ElementSizeInBitsL();

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

        {

        aOut.Append( aIn );

        }

    else if ( elementSizeInBits == 7 ) // need unpacking from 7-bit data

        {

        // Get raw pointers and do unpacking

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

        const TUint8* inPtr = aIn.Ptr();

        for ( TInt i = 0; i < length; i++ )

            {

            TInt from = ( *inPtr >> iStartBit ) & 0x7F; // Take seven bits

            if ( iStartBit )

                {

                inPtr++;

                // Take more from next byte

                from |= ( *inPtr << ( 8 - iStartBit ) ) & 0x7F;

                }

            outPtr[i] = ( TUint8 ) from;

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

            }

        // The last character will be ignored if message ends

        // on an octet bounday with CR.

        if ( outPtr[ length-1 ] == KPhSrvUssdCarriageReturn && iStartBit == 0 )

            {

            length--;

            }

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

        }

    else

        {

        __ASSERT_DEBUG(EFalse,

            PhoneServerUtils::Panic( EPhoneServerPanicModeLogicFault ) );

        }

    return length;

    }

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

// TPhSrvUssdAlphabetPacker::UnpackAndConvertL

// Unpacks the converts the input data, aIn, and appends to aOut

//

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

//

TInt TPhSrvUssdAlphabetPacker::UnpackAndConvertL(

    CCnvCharacterSetConverter& aCharacterSetConverter,

    RFs& aFs,

    const TDesC8& aIn,

    TDes& aOut,

    TInt aNumUDUnits )

    {

    // Unpack first

    HBufC8* unpackedBuffer = HBufC8::NewLC( aNumUDUnits );

    TPtr8 unpackedBufferPtr( unpackedBuffer->Des() );

    UnpackL( aIn, unpackedBufferPtr,aNumUDUnits );

    // Convert

    CSmsAlphabetConverter* converter =

        CSmsAlphabetConverter::NewLC(

            aCharacterSetConverter, aFs, iAlphabet, iIsBinary );

    TPtrC convertedPtr = converter->ConvertToNativeL( *unpackedBuffer );

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

        {

        User::Leave( KErrCorrupt );

        }

    // Cleanup and return

    aOut.Append( convertedPtr );

    CleanupStack::PopAndDestroy( 2 );    // unpackedBuffer, converter

    return aNumUDUnits;

    }

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

// TPhSrvUssdAlphabetPacker::PackedOctetsRequiredL

// Returns the number of octets needed to pack the specified number of

//

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

//

TInt TPhSrvUssdAlphabetPacker::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;

    }

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

// TPhSrvUssdAlphabetPacker::ElementSizeInBitsL

// Returns the size in bits of a UDL element for the alphabet.  Leaves if

// invalid data coding scheme.

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

//

TInt TPhSrvUssdAlphabetPacker::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 ===============================

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

// CPhSrvUssdManager::CPhSrvUssdManager

//

// Constructor

//

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

//

CPhSrvUssdManager::CPhSrvUssdManager(

    RFs& aFsSession,

    CPhSrvResourceManager& aResourceManager

    )

    :CActive( EPriorityLow ),

     iFsSession( aFsSession ),

     iResourceManager( aResourceManager ),

     iDeviceDialog( NULL ),

     iDCS ( KPhCltDcsUnknown ),

     iReturnResultPckg ( iReturnResult ),

     iTextResolver ( EFalse ),

     iTextBuffer ( NULL )

    {

    CActiveScheduler::Add( this );

    }

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

// CPhSrvUssdManager::~CPhSrvUssdManager

//

// Destructor

//

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

//

CPhSrvUssdManager::~CPhSrvUssdManager()

    {

    _DPRINT( 4, "PhSrv.~CPhSrvUssdManager.start" );

    delete iUssdSendHandler;

    iUssdSendHandler = NULL;

    delete iUssdReceiveHandler;

    iUssdReceiveHandler = NULL;

    delete iUssdNotifyNWRelease;

    iUssdNotifyNWRelease = NULL;

    Cancel();

    iTimer.Close();

    delete iTextBuffer;

    iTextBuffer = NULL;

    delete iDeviceDialog;

    iDeviceDialog = NULL;

    if ( iNotifyArray )

        {

        iNotifyArray->Reset();

        }

    delete iNotifyArray;

    if ( iUssdReplyTimer )

        {

        iUssdReplyTimer->Stop();

        }

    delete iUssdReplyTimer;

    iUssdReplyTimer = NULL;

    iFsSession.Close();

    iMobileUssdMessaging.Close();

    delete iMoAckCallback;

    _DPRINT( 4, "PhSrv.~CPhSrvUssdManager.end" );

    }

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

// CPhSrvUssdManager::ConstructL

//

// Symbian OS 2nd phase constructor

//

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

//

void CPhSrvUssdManager::ConstructL( MPhSrvPhoneInterface& aPhoneInterface )

    {

    _DPRINT( 4, "PhSrv.ConstructL.Start" );

    iTextResolver = HbTextResolverSymbian::Init( 

    User::LeaveIfError( iTimer.CreateLocal() );

    User::LeaveIfError( iMobileUssdMessaging.Open( aPhoneInterface.PhSrvMobilePhone() ) );

    // Check support

    RMobileUssdMessaging::TMobileUssdCapsV1 caps;

    RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );

    User::LeaveIfError( iMobileUssdMessaging.GetCaps( pckgCaps ) );

    if ( !( ( caps.iUssdTypes & RMobileUssdMessaging::KCapsMTUssd ) == 0 &&

        ( caps.iUssdFormat & RMobileUssdMessaging::KCapsPackedString ) == 0 ) )

        {

        _DPRINT( 4, "PhSrv.CPhSrvUssdManager::ConstructL" );

        iUssdReceiveHandler = new( ELeave ) CPhSrvUssdReceiveHandler(

            *this,

            iMobileUssdMessaging );

        iUssdReceiveHandler->ConstructL();

        iUssdNotifyNWRelease = new( ELeave )  CPhSrvUssdNotifyNWRelease(

            *this,

            iMobileUssdMessaging );

        iUssdNotifyNWRelease->ConstructL();

        }

    iPhoneInterface = &aPhoneInterface;

    SendHandlerL();

    iMoAckCallback = new (ELeave) CAsyncCallBack( TCallBack( MoAckCallback, this ), CActive::EPriorityIdle );

    iVariantReadOnlyValues = KPhSrvDefaultValue;

    User::LeaveIfError( GetTelephonyVariantData() );

    _DDPRINT( 4, "PhSrv.ConstructL.iSatCanceled ", iSatCanceled );

    _DDPRINT( 4, "PhSrv.ConstructL.iShowDone ", iShowDone );

    iNotifyArray = new( ELeave ) CDesCArrayFlat( KPhrUssdNotifyArraySize );

    _DPRINT( 4, "PhSrv.ConstructL.End" );

    }

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

// CPhSrvUssdManager::SendHandlerL

//

// The send handler.

//

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

//

CPhSrvUssdSendHandler& CPhSrvUssdManager::SendHandlerL()

    {

    // If SendHandler is not created, first check that MO Ussd

    // is supported by the TSY.

    _DPRINT( 4, "PhSrv.SendHandlerL.Start" );

    if ( iUssdSendHandler == NULL )

        {

        _DPRINT( 4, "PhSrv.SendHandlerL.iUssdSendHandler.NULL" );