phoneclientserver/phoneserver/Src/Ussd/CPhSrvUssdManager.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Tue, 02 Feb 2010 01:11:09 +0200
changeset 0 ff3b6d0fd310
child 3 a4a774cb6ea7
child 12 ae8abd0db65c
permissions -rw-r--r--
Revision: 201003 Kit: 201005

/*
* Copyright (c) 2002-2005 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 <AknGlobalNote.h>
#include <aknnotedialog.h>
#include <aknstaticnotedialog.h>
#include <AknProgressDialog.h>
#include <apacmdln.h>
#include <apgtask.h>
#include <bautils.h>
#include <StringLoader.h>
#include <AknGlobalMsgQuery.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 <avkon.rsg>
#include <PhoneServer.rsg>
#include <telephonyvariant.hrh>
#include "PhSrvDebugInfo.h"
#include <e32property.h>

#include <NcnListInternalPSKeys.h>
#include <centralrepository.h>
#include <telinternalcrkeys.h>
#include <coreapplicationuisdomainpskeys.h>


// CONSTANTS
const TInt KPhSrvDefaultValue = 0x00000000;
// const TInt KPhSrvUssdNoTone = 0; // See SharedDataKeysVariant.h or NcnListInternalPSKeys.h
const TInt KPhSrvUssdTone   = 2; // See SharedDataKeysVariant.h or NcnListInternalPSKeys.h

// const TInt KPhSrvUssdTimeOutObserverGranularity = 2;
// const TInt KPhSrvUssdSentMessageObserverGranularity = 2;
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;

// 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 ),
     iDCS ( KPhCltDcsUnknown ),
     iReturnResultPckg ( iReturnResult )

    {
    CActiveScheduler::Add( this );
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::~CPhSrvUssdManager
//
// Destructor
//
// -----------------------------------------------------------------------------
//
CPhSrvUssdManager::~CPhSrvUssdManager()
    {
    _DPRINT( 4, "PhSrv.~CPhSrvUssdManager.start" );       // debug print


    delete iUssdSendHandler;
    iUssdSendHandler = NULL;

    delete iUssdReceiveHandler;
    iUssdReceiveHandler = NULL;

    delete iUssdNotifyNWRelease;
    iUssdNotifyNWRelease = NULL;

    Cancel();

    iTimer.Close();

    delete iGlobalMsgQuery;
    iGlobalMsgQuery = NULL;

    if ( iNotifyArray )
        {
        iNotifyArray->Reset();
        }
    delete iNotifyArray;
    if ( iUssdReplyTimer )
        {
        iUssdReplyTimer->Stop();
        }
    delete iUssdReplyTimer;
    iUssdReplyTimer = NULL;

    iFsSession.Close();

    iMobileUssdMessaging.Close();

    delete iMeQuHeaderText;
    iMeQuHeaderText = NULL;
    
    delete iMoAckCallback;

    _DPRINT( 4, "PhSrv.~CPhSrvUssdManager.end" );       // debug print
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::ConstructL
//
// Symbian OS 2nd phase constructor
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::ConstructL( MPhSrvPhoneInterface& aPhoneInterface )
    {
    _DPRINT( 4, "PhSrv.ConstructL.Start" );       // debug print
    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() );

    iMeQuHeaderText = iResourceManager.ReadResourceLC(
        R_PHSRV_USSD_MESQUERY_MESSAGE);
    CleanupStack::Pop( iMeQuHeaderText );

	_DDPRINT( 4, "PhSrv.ConstructL.iSatCanceled ", iSatCanceled );
    _DDPRINT( 4, "PhSrv.ConstructL.iShowDone ", iShowDone );
    iNotifyArray = new( ELeave ) CDesCArrayFlat( KPhrUssdNotifyArraySize );
    _DPRINT( 4, "PhSrv.ConstructL.End" );       // debug print
    }


// -----------------------------------------------------------------------------
// 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" );       // debug print
    if ( iUssdSendHandler == NULL )
        {
        _DPRINT( 4, "PhSrv.SendHandlerL.iUssdSendHandler.NULL" );       // debug print
        RMobileUssdMessaging::TMobileUssdCapsV1 caps;
        RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );
        User::LeaveIfError( iMobileUssdMessaging.GetCaps( pckgCaps ) );
        _DPRINT( 4, "PhSrv.SendHandlerL.iMobileUssdMessaging.GetCaps" );       // debug print

        if ( ( caps.iUssdTypes & RMobileUssdMessaging::KCapsMOUssd ) == 0 ||
            ( caps.iUssdFormat & RMobileUssdMessaging::KCapsPackedString )
            == 0 )
            {
            _DPRINT( 4, "PhSrv.SendHandlerL.KErrNotSupported" );       // debug print
            User::Leave( KErrNotSupported );
            }

        iUssdSendHandler =
            new( ELeave ) CPhSrvUssdSendHandler(
                *this,
                iMobileUssdMessaging,
                *iPhoneInterface );
        }
    _DPRINT( 4, "PhSrv.SendHandlerL.End" );       // debug print
    return *iUssdSendHandler;
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::SendUssdL
//
// Send the USSD message.
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::SendUssdL(
    const TDesC8& aMsgData,
    RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttribute,
    MPhSrvUssdMessageSentObserver& aObserver )
    {
    _DPRINT( 4, "PhSrv.SendUssdL.Start ######" );           // debug print
    _DPRINT_FLAGS();
    
    if ( iObserver && iNetworkReleased ) 
        {
        // Network has been released but the previous send request is still alive.
        // Cancel the pervious send operation, complete the old request with error
        // and clean up the pointer.
        _DPRINT( 4, "PhSrv.SendUssdL.Error.Complete.Existing" );           // debug print
        if ( iUssdSendHandler ) 
            {
            iUssdSendHandler->Cancel();
            }
        iObserver->UssdMessageSentObserverHandleResult( KErrSessionClosed );
        iObserver = NULL;
        }
    
    if ( iObserver || iSendingAck )
        {
        _DPRINT( 4, "PhSrv.SendUssdL.KErrInUse" );           // debug print
        // Other client is using the service.
        User::Leave( KErrInUse );
        }

    // Check that message type is set
    if( ( aMsgAttribute.iFlags & RMobileUssdMessaging::KUssdMessageType )
        == 0 )
        _DPRINT( 4, "PhSrv.SendUssdL.KUssdMessageType.0" );       // debug print
        {
        // Mesasge type not set -> Set it.
        aMsgAttribute.iFlags |= RMobileUssdMessaging::KUssdMessageType;
        if ( NetworkWaitingForAnAnswer() )
            {
            // Network is waiting for an answer
            _DPRINT( 4, "PhSrv.SendUssdL.EUssdMOReply" );	// debug print
            aMsgAttribute.iType = RMobileUssdMessaging::EUssdMOReply;
            }
        else
            {
            _DPRINT( 4, "PhSrv.SendUssdL.EUssdMORequest" );  // debug print
            aMsgAttribute.iType = RMobileUssdMessaging::EUssdMORequest;
            }
        }
        
    RMobileUssdMessaging::TMobileUssdAttributesV1Pckg attribs( aMsgAttribute );
    iShowDone = ETrue;
    _DPRINT( 4, "PhSrv.SendUssdL.iShowDone.ETrue" );
    _DPRINT( 4, "PhSrv.SendUssdL.Send" );           // debug print
    SendHandlerL().SendUssdL( aMsgData , attribs );
    iObserver = &aObserver;
    // Not closing nor closed anymore
    iNetworkReleased = EFalse;
    iSendRelease = EFalse;
    iClearArray = EFalse;
    
    // Reply timer can be killed here... Receive event might come right after this
    // which will setup the timer again if needed.
    if ( NetworkWaitingForAnAnswer() )
        {
        _DPRINT( 4, "PhSrv.SendUssdCancel.TimerStop" );   // debug print
        iUssdReplyTimer->Stop();
        }
    _DPRINT( 4, "PhSrv.SendUssdL.End" );           // debug print
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::NetworkWaitingForAnAnswer
// -----------------------------------------------------------------------------
//
TBool CPhSrvUssdManager::NetworkWaitingForAnAnswer() 
    {
    return iUssdReplyTimer && iUssdReplyTimer->IsTimerActive();
    }
// -----------------------------------------------------------------------------
// CPhSrvUssdManager::SendUssdCancel
//
// Cancel the USSD sending.
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::SendUssdCancel()
    {
    _DPRINT( 4, "PhSrv.SendUssdCancel.Start #######" );           // debug print

    // Ack sending should not be canceled unless it's about terminating
    // the whole session
    _DPRINT_FLAGS();
    if ( !iSendingAck || iSendRelease ) 
        {
        _DPRINT( 4, "PhSrv.SendUssdCancel.DoingCancel" );
        iUssdSendHandler->SendUssdCancel();
        }

    if ( iHavePendingSatMessagePointer )
        {
        _DPRINT( 4, "PhSrv.SendUssdCancel.SatCancel" );
        iSatCanceled = ETrue;
        }
    iObserver = NULL;
    
    SetActiveIfPendingNotificationsExist();
    _DPRINT( 4, "PhSrv.SendUssdCancel.End" );           // debug print
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::SetActiveIfPendingNotificationsExist
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::SetActiveIfPendingNotificationsExist()
    {
    if ( !IsActive() && NotifyCount() > 0 )
        {
        _DPRINT( 4, "PhSrv.AcrtivateIf.NotActiveSelf" );
        iLaunchGMQ = ETrue;
        iNotifyMessage = ETrue;
        _DPRINT( 4, "PhSrv.SendUssdCancel.iNotifyMessage.ETrue" );
        iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );
        SetActive();
        _DPRINT_FLAGS();
        _DDPRINT( 4, "PhSrv.AcrtivateIf.SetActive ", iStatus.Int() );
        }
    }
// -----------------------------------------------------------------------------
// CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL
//
//
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL( TInt aError )
    {
    // debug print
    _DDPRINT(
        4,
        "PhSrv.UssdNetworkObserverHandleSendEventL.Start: ##### ",
        aError );

    // complete SAT if needed
    if ( aError < KErrNone )
        {
        // debug print
        _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleSendEventL.CompleteSat" );
        CompleteSatL( NULL, aError );
        }

    if ( iObserver )
        {
        // debug print
        _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleSendEventL.Observer" );

        iObserver->UssdMessageSentObserverHandleResult( aError );
        iObserver = NULL;
        }
    
    iSendingAck = EFalse;
    
    AsyncProcessMoAcks();
    
    // debug print
    _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleSendEventL.End" );
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::UssdAppTaskExists
//
//
//
// -----------------------------------------------------------------------------
//
TBool CPhSrvUssdManager::UssdAppTaskExistsL()
{   
    TBool ret = EFalse;
    RWsSession wsSession;
    User::LeaveIfError(wsSession.Connect());
    _DPRINT( 4, "PhSrv.UssdAppTaskExists.wsSession.Connect" );
    CleanupClosePushL(wsSession);
    TApaTaskList tasklist(wsSession);
    TApaTask task = tasklist.FindApp(TUid::Uid(KPhSrvUssdAppUID));
    ret = task.Exists();

    CleanupStack::PopAndDestroy();
    return ret;
}

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL
//
//
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL(
    const TDes8& aMsgData,
    const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes,
    TInt aError )
    {
    _DDPRINT(
        4,
        "PhSrv.UssdNetworkObserverHandleReceivedEventL.Start: ### ",
        aError );
    _DPRINT_FLAGS();
    if ( aError != KErrNone )
        {
        TurnLightsOn(); //Ensure lights on
        // debug print
        _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.ShErNote" );
        ShowErrorNoteL( aError );
        }
    else if ( iSendRelease )
        {
        // Ignore if sendrelease is to be done. If the message was
        _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.SendRelease.Ignore" );
        }
    else
        {
        UssdHandleReceivedEventL( aMsgData, aMsgAttributes );
        }
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::UssdHandleReceivedEventL
//
//
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::UssdHandleReceivedEventL(
    const TDes8& aMsgData,
    const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes )
    {
    // This always is either ongoing transaction or starting a new based
    // on incoming message, mark transaction to be open.
    iNetworkReleased = EFalse;
		
    // 2. Complete Send with some positive value.
	if ( iObserver )
        {
        // debug print
        _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Observer" );
        UssdNetworkObserverHandleSendEventL( 1 ); // some positive value
        }
	
    if ( aMsgAttributes.iFlags&RMobileUssdMessaging::KUssdMessageType &&
         aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTRequest )
        {
        // 3. Stop old reply timer and start new one if needed.
        RestartReplyTimerL();
        _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.Timer.Stop" );
        _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.Timer.New" );
        }
    _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Decode" );
    TUint8 dcs = KPhSrvUssdDefaultDCS;
    if(aMsgAttributes.iFlags & RMobileUssdMessaging::KUssdMessageDcs)
        {
        dcs = aMsgAttributes.iDcs;
        }
    iDecodedMessage.Zero();
    iReceivedMessage.Zero();
    DecodeL(aMsgData, iDecodedMessage, dcs);
    if(iDecodedMessage.Length() > 0)
        {
        iReceivedMessage = iDecodedMessage;
        }
    // 5. Show note.
    // debug print
    _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Note" );
    if ( !( aMsgAttributes.iFlags & RMobileUssdMessaging::KUssdMessageType ) ||
            aMsgAttributes.iType != RMobileUssdMessaging::EUssdMTRequest )
        {
        if ( !ShowNotesL() )
            {
            // debug print
            _DPRINT( 4,
                "PhSrv.UssdHandleReceivedEventL.SAtReturn" );
            return;
            }
        }

    // empty string is handled as ok message
    if ( !iDecodedMessage.Length() )
        {
        TurnLightsOn(); //Ensure lights on
        // debug print
        _DPRINT( 4,
            "PhSrv.UssdHandleReceivedEventL.EmptyString" );
        
        ShowDoneNoteL();

        // debug print
        _DPRINT( 4,
            "PhSrv.UssdHandleReceivedEventL.EmptyString.OK" );
        }
    else
        {
       	_DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.String" );
        iNotifyMessage = ( aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTNotify );
        _DDPRINT( 4, "PhSrv.UssdHandleReceivedEventL.iNotifyMessage: ", iNotifyMessage );
        _DDPRINT( 4, "PhSrv.UssdNOHREventL.iNotifyMessage: ", iNotifyMessage );
        iMsgTypeReply = ( aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTReply );
        _DDPRINT( 4, "PhSrv.UssdHandleReceivedEventL.iMsgTypeReply: ", iMsgTypeReply );
        
        if ( iNotifyMessage ) 
            {
            // need to send an MO ack
            iAcksToBeSent ++;
            }
        
        if ( iNotifyMessage || iMsgTypeReply )
        	{
        	//This is for reply message in notifyarray
        	iNotifyMessage = ETrue;
        	_DDPRINT( 4, "PhSrv.UssdHandleReceivedEventL.iNotifyMessage: ", iNotifyMessage );

	        //Notify added to array
        	iNotifyArray->AppendL( iReceivedMessage );

        	_DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.AppendL" );       // debug print
        	UpdateNotifyMessage();

        	if ( !iSendRelease && NotifyCount() <= 1 )
				{
				_DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.!SendRelease.Cancel" );       // debug print
				Cancel();
				}
        	}
        else
       		{
       		// New message deletes old message, i.e. Cancel existing query.
       		Cancel();
			_DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.NewAnswerable" );       // debug print
       		}

        if ( !iGlobalMsgQuery )
            {
            iGlobalMsgQuery = CAknGlobalMsgQuery::NewL();
            }

        // Delay after message query so that application execution order will
        // be correct.
        iGlobalMsgQuery->SetExitDelay( KPhSrvUssdNoteExitPeriod );

        TInt softkeys = R_AVKON_SOFTKEYS_USSD_ANSWER_EXIT__ANSWER;
        if( !( aMsgAttributes.iFlags & RMobileUssdMessaging::KUssdMessageType )
             || aMsgAttributes.iType != RMobileUssdMessaging::EUssdMTRequest )
            {
            softkeys = R_AVKON_SOFTKEYS_EXIT;
            }

        // Set timer that lauches Global MessageQuery after time interval.
        iSoftkeys = softkeys;

        // debug print
        _DPRINT( 4,
            "PhSrv.UssdHandleReceivedEventL.String.Middle" );

        // Play the USSD tone if needed. Logically should be in RunL, but here
        // to give better balancing with voice and visible message.
        if ( IsTelephonyFeatureSupported( KTelephonyLVFlagUssdTone ) )
            {
            _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.PlayTone" );
            PlayUssdTone();
            }

        // Launch the new message query
        if ( !IsActive() )
            {
            iLaunchGMQ = ETrue;
            iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );
            SetActive();
            }
        AsyncProcessMoAcks();
        }
    _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Editor" );
    if( aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTRequest && UssdAppTaskExistsL() )
        {
        iEmptyEditor = ETrue;
        }
    _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.End" );
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::RestartReplyTimerL
//
//
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::RestartReplyTimerL()
    {
    if ( iUssdReplyTimer )
        {
        _DPRINT( 4, "PhSrv.RestartReplyTimerL.Stop" );
        iUssdReplyTimer->Stop();
        }

    if ( !iUssdReplyTimer )
        {
        _DPRINT( 4, "PhSrv.RestartReplyTimerL.New" );
        iUssdReplyTimer = CPhSrvUssdReplyTimer::NewL( *this );
        }
    
    _DPRINT( 4, "PhSrv.RestartReplyTimerL.Start" );
    iUssdReplyTimer->Start();
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL
//
//
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL(
const RMobilePhone::TMobilePhoneSendSSRequestV3 & aReturnResult,
TInt aError )
	{
 	_DDPRINT( 4, "PhSrv.UssdNotifyNWRelease ##### ", aError ); // debug print
    _DPRINT_FLAGS();
 	TBool showNotes = ShowNotesL();
 	iNetworkReleased = ETrue;
 	iSendingAck = EFalse;
    iSendRelease = EFalse;
 	iAcksToBeSent = 0;
 	
 	if ( iHavePendingSatMessagePointer )
 		{
 		iReturnResult = aReturnResult;
 		if ( !iSatCanceled )
 			{
 			CompleteSatL(&iReceivedMessage, aError );
			_DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.CompleteSat" );       // debug print
 			}
 		}
 	if ( iUssdReplyTimer && iUssdReplyTimer->IsTimerActive() )
    	{
    	_DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.Timer.Stop" );
    	iUssdReplyTimer->Stop();
    	Cancel();
    	CheckArray();
    	}
    if ( showNotes && iShowDone )
        {
        ShowDoneNoteL();
        }
    if ( iUssdSendHandler && iSendingAck ) 
        {
        // if we are sending ack, it can be canceled.
        iUssdSendHandler->Cancel();
        }
    
    iSatCanceled = EFalse;
    _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.iSatCanceled.EFalse" );
    iShowDone = EFalse;
    _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.Ending" );
    _DPRINT_FLAGS();
    _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.End" );
	}

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::ShowDoneNoteL
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::ShowDoneNoteL()
    {
    _DDPRINT( 4, "PhSrv.ShowDoneNoteL.iShowDone", iShowDone );
    // Show global confirmation note "Done"
    HBufC* noteText = iResourceManager.ReadResourceLC( R_PHSRV_TEXT_DONE );
    CAknGlobalNote* note = CAknGlobalNote::NewLC();
    note->ShowNoteL( EAknGlobalConfirmationNote, *noteText );
    CleanupStack::PopAndDestroy( note );
    CleanupStack::PopAndDestroy( noteText );
    iShowDone = EFalse;
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::ShowErrorNoteL
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::ShowErrorNoteL( TInt aError )
    {
    _DDPRINT( 4, "PhSrv.ShowErrorNoteL.Start ", aError );
    if ( aError == KErrCancel )
        {
        _DPRINT( 4, "PhSrv.ShowErrorNoteL.Return" );
        return;
        }

    CTextResolver* textResolver = CTextResolver::NewLC();

    HBufC* buffer = textResolver->ResolveErrorString( aError ).AllocLC();

    CAknGlobalNote* note = CAknGlobalNote::NewLC();
    note->ShowNoteL( EAknGlobalErrorNote, *buffer );

    CleanupStack::PopAndDestroy( 3 ); // note, buffer, textResolver
    _DPRINT( 4, "PhSrv.ShowErrorNoteL.End" );
    return;
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::DecodeL
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::DecodeL(
    const TDesC8& aSrc,
    TDes& aDes ,
    TUint8 aDcs )
    {
    _DPRINT( 4, "PhSrv.DecodeL.Start" );
    aDes.Zero();
    CCnvCharacterSetConverter* charConv = CCnvCharacterSetConverter::NewLC();

    iDCS = KPhCltDcsUnknown; // default

    // Check DCS
    TSmsDataCodingScheme::TSmsAlphabet alphabet =
        TSmsDataCodingScheme::ESmsAlphabet7Bit; // default
    TUint cutChars = 0;
    TUint startBit = 0;

    // Codes from GSM 03.38
    if ( aDcs == KPhSrvUssdDcsAlphabetDefaultPrecededLanguage )
        {
        FindFirstCarriageReturnL( aSrc , cutChars , startBit );
        }
    else if ( aDcs == KPhSrvUssdDcsAlphabetUCS2PrecededLanguage )
        {
        alphabet = TSmsDataCodingScheme::ESmsAlphabetUCS2;
        cutChars = KPhSrvUssdDcsAlphabetUCS2PrecededLanguageSkipChars;
        }
    else if ( (aDcs&KPhSrvUssdDcsGeneralInformationMask)  ==
            KPhSrvUssdDcsGeneralInformation ) // General data coding information
        {
        //Is text compressed?
        if ( aDcs & KPhSrvUssdDcsGeneralInformationCompressed )
            {
            _DPRINT( 4, "PhSrv.DecodeL.KErrNotSupported" );
            User::Leave( KErrNotSupported );
            }
        // Is SIM specific message
        else if ( ( aDcs & KPhSrvUssdDcsGeneralInformationSimMask )
                   == KPhSrvUssdDcsGeneralInformationSim )
            {
            _DPRINT( 4, "PhSrv.DecodeL.KErrAbort" );
            User::Leave( KErrAbort ); // Do not show any messages
            }
        // 8 bit data?
        else if ( ( aDcs&KPhSrvUssdDcsGeneralInformationAlphabetMask ) ==
                   KPhSrvUssdDcsGeneralInformationAlphabet8Bit )
            {
            alphabet = TSmsDataCodingScheme::ESmsAlphabet8Bit;
            }
        // UCS2 bit data?
        else if ( ( aDcs&KPhSrvUssdDcsGeneralInformationAlphabetMask ) ==
                   KPhSrvUssdDcsGeneralInformationAlphabetUCS2 )
            {
            alphabet = TSmsDataCodingScheme::ESmsAlphabetUCS2;
            }
        }
    // Data coding/message handling
    else if ( ( aDcs & KPhSrvUssdDcsMessageHandlingAlphabetMask )
               == KPhSrvUssdDcsMessageHandlingAlphabet8Bit )
        {
        alphabet = TSmsDataCodingScheme::ESmsAlphabet8Bit;
        }

    TPhSrvUssdAlphabetPacker* packer =
        new ( ELeave ) TPhSrvUssdAlphabetPacker( alphabet , EFalse, startBit );
    CleanupStack::PushL( packer );

    if ( alphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit )
        {
        TInt numberOfElem = ( ( aSrc.Length() - cutChars ) * 8 - startBit ) / 7;
        packer->UnpackAndConvertL(
            *charConv ,
            iFsSession ,
            aSrc.Right( aSrc.Length() - cutChars ),
            aDes ,
            numberOfElem );

        // DCS was 7-bit data.
        iDCS = KPhCltDcs7Bit;
        }
    else // ESmsAlphabet8Bit || ESmsAlphabetUCS2
        {
        CSmsAlphabetConverter* converter =
            CSmsAlphabetConverter::NewLC(
                *charConv , iFsSession,alphabet,EFalse );

        aDes = converter->ConvertToNativeL(
            aSrc.Right( aSrc.Length() - cutChars ) );
        CleanupStack::PopAndDestroy( converter );

        if( alphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit )
            {
            // DCS was 8-bit data.
            iDCS = KPhCltDcs8Bit;
            }
        else if( alphabet == TSmsDataCodingScheme::ESmsAlphabetUCS2 )
            {
            // DCS was UCS2 data.
            iDCS = KPhCltDcsUcs2;
            }
        // If DCS not 8-bit or UCS2, then EPhCltDcsUnknown is returned.
        }

    //
    CleanupStack::PopAndDestroy(2); // packer, charConv
    _DPRINT( 4, "PhSrv.DecodeL.End" );
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::FindFirstCarriageReturnL
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::FindFirstCarriageReturnL(
    const TDesC8& aBuffer ,
    TUint& aSkipChars ,
    TUint& aStartBit )
    {
    _DPRINT( 4, "PhSrv.FindFirstCarriageReturnL.Start" );
    if ( aBuffer.Length() < 3 )
        {
        _DPRINT( 4, "PhSrv.FindFirstCarriageReturnL.KErrUnderflow" );
        User::Leave( KErrUnderflow );
        }

    aSkipChars = 0;
    aStartBit = 0;

    // Try out two different cases:
    // 1. Find CR from thrid byte
    // 2. Find CR from second byte, starting from bit 6

    // 1.:
    if ( aBuffer[2] == KPhSrvUssdCarriageReturn )
        {
        aSkipChars = KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars3;
        aStartBit = 0;
        _DPRINT( 4, "PhSrv.FindFirstCarriageReturnL.ThirdByte.Return" );
        return;
        }

    // 2.:
    // First put the pieces together and then compare
    // Take last 2 bits from the second byte:
    TUint result1 = aBuffer[1];
    result1 = result1 >> 6;

    // Take first 5 bits from the third byte:
    TUint result2 = aBuffer[2];
    result2 = result2 & 0x1f; // bits 0-4.
    result2 = result2 << 2; // move to bits 2-6.

    TUint result = result1 + result2; // 0000 00xx + 0xxx xx00
    if ( result == KPhSrvUssdCarriageReturn )
        {
        aSkipChars = KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars2;
        aStartBit = KPhSrvUssdDcsAlphabetDefaultPrecededLanguageStartBit;
        _DPRINT( 4, "PhSrv.FindFirstCarriageReturnL.SecondByte.Return" );
        return;
        }

    // Is was not case 1. or 2. so we are not supporting sort of string.
    User::Leave( KErrNotSupported );
    _DPRINT( 4, "PhSrv.FindFirstCarriageReturnL.KErrNotSupported" );
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::UssdReplyTimerObserverHandleExpired
//
//
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::UssdReplyTimerObserverHandleExpiredL( TInt aError )
    {
    _DDPRINT( 4, "PhSrv.ReplyTimer.Start.aError ", aError );     // debug print
    delete iUssdReplyTimer;
    iUssdReplyTimer = NULL;

    if ( aError == KErrNone &&
         IsActive() &&
         iGlobalMsgQuery )
        {
        Cancel();
        // Terminates USSD session.
        _DPRINT( 4, "PhSrv.ReplyTimer.SendRelease" );     // debug print
        if ( iNotifyArray ) 
            {
            iNotifyArray->Reset();
            }
        TryCloseSession();
        }
    _DPRINT( 4, "PhSrv.ReplyTimer.End" );     // debug print
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::RunL
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::RunL()
    {
    _DPRINT( 4, "PhSrv.RunL.Start" );           // debug print

    ProcessMoAcksL();
    
    if ( iLaunchGMQ )
        {
        LaunchGlobalMessageQueryL();
        // Do not launch Global Message Query next time.
        iLaunchGMQ = EFalse;
        _DPRINT( 4, "PhSrv.iLaunchGMQ.EFalse" );
        }
    else
        {
        iStartEditor = EFalse;
        
        TInt key = iStatus.Int();
        if ( key == EEikBidOk ) // OK key
            {
            if ( NetworkWaitingForAnAnswer() )
                {
                key = EAknSoftkeyShow;
                }
            else
                {
                key = EAknSoftkeyExit;
                }
            }

        switch( key )
            {
            case EAknSoftkeyShow:
                {
                // Answer
                iStartEditor = ETrue;
                iShowDone = EFalse;
                // Start the USSD editor now.
                _DPRINT( 4, "PhSrv.RunL.RequestStartEditingL" ); // debug print
                RequestStartEditingL();
                break;
                }
            case EAknSoftkeyYes:
                {
                _DPRINT( 4, "PhSrv.RunL.SK.Yes" );
                iClearArray = EFalse;
                iNotifyArray->Reset();
                TryCloseSession();
                break;
                }
            case EAknSoftkeyCancel:
                _DPRINT( 4, "PhSrv.RunL.SK.Cancel" ); 
                if ( iHavePendingSatMessagePointer )
                    {
                    iSatCanceled = ETrue;
                    CompleteSatL( &iReceivedMessage, KErrCancel );
                    _DPRINT( 4, "PhSrv.RunL.CompleteSatL" );
                    }
                // fall through.
            case EAknSoftkeyExit:
                _DPRINT( 4, "PhSrv.RunL.SK.Exit" ); 
                ClearArrayL();
                TryCloseSession();
                break;
            case EAknSoftkeyBack:
                _DPRINT( 4, "PhSrv.RunL.SK.Back" ); 
                ClearArrayL();
                TryCloseSession();
                break;
            case EAknSoftkeyNo:
                _DPRINT( 4, "PhSrv.RunL.SK.No" );
                iClearArray = EFalse;
                iNotifyMessage = ETrue; // for removing the yes/no query
                // fall through.
            case EAknSoftkeyNext:
                _DPRINT( 4, "PhSrv.RunL.SK.Next" ); 
                CheckArray();
                TryCloseSession();
                break;
            default:
                _DPRINT( 4, "PhSrv.RunL.SK.Default" ); 
                break;
            }
        _DPRINT( 4, "PhSrv.RunL.End" );     // debug print
        }
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::LaunchGlobalMessageQueryL
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::LaunchGlobalMessageQueryL()
    {
    _DPRINT( 4, "PhSrv.LGMQ.start" );
    _DPRINT_FLAGS();
    if ( iNotifyMessage )
        {
        _DDPRINT( 4, "PhSrv.LGMQ.NotifyMessage", iNotifyMessage );
        iNotifyMessage = ETrue;
        TInt count = NotifyCount();
        if ( count > 1 )
            {
            iSoftkeys = R_AVKON_SOFTKEYS_NEXT_EXIT__NEXT;
            }
        else
            {
            iSoftkeys = R_AVKON_SOFTKEYS_EXIT;
            }
        if ( iClearArray )
            {
            iSoftkeys = R_AVKON_SOFTKEYS_YES_NO;
            }
        iReceivedMessage.Zero();
        iReceivedMessage = (*iNotifyArray)[0];
        }
    TurnLightsOn(); //Ensure lights on

    _DPRINT( 4, "PhSrv.LGMQ.ShMsgQuery" ); // debug print
    // Launch Global MessageQuery as requested.
    iGlobalMsgQuery->ShowMsgQueryL(iStatus, iReceivedMessage, iSoftkeys,
            *iMeQuHeaderText, KNullDesC);
    _DPRINT( 4, "PhSrv.LGMQ.SetActive" );
    SetActive();
    iShowDone = EFalse;
    // Do nothing else in RunL this time.
    _DPRINT( 4, "PhSrv.LGMQ.ShMsgQuery.ret" ); // debug print
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::ProcessMoAcksL()
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::ProcessMoAcksL()
    {
    //Acknowledgment is sent if notify message
    if ( iNotifyMessage && iAcksToBeSent )
        {
        _DPRINT( 4, "PhSrv.LGMQ.SendMoAcknowledgementL, start" );
        _DPRINT_FLAGS();
        if ( iUssdSendHandler && !iUssdSendHandler->IsActive() &&
             !iNetworkReleased && !iSendRelease && !iSendingAck )
            {
            _DPRINT( 4, "PhSrv.LGMQ.MoAckNeededToBeSent" );
            SendMoAcknowledgementL();
            iAcksToBeSent--;
            iSendingAck = ETrue;
            }
        _DPRINT( 4, "PhSrv.LGMQ.SendMoAcknowledgementL, end" );
        }
    }
 
// -----------------------------------------------------------------------------
// CPhSrvUssdManager::AsyncProcessMoAcks()
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::AsyncProcessMoAcks()
    {
    if ( iMoAckCallback ) 
        {
        iMoAckCallback->CallBack();
        _DPRINT( 4, "PhSrv.LGMQ.AsyncProcessMoAcksL, queued" );
        }
    }
// -----------------------------------------------------------------------------
// CPhSrvUssdManager::MoAckCallback()
// -----------------------------------------------------------------------------
//
TInt CPhSrvUssdManager::MoAckCallback( TAny *aUssdManager )
    {
    _DPRINT( 4, "PhSrv.MoAckCallback.start" );
    if ( aUssdManager )
        {
        CPhSrvUssdManager* manager = static_cast<CPhSrvUssdManager*>( aUssdManager );
        TRAP_IGNORE( manager->ProcessMoAcksL() );
        }
    _DPRINT( 4, "PhSrv.MoAckCallback.end" );
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::TryCloseSession()
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::TryCloseSession() 
    {
    // Dismiss, cancel the session.
    _DPRINT( 4, "PhSrv.CheckAndCloseSession.close" );  // debug print
       
    iShowDone = EFalse;
    iEmptyEditor = EFalse;
    
    // If the notification array is empty, close the session.
    if ( NotifyCount() == 0 && !iNetworkReleased )
        {
        CloseSession();
        }
    }
// -----------------------------------------------------------------------------
// CPhSrvUssdManager::CloseSession()
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::CloseSession()
    {
    iSendRelease = ETrue;
    iClearArray = EFalse;
    iAcksToBeSent = 0;
    _DPRINT( 4, "PhSrv.CheckAndCloseSession.canceling" ); 
    SendUssdCancel();
    Cancel();
        
    // Terminates USSD session.
    if ( !iNetworkReleased ) 
        {
        iUssdSendHandler->SendReleaseSession();
        }
    if ( iUssdReplyTimer )
        {
        _DPRINT( 4, "PhSrv.CheckAndCloseSession.Timer.Stop" );
        iUssdReplyTimer->Stop();
        }
    }
 
// -----------------------------------------------------------------------------
// CPhSrvUssdManager::CheckArray()
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::CheckArray()
	{
	_DPRINT( 4, "PhSrv.CheckArray.Start" );     // debug print
 	if (iNotifyArray  && NotifyCount() > 0)
		{
		if 	( !iNotifyMessage && !iClearArray )
			{
			iLaunchGMQ = ETrue;
			iNotifyMessage = ETrue;
			_DPRINT( 4, "PhSrv.CheckArray.iNotifyMessage.ETrue" );
			iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );
			_DDPRINT( 4, "PhSrv.CheckArray.SetActive.NoNotifyMessage ", iStatus.Int() );
			SetActive();
			}
		else if( NotifyCount() > 1 )
			{
			( iNotifyArray )->Delete( 0 );
			( iNotifyArray )->Compress();
			iLaunchGMQ = ETrue;
			iNotifyMessage = ETrue;
			_DPRINT( 4, "PhSrv.CheckArray.iNotifyMessage.ETrue" );
			iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );
			_DDPRINT( 4, "PhSrv.CheckArray.SetActive.NotifyCount>1 ", iStatus.Int() );
			SetActive();
			}
 		else
     		{
			iNotifyArray->Reset();
     		iNotifyMessage = EFalse;
     		_DPRINT( 4, "PhSrv.CheckArray.iNotifyMessage.EFalse" );
     		}
  		}
    _DPRINT_FLAGS();
  	_DPRINT( 4, "PhSrv.CheckArray.End" );     // debug print
 	}

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::ClearArray()
// -----------------------------------------------------------------------------
//
  void CPhSrvUssdManager::ClearArrayL()
  	{
  	_DPRINT( 4, "PhSrv.ClearArrayL.Start" );     // debug print
  	if (iNotifyArray && NotifyCount() > 0)
	  	{
	  	if (iNotifyMessage && NotifyCount()== 1 )
	  		{
	  		iNotifyArray->Reset();
	  		}
	  	else
	  		{
	  		iReceivedMessage.Zero();
	  		HBufC* unreadText = iResourceManager.ReadResourceLC( R_PHSRV_TEXT_UNREAD );
	  		TPtr pMessage( unreadText->Des() );
	  		iReceivedMessage.Append( pMessage );
	  		iNotifyArray->InsertL( 0, iReceivedMessage );
	        CleanupStack::PopAndDestroy( unreadText );
	  		iLaunchGMQ = ETrue;
	  		iNotifyMessage = ETrue;
	  		_DPRINT( 4, "PhSrv.ClearArrayL.iNotifyMessage.ETrue" );
	  		iClearArray = ETrue;
	  		iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );
	  		_DDPRINT( 4, "PhSrv.ClearArrayL.iTimer ", iStatus.Int() );
			SetActive();
	  		}
	  	}
    _DPRINT_FLAGS();
	_DPRINT( 4, "PhSrv.ClearArrayL.End" );     // debug print
  	}

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::NotifyCount()
// -----------------------------------------------------------------------------
//
  TInt CPhSrvUssdManager:: NotifyCount()
  {
  return iNotifyArray->Count();
  }

  // -----------------------------------------------------------------------------
// CPhSrvUssdManager::UpdateNotifyMessage()
// -----------------------------------------------------------------------------
//
  void CPhSrvUssdManager:: UpdateNotifyMessage()
  	{
  	_DDPRINT( 4, "PhSrv.UpdateNotifyMessage.Start, clear: ", iClearArray );     // debug print
  	if (NotifyCount() > 1 && !iClearArray )
  		{
  		_DPRINT( 4, "PhSrv.UpdateNotifyMessage" );     // debug print
  		iGlobalMsgQuery->UpdateMsgQuery( R_AVKON_SOFTKEYS_NEXT_EXIT__NEXT );
  		}
  	_DPRINT( 4, "PhSrv.UpdateNotifyMessage.End" );     // debug print
  	}

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::DoCancel
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::DoCancel()
    {
    _DPRINT( 4, "PhSrv.DoCancel.Start" ); // debug print
    iTimer.Cancel();
    iLaunchGMQ = EFalse;

    if ( iGlobalMsgQuery )
        {
        _DPRINT( 4, "PhSrv.DoCancel" ); // debug print
        iGlobalMsgQuery->CancelMsgQuery();
        }
    _DPRINT( 4, "PhSrv.DoCancel.End" ); // debug print
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::RunError
//
// Because the RunL can leave, this function exists.
// In case of error, just returning KErrNone is OK.
// -----------------------------------------------------------------------------
//
TInt CPhSrvUssdManager::RunError( TInt /*aError*/ )
    {
    _DPRINT( 4, "PhSrv.RunError.Start" );     // debug print
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::RequestStartEditingL
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::RequestStartEditingL()
    {
    _DPRINT( 4, "PhSrv.UssdM.RequestStartEditingL.start" ); // debug print

    RWsSession wsSession;
    User::LeaveIfError( wsSession.Connect() );
    _DPRINT( 4, "PhSrv.RequestStartEditingL.wsSession.connect" );     // debug print
    CleanupClosePushL( wsSession );

    // Find the task with name
    TApaTaskList tasklist( wsSession );
    TApaTask task = tasklist.FindApp( TUid::Uid( KPhSrvUssdAppUID ) );

    // If task exists, bring it to foreground
    if ( task.Exists() )
        {
        _DPRINT( 4, "PhSrv.UssdM.RequestStartEditingL.task.BringToForeground" );
        task.BringToForeground();
        }
    else
        {
        // Start new app
        RApaLsSession apaLsSession;
        User::LeaveIfError( apaLsSession.Connect() );
        _DPRINT( 4, "PhSrv.RequestStartEditingL.apaLsSession.connect" );     // debug print
        CleanupClosePushL( apaLsSession );

        TApaAppInfo appInfo;
        TInt err = apaLsSession.GetAppInfo(
            appInfo,
            TUid::Uid( KPhSrvUssdAppUID )  );
        if ( err == KErrNone )
            {
            _DDPRINT( 4, "PhSrv.RequestStartEditingL.GetAppInfo ", err );     // debug print

        #ifndef SYMBIAN_SUPPORT_UI_FRAMEWORKS_V1
            CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();
            apaCommandLine->SetExecutableNameL( appInfo.iFullName );
        #else // SYMBIAN_SUPPORT_UI_FRAMEWORKS_V1
            CApaCommandLine* apaCommandLine =
                CApaCommandLine::NewLC( appInfo.iFullName );
        #endif // SYMBIAN_SUPPORT_UI_FRAMEWORKS_V1

            err = apaLsSession.StartApp( *apaCommandLine );
            CleanupStack::PopAndDestroy( apaCommandLine );
            }
        CleanupStack::PopAndDestroy(); // apaLsSession
        }
    CleanupStack::PopAndDestroy(); // wsSession

    _DPRINT( 4, "PhSrv.UssdM.RequestStartEditingL.end" ); // debug print
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::InformUssdApplicationStarting
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::InformUssdApplicationStarting()
    {
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppStarting.start" ); // debug print
    if ( iUssdReplyTimer )
        {
        _DPRINT( 4, "PhSrv.InformUssdApplicationStarting.iUssdReplyTimer" );
        if ( iUssdReplyTimer->IsTimerActive() )
            {
            _DPRINT( 4, "PhSrv.InformUssdApplicationStarting.iUssdReplyTimer.active" );
            iUssdReplyTimer->Pause();
            }
        }
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppStarting.end" ); // debug print
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::InformUssdApplicationTerminatingL
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::InformUssdApplicationTerminatingL(
    const RMessage2& aMessage )
    {
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppTerminatingL.start" ); // debug print
    if ( iUssdReplyTimer )
        {
        if ( iUssdReplyTimer->IsTimerActive() )
            {
            // debug print
            _DPRINT( 4, "PhSrv.UssdM.InfUssdAppTerminatingL.timer" );

            // Read the information what is the reason
            // for application termination.
            TPhCltUssdAppExitReason exitReason = EPhCltExitReasonUnknown;
            TPckg< TPhCltUssdAppExitReason > exitReasonPckg( exitReason );
            aMessage.ReadL(
                0,
                exitReasonPckg );

            // debug print
            _DPRINT( 4, "PhSrv.UssdM.InfUssdAppTerminatingL.timer2" );

            // If reason was the completion of send operation, the USSD
            // session is not canceled, otherwise it is canceled.
            if ( exitReason != EPhCltSendCompleted )
                {
                // debug print
                _DPRINT( 4, "PhSrv.UssdM.InfUssdAppTerminatingL.SendRelease" );
                CloseSession();
                }
            }
        }
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppTerminatingL.end" ); // debug print
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::InformUssdApplicationToForeground
// -----------------------------------------------------------------------------
//
TInt CPhSrvUssdManager::InformUssdApplicationToForeground()
    {
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppToForeground.start" ); // debug print

    // Do the same actions as in InformUssdApplicationStarting,
    // that is why it is called.
    InformUssdApplicationStarting();

    if ( iEmptyEditor )
        {
        _DPRINT( 4, "PhSrv.UssdM.InfUssdAppToForeground.empty" ); // debug print
        iEmptyEditor = EFalse;
        return 1; // some positive number
        }
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppToForeground.end" ); // debug print
    return KErrNone;
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::InformUssdApplicationToBackground
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::InformUssdApplicationToBackground()
    {
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppToBackground.start" ); // debug print
    if ( iUssdReplyTimer )
        {
        _DPRINT( 4, "PhSrv.UssdM.InfUssdAppToBackground.timer" ); // debug print
        if ( iUssdReplyTimer->IsTimerActive() )
            {
            _DPRINT( 4, "PhSrv.UssdM.InfUssdAppToBackground.timer.Active" ); // debug print
            iUssdReplyTimer->Continue();
            }
        }
    _DPRINT( 4, "PhSrv.UssdM.InfUssdAppToBackground.end" ); // debug print
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::InformStartSAT
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::InformStartSAT( const RMessage2& aSatMessage )
    {
    _DPRINT( 4, "PhSrv.InformStartSAT.Start" );    // debug print

    if ( iHavePendingSatMessagePointer )
        {
        _DPRINT( 4, "PhSrv.InformStartSAT.Complete.InUse" ); // debug print
        aSatMessage.Complete( KErrInUse );
        }
    else
        {
        _DPRINT( 4, "PhSrv.InformStartSAT.Set" );           // debug print

        // There was not pending SAT message
        iHavePendingSatMessagePointer = ETrue;
        _DDPRINT( 4, "PhSrv.UssdM.InformStartSAT.PendingSatPointer ", iHavePendingSatMessagePointer );
        iPendingSatMessagePointer = aSatMessage;
        }

    _DPRINT( 4, "PhSrv.InformStartSAT.End" );   // debug print
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::InformStopSAT
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::InformStopSAT()
    {
    _DPRINT( 4, "PhSrv.InformStopSAT.Start" );               // debug print

    // Do the actions only if there is pending SAT message.
    if ( iHavePendingSatMessagePointer )
        {
        _DPRINT( 4, "PhSrv.InformStopSAT.Complete.Cancel" ); // debug print
        if ( !iPendingSatMessagePointer.IsNull() )
            {
            iPendingSatMessagePointer.Complete( KErrCancel );
            _DPRINT( 4, "PhSrv.InformStopSAT.Complete.KErrCancel" );
            }
        iHavePendingSatMessagePointer = EFalse;
        }
    _DPRINT( 4, "PhSrv.InformStopSAT.End" );                 // debug print
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::ShowNotes
// -----------------------------------------------------------------------------
//


TBool CPhSrvUssdManager::ShowNotesL()
{
_DPRINT( 4, "PhSrv.ShowNotesL.Start" );

if ( !iHavePendingSatMessagePointer )
    {
    if ( iSatCanceled )
        {
        _DPRINT( 4, "PhSrv.ShowNotesL, EFalse" );  // debug print
        return EFalse;
        }
    else
        {
        _DPRINT( 4, "PhSrv.ShowNotesL, ETrue" );  // debug print
        return ETrue;
        }
    }
// Read the information whether the notes are shown or not.
    TUint notesShown = 0;
    TPckg< TUint > noShPckg( notesShown );
    iPendingSatMessagePointer.ReadL(
        0,
        noShPckg );

    TBool showNotes = EFalse;
    _DPRINT( 4, "PhSrv.ShowNotes Sat= EFalse" );    // debug print
    if ( notesShown == KPhCltShowNotes )
        {
        _DPRINT( 4, "PhSrv.ShowNotes Sat= ETrue" ); // debug print
        showNotes = ETrue;
        }
    _DPRINT( 4, "PhSrv.ShowNotesL.End" );
    return showNotes;
}

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::CompleteSatL
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::CompleteSatL(
    TDesC* aReceiveString,
    TInt aError )
    {
    _DPRINT( 4, "PhSrv.CompleteSatL.Start" );                // debug print
    if ( aReceiveString )
        {
        if ( aReceiveString->Length() )
            {
            _DPRINT( 4, "PhSrv.CompleteSatL.recString.>0" ); // debug print
            // copy the received string to client side.
            if ( iPendingSatMessagePointer.Int1() < aReceiveString->Length() )
                {
                // debug print
                _DPRINT( 4, "PhSrv.CompleteSatL.recString.LengthError" );
                if ( !iPendingSatMessagePointer.IsNull() )
                    {
                    iPendingSatMessagePointer.Complete( KErrOverflow );
                    _DPRINT( 4, "PhSrv.CompleteSatLComplete.KErrOverFlow" );
                    }
                iHavePendingSatMessagePointer = EFalse;
                }
			else
				{
            _DPRINT( 4, "PhSrv.CompleteSatL.recString.Write" );  // debug print
            iPendingSatMessagePointer.WriteL(
                2,
                *aReceiveString );

            _DPRINT( 4, "PhSrv.CompleteSatL.recString.Write2" ); // debug print
            TPckg< TUint > dcsPackage( iDCS );
            iPendingSatMessagePointer.WriteL(
                0,
                dcsPackage );
            }
        }
        }
    _DPRINT( 4, "PhSrv.CompleteSatL.Middle" );           // debug print
    if ( !iPendingSatMessagePointer.IsNull() )
        {
        if ( aReceiveString && !iSatCanceled )
            {
            _DDPRINT( 4, "PhSrv.CompleteSatL.Complete.", iReturnResult.iOpCode  );   // debug print
            iPendingSatMessagePointer.Complete( iReturnResult.iOpCode ); // Some positive value
            }
        else
            {
            _DPRINT( 4, "PhSrv.CompleteSatL.Complete.aError" ); // debug print
            iPendingSatMessagePointer.Complete( aError );
            }
        }

    iHavePendingSatMessagePointer = EFalse;

    _DPRINT( 4, "PhSrv.CompleteSatL.End" );           // debug print
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::IsTelephonyFeatureSupported
//
// -----------------------------------------------------------------------------
//
TBool CPhSrvUssdManager::IsTelephonyFeatureSupported(
    const TInt aFeatureId )
    {
	return ( aFeatureId & iVariantReadOnlyValues );
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::PlayUssdTone
//
// -----------------------------------------------------------------------------
//
TInt CPhSrvUssdManager::PlayUssdTone()
    {
    _DPRINT( 4, "PhSrv.UssdM.PlayTone.start" );           // debug print

    TInt err = KErrNone;

    RProperty::Define( KPSUidNcnList, KNcnPlayAlertTone, RProperty::EInt, ECapability_None , ECapabilityWriteDeviceData );
    RProperty::Set( KPSUidNcnList, KNcnPlayAlertTone, KPhSrvUssdTone );

    // debug print
    _DDPRINT(
        4,
        "PhSrv.UssdM.PlayTone.end",
        err );
    return err;
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::GetTelephonyVariantData
//
// -----------------------------------------------------------------------------
//
TInt CPhSrvUssdManager::GetTelephonyVariantData()
    {
    _DPRINT( 4, "PhSrv.UssdM.GetTelephonyVariantData.Start" );
    TInt err = KErrNone;

    // Variation data should be unchangable during run-time,
    // therefore, if once succesfully read, later reads are
    // not allowed.
    if ( iVariantReadOnlyValues == KPhSrvDefaultValue )
        {
        CRepository* cenRepSession = NULL;
        TRAP ( err ,
               cenRepSession = CRepository::NewL( KCRUidTelVariation ) );
        if ( err == KErrNone )
            {
            err = cenRepSession->Get( KTelVariationFlags,
                                   iVariantReadOnlyValues );
            }
        delete cenRepSession;
        }

    _DDPRINT( 4, "PhSrv.UssdM.variant", iVariantReadOnlyValues ); // debug print
    _DPRINT( 4, "PhSrv.UssdM.GetTelephonyVariantData.End" );
    return err;
    }


// -----------------------------------------------------------------------------
// CPhSrvUssdManager::SendMoAcknowledgementL
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::SendMoAcknowledgementL()
    {
    _DPRINT( 4, "PhSrv.SendMoAckL.Start" );           // debug print

    // Acknowledge MT USSD message.
    RMobileUssdMessaging::TMobileUssdAttributesV1 msgAttribs;
    msgAttribs.iFlags =
        RMobileUssdMessaging::KUssdMessageType +
        RMobileUssdMessaging::KUssdDataFormat  +
        RMobileUssdMessaging::KUssdMessageDcs;

    msgAttribs.iType   = RMobileUssdMessaging::EUssdMOAcknowledgement;
    _DDPRINT( 4, "PhSrv.SendMoAckL.msgAttribs.iType ", msgAttribs.iType );
    msgAttribs.iFormat = RMobileUssdMessaging::EFormatUnspecified;
    _DDPRINT( 4, "PhSrv.SendMoAckL.msgAttribs.iFormat ", msgAttribs.iFormat );
    msgAttribs.iDcs    = KPhSrvUssdDefaultDCS;

    RMobileUssdMessaging::TMobileUssdAttributesV1Pckg attribs = msgAttribs;
    SendHandlerL().SendUssdL( KNullDesC8() , attribs );

    _DPRINT( 4, "PhSrv.SendMoAckL.End" );           // debug print
    }

// -----------------------------------------------------------------------------
// CPhSrvUssdManager::TurnLightsOn
//
// -----------------------------------------------------------------------------
//
void CPhSrvUssdManager::TurnLightsOn()
    {
     _DPRINT( 4, "PhSrv.TurnLightsOn Start" );           // debug print


         // Change the bit on and off. SysAp will detect that
     // the lights should be switched on for the specified time.
     //
         RProperty::Set(KPSUidCoreApplicationUIs, KLightsControl, ELightsOn);
         TInt err = RProperty::Set(KPSUidCoreApplicationUIs, KLightsControl, ELightsOff);

         if ( err != KErrNone )
                 {
                 _DDPRINT( 4,"PhSrv.TurnLightsOn.Error: ",err );// debug print
                 }

     _DPRINT( 4, "PhSrv.TurnLightsOn.End" );           // debug print
    }
// End of File