1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  USSD Manager.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include "CPhSrvUssdManager.h"

    20 #include "PhSrvUtils.h"

    21 #include "CPhSrvUssdSendHandler.h"

    22 #include "CPhSrvUssdReceiveHandler.h"

    23 #include "CPhSrvUssdNotifyNWRelease.h"

    24 #include "CPhSrvResourceManager.h"

    25 #include "CPhSrvUssdReplyTimer.h"

    26 #include "MPhSrvUssdMessageSentObserver.h"

    27 #include "MPhSrvPhoneInterface.h"

    28 #include "CPhSrvUssdSessionCancelWaiter.h"

    29 

    30 #include <AknGlobalNote.h>

    31 #include <aknnotedialog.h>

    32 #include <aknstaticnotedialog.h>

    33 #include <AknProgressDialog.h>

    34 #include <apacmdln.h>

    35 #include <apgtask.h>

    36 #include <bautils.h>

    37 #include <StringLoader.h>

    38 #include <AknGlobalMsgQuery.h>

    39 #include <textresolver.h>

    40 #include <charconv.h>

    41 #include <gsmuelem.h>

    42 #include <exterror.h>

    43 #include <rmmcustomapi.h>

    44 

    45 #include <w32std.h>

    46 #include <apgcli.h>

    47 #include <CPhCltUssd.h>

    48 #include <avkon.rsg>

    49 #include <PhoneServer.rsg>

    50 #include <telephonyvariant.hrh>

    51 #include "PhSrvDebugInfo.h"

    52 #include <e32property.h>

    53 

    54 #include <NcnListInternalPSKeys.h>

    55 #include <centralrepository.h>

    56 #include <telinternalcrkeys.h>

    57 #include <coreapplicationuisdomainpskeys.h>

    58 

    59 

    60 // CONSTANTS

    61 const TInt KPhSrvDefaultValue = 0x00000000;

    62 // const TInt KPhSrvUssdNoTone = 0; // See SharedDataKeysVariant.h or NcnListInternalPSKeys.h

    63 const TInt KPhSrvUssdTone   = 2; // See SharedDataKeysVariant.h or NcnListInternalPSKeys.h

    64 

    65 // const TInt KPhSrvUssdTimeOutObserverGranularity = 2;

    66 // const TInt KPhSrvUssdSentMessageObserverGranularity = 2;

    67 const TInt KPhSrvUssdAppUID = 0x10005955;

    68 

    69 const TInt KPhSrvUssdMessageQueryInterval = 500000; // 0.5 sec

    70 const TInt KPhSrvUssdNoteExitPeriod = 500000; // 0.5 sec

    71 //

    72 const TUint KPhSrvUssdDefaultDCS = 0x0f;                        // 00001111

    73 

    74 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguage = 0x10;// 00010000

    75 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars3 = 3;

    76 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars2 = 2;

    77 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageStartBit = 5;

    78 

    79 const TUint KPhSrvUssdDcsAlphabetUCS2PrecededLanguage = 0x11;   // 00010001

    80 const TUint KPhSrvUssdDcsAlphabetUCS2PrecededLanguageSkipChars = 2;

    81 

    82 const TUint KPhSrvUssdDcsGeneralInformationMask = 0xc0;         // 11000000

    83 const TUint KPhSrvUssdDcsGeneralInformation = 0x40;             // 01xxxxxx

    84 const TUint KPhSrvUssdDcsGeneralInformationCompressed = 0x20;   // xx1xxxxx

    85 const TUint KPhSrvUssdDcsGeneralInformationSimMask = 0x13;      // 00010011

    86 const TUint KPhSrvUssdDcsGeneralInformationSim = 0x12;          // xxx1xx10

    87 const TUint KPhSrvUssdDcsGeneralInformationAlphabetMask = 0x0c; // 00001100

    88 const TUint KPhSrvUssdDcsGeneralInformationAlphabet8Bit = 0x04; // xxxx01xx

    89 const TUint KPhSrvUssdDcsGeneralInformationAlphabetUCS2 = 0x08; // xxxx10xx

    90 

    91 const TUint KPhSrvUssdDcsMessageHandlingAlphabetMask = 0xf4;    // 11110100

    92 const TUint KPhSrvUssdDcsMessageHandlingAlphabet8Bit = 0xf4;    // 1111x1xx

    93 const TInt KPhrUssdNotifyArraySize = 1;

    94 

    95 // MACROS

    96 

    97 #define _DPRINT_FLAGS() \

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

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

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

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

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

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

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

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

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

   107 

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

   109 

   110 // CLASS DECLARATION

   111 

   112 #ifndef TPHSRVUSSDALPHABETPACKER_H

   113 #define TPHSRVUSSDALPHABETPACKER_H

   114 

   115 // CONSTANTS

   116 const TUint8 KPhSrvUssdCarriageReturn = 0x0d;

   117 

   118 /**

   119 *  Packs and unpacks data encoded in an Ussd alphabet.

   120 *

   121 *  @since 1.0

   122 */

   123 class TPhSrvUssdAlphabetPacker

   124     {

   125     public:  // Constructors and destructor

   126 

   127         /**

   128         * Constructor.

   129         *

   130         * @param aAlphabet The alphabet that is used.

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

   132         * @param aStartBit The start bit for conversion.

   133         */

   134         TPhSrvUssdAlphabetPacker(

   135             TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

   136             TBool aIsBinary,

   137             TInt aStartBit );

   138 

   139 

   140     public: // New functions

   141 

   142         /**

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

   144         *

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

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

   147         * @param aNumUDUnits Buffer length.

   148         * @return Length of the result buffer.

   149         */

   150         TInt UnpackL(

   151             const TDesC8& aIn,

   152             TDes8& aOut,

   153             TInt aNumUDUnits );

   154 

   155         /**

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

   157         *

   158         * @param aCharacterSetConverter Does the converting.

   159         * @param aFs File server session.

   160         * @param aIn Packed 7-bit buffer.

   161         * @param aOut Unicode buffer.

   162         * @param aNumUDUnits Number of charahters.

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

   164         */

   165         TInt UnpackAndConvertL(

   166             CCnvCharacterSetConverter& aCharacterSetConverter,

   167             RFs& aFs,

   168             const TDesC8& aIn,

   169             TDes& aOut,

   170             TInt aNumUDUnits );

   171 

   172         /**

   173         * Counts the needed octet amout.

   174         *

   175         * @param aNumUDUnits Number of source characters.

   176         * @return Octets needed.

   177         */

   178         TInt PackedOctetsRequiredL( TInt aNumUDUnits ) const;

   179 

   180 

   181     private:

   182 

   183         // Private helper methods

   184         TInt ElementSizeInBitsL() const;

   185 

   186 

   187     private:    // Data

   188 

   189         // The used coding alphabet.

   190         TSmsDataCodingScheme::TSmsAlphabet iAlphabet;

   191 

   192         // Is the packed data binary.

   193         TBool iIsBinary;

   194 

   195         // The start bit for packing.

   196         TInt iStartBit;

   197     };

   198 

   199 #endif // TPHSRVUSSDALPHABETPACKER_H

   200 

   201 

   202 // -----------------------------------------------------------------------------

   203 // TPhSrvUssdAlphabetPacker::TPhSrvUssdAlphabetPacker

   204 // Constructor.

   205 //

   206 // -----------------------------------------------------------------------------

   207 //

   208 TPhSrvUssdAlphabetPacker::TPhSrvUssdAlphabetPacker(

   209     TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

   210     TBool aIsBinary,

   211     TInt aStartBit)

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

   213     {

   214     }

   215 

   216 

   217 // -----------------------------------------------------------------------------

   218 // TPhSrvUssdAlphabetPacker::UnpackL

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

   220 //

   221 // -----------------------------------------------------------------------------

   222 //

   223 TInt TPhSrvUssdAlphabetPacker::UnpackL(

   224     const TDesC8& aIn,

   225     TDes8& aOut,

   226     TInt aNumUDUnits )

   227     {

   228     TInt length = aNumUDUnits;

   229     // Ensure we've got enough  output buffer

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

   231         {

   232         User::Leave(KErrCorrupt);

   233         }

   234 

   235     TInt elementSizeInBits = ElementSizeInBitsL();

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

   237         {

   238         aOut.Append( aIn );

   239         }

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

   241         {

   242         // Get raw pointers and do unpacking

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

   244         const TUint8* inPtr = aIn.Ptr();

   245 

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

   247             {

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

   249             if ( iStartBit )

   250                 {

   251                 inPtr++;

   252                 // Take more from next byte

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

   254                 }

   255             outPtr[i] = ( TUint8 ) from;

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

   257             }

   258 

   259         // The last character will be ignored if message ends

   260         // on an octet bounday with CR.

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

   262             {

   263             length--;

   264             }

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

   266         }

   267     else

   268         {

   269         __ASSERT_DEBUG(EFalse,

   270             PhoneServerUtils::Panic( EPhoneServerPanicModeLogicFault ) );

   271         }

   272     return length;

   273     }

   274 

   275 

   276 // -----------------------------------------------------------------------------

   277 // TPhSrvUssdAlphabetPacker::UnpackAndConvertL

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

   279 //

   280 // -----------------------------------------------------------------------------

   281 //

   282 TInt TPhSrvUssdAlphabetPacker::UnpackAndConvertL(

   283     CCnvCharacterSetConverter& aCharacterSetConverter,

   284     RFs& aFs,

   285     const TDesC8& aIn,

   286     TDes& aOut,

   287     TInt aNumUDUnits )

   288     {

   289 

   290     // Unpack first

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

   292     TPtr8 unpackedBufferPtr( unpackedBuffer->Des() );

   293     UnpackL( aIn, unpackedBufferPtr,aNumUDUnits );

   294 

   295     // Convert

   296     CSmsAlphabetConverter* converter =

   297         CSmsAlphabetConverter::NewLC(

   298             aCharacterSetConverter, aFs, iAlphabet, iIsBinary );

   299 

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

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

   302         {

   303         User::Leave( KErrCorrupt );

   304         }

   305     // Cleanup and return

   306     aOut.Append( convertedPtr );

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

   308     return aNumUDUnits;

   309     }

   310 

   311 

   312 // -----------------------------------------------------------------------------

   313 // TPhSrvUssdAlphabetPacker::PackedOctetsRequiredL

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

   315 //

   316 // -----------------------------------------------------------------------------

   317 //

   318 TInt TPhSrvUssdAlphabetPacker::PackedOctetsRequiredL( TInt aNumUDUnits ) const

   319 

   320     {

   321     TInt octetsRequired = 0;

   322     TInt elementSizeInBits = ElementSizeInBitsL();

   323     if ( elementSizeInBits == 8 )

   324         {

   325         octetsRequired=aNumUDUnits;

   326         }

   327     else

   328         {

   329         octetsRequired =

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

   331         }

   332     return octetsRequired;

   333     }

   334 

   335 // -----------------------------------------------------------------------------

   336 // TPhSrvUssdAlphabetPacker::ElementSizeInBitsL

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

   338 // invalid data coding scheme.

   339 // -----------------------------------------------------------------------------

   340 //

   341 TInt TPhSrvUssdAlphabetPacker::ElementSizeInBitsL() const

   342     {

   343     if (iIsBinary)

   344         return 8;

   345     switch ( iAlphabet )

   346         {

   347         case TSmsDataCodingScheme::ESmsAlphabet7Bit:

   348             {

   349             return 7;

   350             }

   351         case TSmsDataCodingScheme::ESmsAlphabet8Bit:

   352         case TSmsDataCodingScheme::ESmsAlphabetUCS2:

   353             {

   354             return 8;

   355             }

   356         default:

   357             {

   358             User::Leave(KErrGsmSMSDataCodingSchemeNotSupported);

   359             return 8;

   360             }

   361         }

   362     }

   363 

   364 

   365 

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

   367 

   368 // -----------------------------------------------------------------------------

   369 // CPhSrvUssdManager::CPhSrvUssdManager

   370 //

   371 // Constructor

   372 //

   373 // -----------------------------------------------------------------------------

   374 //

   375 CPhSrvUssdManager::CPhSrvUssdManager(

   376     RFs& aFsSession,

   377     CPhSrvResourceManager& aResourceManager

   378     )

   379     :CActive( EPriorityLow ),

   380      iFsSession( aFsSession ),

   381      iResourceManager( aResourceManager ),

   382      iDCS ( KPhCltDcsUnknown ),

   383      iReturnResultPckg ( iReturnResult )

   384 

   385     {

   386     CActiveScheduler::Add( this );

   387     }

   388 

   389 

   390 // -----------------------------------------------------------------------------

   391 // CPhSrvUssdManager::~CPhSrvUssdManager

   392 //

   393 // Destructor

   394 //

   395 // -----------------------------------------------------------------------------

   396 //

   397 CPhSrvUssdManager::~CPhSrvUssdManager()

   398     {

   399     _DPRINT( 4, "PhSrv.~CPhSrvUssdManager.start" );       // debug print

   400 

   401 

   402     delete iUssdSendHandler;

   403     iUssdSendHandler = NULL;

   404 

   405     delete iUssdReceiveHandler;

   406     iUssdReceiveHandler = NULL;

   407 

   408     delete iUssdNotifyNWRelease;

   409     iUssdNotifyNWRelease = NULL;

   410 

   411     Cancel();

   412 

   413     iTimer.Close();

   414 

   415     delete iGlobalMsgQuery;

   416     iGlobalMsgQuery = NULL;

   417 

   418     if ( iNotifyArray )

   419         {

   420         iNotifyArray->Reset();

   421         }

   422     delete iNotifyArray;

   423     if ( iUssdReplyTimer )

   424         {

   425         iUssdReplyTimer->Stop();

   426         }

   427     delete iUssdReplyTimer;

   428     iUssdReplyTimer = NULL;

   429 

   430     iFsSession.Close();

   431 

   432     iMobileUssdMessaging.Close();

   433 

   434     delete iMeQuHeaderText;

   435     iMeQuHeaderText = NULL;

   436     

   437     delete iMoAckCallback;

   438 

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

   440     }

   441 

   442 

   443 // -----------------------------------------------------------------------------

   444 // CPhSrvUssdManager::ConstructL

   445 //

   446 // Symbian OS 2nd phase constructor

   447 //

   448 // -----------------------------------------------------------------------------

   449 //

   450 void CPhSrvUssdManager::ConstructL( MPhSrvPhoneInterface& aPhoneInterface )

   451     {

   452     _DPRINT( 4, "PhSrv.ConstructL.Start" );       // debug print

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

   454 

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

   456 

   457     // Check support

   458     RMobileUssdMessaging::TMobileUssdCapsV1 caps;

   459     RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );

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

   461 

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

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

   464         {

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

   466         iUssdReceiveHandler = new( ELeave ) CPhSrvUssdReceiveHandler(

   467             *this,

   468             iMobileUssdMessaging );

   469         iUssdReceiveHandler->ConstructL();

   470 

   471         iUssdNotifyNWRelease = new( ELeave )  CPhSrvUssdNotifyNWRelease(

   472             *this,

   473             iMobileUssdMessaging );

   474 

   475         iUssdNotifyNWRelease->ConstructL();

   476         }

   477 

   478     iPhoneInterface = &aPhoneInterface;

   479 

   480     SendHandlerL();

   481     

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

   483 

   484     iVariantReadOnlyValues = KPhSrvDefaultValue;

   485 

   486     User::LeaveIfError( GetTelephonyVariantData() );

   487 

   488     iMeQuHeaderText = iResourceManager.ReadResourceLC(

   489         R_PHSRV_USSD_MESQUERY_MESSAGE);

   490     CleanupStack::Pop( iMeQuHeaderText );

   491 

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

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

   494     iNotifyArray = new( ELeave ) CDesCArrayFlat( KPhrUssdNotifyArraySize );

   495     _DPRINT( 4, "PhSrv.ConstructL.End" );       // debug print

   496     }

   497 

   498 

   499 // -----------------------------------------------------------------------------

   500 // CPhSrvUssdManager::SendHandlerL

   501 //

   502 // The send handler.

   503 //

   504 // -----------------------------------------------------------------------------

   505 //

   506 CPhSrvUssdSendHandler& CPhSrvUssdManager::SendHandlerL()

   507     {

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

   509     // is supported by the TSY.

   510     _DPRINT( 4, "PhSrv.SendHandlerL.Start" );       // debug print

   511     if ( iUssdSendHandler == NULL )

   512         {

   513         _DPRINT( 4, "PhSrv.SendHandlerL.iUssdSendHandler.NULL" );       // debug print

   514         RMobileUssdMessaging::TMobileUssdCapsV1 caps;

   515         RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );

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

   517         _DPRINT( 4, "PhSrv.SendHandlerL.iMobileUssdMessaging.GetCaps" );       // debug print

   518 

   519         if ( ( caps.iUssdTypes & RMobileUssdMessaging::KCapsMOUssd ) == 0 ||

   520             ( caps.iUssdFormat & RMobileUssdMessaging::KCapsPackedString )

   521             == 0 )

   522             {

   523             _DPRINT( 4, "PhSrv.SendHandlerL.KErrNotSupported" );       // debug print

   524             User::Leave( KErrNotSupported );

   525             }

   526 

   527         iUssdSendHandler =

   528             new( ELeave ) CPhSrvUssdSendHandler(

   529                 *this,

   530                 iMobileUssdMessaging,

   531                 *iPhoneInterface );

   532         }

   533     _DPRINT( 4, "PhSrv.SendHandlerL.End" );       // debug print

   534     return *iUssdSendHandler;

   535     }

   536 

   537 

   538 // -----------------------------------------------------------------------------

   539 // CPhSrvUssdManager::SendUssdL

   540 //

   541 // Send the USSD message.

   542 //

   543 // -----------------------------------------------------------------------------

   544 //

   545 void CPhSrvUssdManager::SendUssdL(

   546     const TDesC8& aMsgData,

   547     RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttribute,

   548     MPhSrvUssdMessageSentObserver& aObserver )

   549     {

   550     _DPRINT( 4, "PhSrv.SendUssdL.Start ######" );           // debug print

   551     _DPRINT_FLAGS();

   552     

   553     if ( iObserver && iNetworkReleased ) 

   554         {

   555         // Network has been released but the previous send request is still alive.

   556         // Cancel the pervious send operation, complete the old request with error

   557         // and clean up the pointer.

   558         _DPRINT( 4, "PhSrv.SendUssdL.Error.Complete.Existing" );           // debug print

   559         if ( iUssdSendHandler ) 

   560             {

   561             iUssdSendHandler->Cancel();

   562             }

   563         iObserver->UssdMessageSentObserverHandleResult( KErrSessionClosed );

   564         iObserver = NULL;

   565         }

   566     

   567     if ( iObserver || iSendingAck )

   568         {

   569         _DPRINT( 4, "PhSrv.SendUssdL.KErrInUse" );           // debug print

   570         // Other client is using the service.

   571         User::Leave( KErrInUse );

   572         }

   573 

   574     // Check that message type is set

   575     if( ( aMsgAttribute.iFlags & RMobileUssdMessaging::KUssdMessageType )

   576         == 0 )

   577         _DPRINT( 4, "PhSrv.SendUssdL.KUssdMessageType.0" );       // debug print

   578         {

   579         // Mesasge type not set -> Set it.

   580         aMsgAttribute.iFlags |= RMobileUssdMessaging::KUssdMessageType;

   581         if ( NetworkWaitingForAnAnswer() )

   582             {

   583             // Network is waiting for an answer

   584             _DPRINT( 4, "PhSrv.SendUssdL.EUssdMOReply" );	// debug print

   585             aMsgAttribute.iType = RMobileUssdMessaging::EUssdMOReply;

   586             }

   587         else

   588             {

   589             _DPRINT( 4, "PhSrv.SendUssdL.EUssdMORequest" );  // debug print

   590             aMsgAttribute.iType = RMobileUssdMessaging::EUssdMORequest;

   591             }

   592         }

   593         

   594     RMobileUssdMessaging::TMobileUssdAttributesV1Pckg attribs( aMsgAttribute );

   595     iShowDone = ETrue;

   596     _DPRINT( 4, "PhSrv.SendUssdL.iShowDone.ETrue" );

   597     _DPRINT( 4, "PhSrv.SendUssdL.Send" );           // debug print

   598     SendHandlerL().SendUssdL( aMsgData , attribs );

   599     iObserver = &aObserver;

   600     // Not closing nor closed anymore

   601     iNetworkReleased = EFalse;

   602     iSendRelease = EFalse;

   603     iClearArray = EFalse;

   604     

   605     // Reply timer can be killed here... Receive event might come right after this

   606     // which will setup the timer again if needed.

   607     if ( NetworkWaitingForAnAnswer() )

   608         {

   609         _DPRINT( 4, "PhSrv.SendUssdCancel.TimerStop" );   // debug print

   610         iUssdReplyTimer->Stop();

   611         }

   612     _DPRINT( 4, "PhSrv.SendUssdL.End" );           // debug print

   613     }

   614 

   615 // -----------------------------------------------------------------------------

   616 // CPhSrvUssdManager::NetworkWaitingForAnAnswer

   617 // -----------------------------------------------------------------------------

   618 //

   619 TBool CPhSrvUssdManager::NetworkWaitingForAnAnswer() 

   620     {

   621     return iUssdReplyTimer && iUssdReplyTimer->IsTimerActive();

   622     }

   623 // -----------------------------------------------------------------------------

   624 // CPhSrvUssdManager::SendUssdCancel

   625 //

   626 // Cancel the USSD sending.

   627 //

   628 // -----------------------------------------------------------------------------

   629 //

   630 void CPhSrvUssdManager::SendUssdCancel()

   631     {

   632     _DPRINT( 4, "PhSrv.SendUssdCancel.Start #######" );           // debug print

   633 

   634     // Ack sending should not be canceled unless it's about terminating

   635     // the whole session

   636     _DPRINT_FLAGS();

   637     if ( !iSendingAck || iSendRelease ) 

   638         {

   639         _DPRINT( 4, "PhSrv.SendUssdCancel.DoingCancel" );

   640         iUssdSendHandler->SendUssdCancel();

   641         }

   642 

   643     if ( iHavePendingSatMessagePointer )

   644         {

   645         _DPRINT( 4, "PhSrv.SendUssdCancel.SatCancel" );

   646         iSatCanceled = ETrue;

   647         }

   648     iObserver = NULL;

   649     

   650     SetActiveIfPendingNotificationsExist();

   651     _DPRINT( 4, "PhSrv.SendUssdCancel.End" );           // debug print

   652     }

   653 

   654 // -----------------------------------------------------------------------------

   655 // CPhSrvUssdManager::SetActiveIfPendingNotificationsExist

   656 // -----------------------------------------------------------------------------

   657 //

   658 void CPhSrvUssdManager::SetActiveIfPendingNotificationsExist()

   659     {

   660     if ( !IsActive() && NotifyCount() > 0 )

   661         {

   662         _DPRINT( 4, "PhSrv.AcrtivateIf.NotActiveSelf" );

   663         iLaunchGMQ = ETrue;

   664         iNotifyMessage = ETrue;

   665         _DPRINT( 4, "PhSrv.SendUssdCancel.iNotifyMessage.ETrue" );

   666         iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );

   667         SetActive();

   668         _DPRINT_FLAGS();

   669         _DDPRINT( 4, "PhSrv.AcrtivateIf.SetActive ", iStatus.Int() );

   670         }

   671     }

   672 // -----------------------------------------------------------------------------

   673 // CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL

   674 //

   675 //

   676 //

   677 // -----------------------------------------------------------------------------

   678 //

   679 void CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL( TInt aError )

   680     {

   681     // debug print

   682     _DDPRINT(

   683         4,

   684         "PhSrv.UssdNetworkObserverHandleSendEventL.Start: ##### ",

   685         aError );

   686 

   687     // complete SAT if needed

   688     if ( aError < KErrNone )

   689         {

   690         // debug print

   691         _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleSendEventL.CompleteSat" );

   692         CompleteSatL( NULL, aError );

   693         }

   694 

   695     if ( iObserver )

   696         {

   697         // debug print

   698         _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleSendEventL.Observer" );

   699 

   700         iObserver->UssdMessageSentObserverHandleResult( aError );

   701         iObserver = NULL;

   702         }

   703     

   704     iSendingAck = EFalse;

   705     

   706     AsyncProcessMoAcks();

   707     

   708     // debug print

   709     _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleSendEventL.End" );

   710     }

   711 

   712 

   713 // -----------------------------------------------------------------------------

   714 // CPhSrvUssdManager::UssdAppTaskExists

   715 //

   716 //

   717 //

   718 // -----------------------------------------------------------------------------

   719 //

   720 TBool CPhSrvUssdManager::UssdAppTaskExistsL()

   721 {   

   722     TBool ret = EFalse;

   723     RWsSession wsSession;

   724     User::LeaveIfError(wsSession.Connect());

   725     _DPRINT( 4, "PhSrv.UssdAppTaskExists.wsSession.Connect" );

   726     CleanupClosePushL(wsSession);

   727     TApaTaskList tasklist(wsSession);

   728     TApaTask task = tasklist.FindApp(TUid::Uid(KPhSrvUssdAppUID));

   729     ret = task.Exists();

   730 

   731     CleanupStack::PopAndDestroy();

   732     return ret;

   733 }

   734 

   735 // -----------------------------------------------------------------------------

   736 // CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL

   737 //

   738 //

   739 //

   740 // -----------------------------------------------------------------------------

   741 //

   742 void CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL(

   743     const TDes8& aMsgData,

   744     const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes,

   745     TInt aError )

   746     {

   747     _DDPRINT(

   748         4,

   749         "PhSrv.UssdNetworkObserverHandleReceivedEventL.Start: ### ",

   750         aError );

   751     _DPRINT_FLAGS();

   752     if ( aError != KErrNone )

   753         {

   754         TurnLightsOn(); //Ensure lights on

   755         // debug print

   756         _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.ShErNote" );

   757         ShowErrorNoteL( aError );

   758         }

   759     else if ( iSendRelease )

   760         {

   761         // Ignore if sendrelease is to be done. If the message was

   762         _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.SendRelease.Ignore" );

   763         }

   764     else

   765         {

   766         UssdHandleReceivedEventL( aMsgData, aMsgAttributes );

   767         }

   768     }

   769 

   770 // -----------------------------------------------------------------------------

   771 // CPhSrvUssdManager::UssdHandleReceivedEventL

   772 //

   773 //

   774 //

   775 // -----------------------------------------------------------------------------

   776 //

   777 void CPhSrvUssdManager::UssdHandleReceivedEventL(

   778     const TDes8& aMsgData,

   779     const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes )

   780     {

   781     // This always is either ongoing transaction or starting a new based

   782     // on incoming message, mark transaction to be open.

   783     iNetworkReleased = EFalse;

   784 		

   785     // 2. Complete Send with some positive value.

   786 	if ( iObserver )

   787         {

   788         // debug print

   789         _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Observer" );

   790         UssdNetworkObserverHandleSendEventL( 1 ); // some positive value

   791         }

   792 	

   793     if ( aMsgAttributes.iFlags&RMobileUssdMessaging::KUssdMessageType &&

   794          aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTRequest )

   795         {

   796         // 3. Stop old reply timer and start new one if needed.

   797         RestartReplyTimerL();

   798         _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.Timer.Stop" );

   799         _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleReceivedEventL.Timer.New" );

   800         }

   801     _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Decode" );

   802     TUint8 dcs = KPhSrvUssdDefaultDCS;

   803     if(aMsgAttributes.iFlags & RMobileUssdMessaging::KUssdMessageDcs)

   804         {

   805         dcs = aMsgAttributes.iDcs;

   806         }

   807     iDecodedMessage.Zero();

   808     iReceivedMessage.Zero();

   809     DecodeL(aMsgData, iDecodedMessage, dcs);

   810     if(iDecodedMessage.Length() > 0)

   811         {

   812         iReceivedMessage = iDecodedMessage;

   813         }

   814     // 5. Show note.

   815     // debug print

   816     _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Note" );

   817     if ( !( aMsgAttributes.iFlags & RMobileUssdMessaging::KUssdMessageType ) ||

   818             aMsgAttributes.iType != RMobileUssdMessaging::EUssdMTRequest )

   819         {

   820         if ( !ShowNotesL() )

   821             {

   822             // debug print

   823             _DPRINT( 4,

   824                 "PhSrv.UssdHandleReceivedEventL.SAtReturn" );

   825             return;

   826             }

   827         }

   828 

   829     // empty string is handled as ok message

   830     if ( !iDecodedMessage.Length() )

   831         {

   832         TurnLightsOn(); //Ensure lights on

   833         // debug print

   834         _DPRINT( 4,

   835             "PhSrv.UssdHandleReceivedEventL.EmptyString" );

   836         

   837         ShowDoneNoteL();

   838 

   839         // debug print

   840         _DPRINT( 4,

   841             "PhSrv.UssdHandleReceivedEventL.EmptyString.OK" );

   842         }

   843     else

   844         {

   845        	_DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.String" );

   846         iNotifyMessage = ( aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTNotify );

   847         _DDPRINT( 4, "PhSrv.UssdHandleReceivedEventL.iNotifyMessage: ", iNotifyMessage );

   848         _DDPRINT( 4, "PhSrv.UssdNOHREventL.iNotifyMessage: ", iNotifyMessage );

   849         iMsgTypeReply = ( aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTReply );

   850         _DDPRINT( 4, "PhSrv.UssdHandleReceivedEventL.iMsgTypeReply: ", iMsgTypeReply );

   851         

   852         if ( iNotifyMessage ) 

   853             {

   854             // need to send an MO ack

   855             iAcksToBeSent ++;

   856             }

   857         

   858         if ( iNotifyMessage || iMsgTypeReply )

   859         	{

   860         	//This is for reply message in notifyarray

   861         	iNotifyMessage = ETrue;

   862         	_DDPRINT( 4, "PhSrv.UssdHandleReceivedEventL.iNotifyMessage: ", iNotifyMessage );

   863 

   864 	        //Notify added to array

   865         	iNotifyArray->AppendL( iReceivedMessage );

   866 

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

   868         	UpdateNotifyMessage();

   869 

   870         	if ( !iSendRelease && NotifyCount() <= 1 )

   871 				{

   872 				_DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.!SendRelease.Cancel" );       // debug print

   873 				Cancel();

   874 				}

   875         	}

   876         else

   877        		{

   878        		// New message deletes old message, i.e. Cancel existing query.

   879        		Cancel();

   880 			_DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.NewAnswerable" );       // debug print

   881        		}

   882 

   883         if ( !iGlobalMsgQuery )

   884             {

   885             iGlobalMsgQuery = CAknGlobalMsgQuery::NewL();

   886             }

   887 

   888         // Delay after message query so that application execution order will

   889         // be correct.

   890         iGlobalMsgQuery->SetExitDelay( KPhSrvUssdNoteExitPeriod );

   891 

   892         TInt softkeys = R_AVKON_SOFTKEYS_USSD_ANSWER_EXIT__ANSWER;

   893         if( !( aMsgAttributes.iFlags & RMobileUssdMessaging::KUssdMessageType )

   894              || aMsgAttributes.iType != RMobileUssdMessaging::EUssdMTRequest )

   895             {

   896             softkeys = R_AVKON_SOFTKEYS_EXIT;

   897             }

   898 

   899         // Set timer that lauches Global MessageQuery after time interval.

   900         iSoftkeys = softkeys;

   901 

   902         // debug print

   903         _DPRINT( 4,

   904             "PhSrv.UssdHandleReceivedEventL.String.Middle" );

   905 

   906         // Play the USSD tone if needed. Logically should be in RunL, but here

   907         // to give better balancing with voice and visible message.

   908         if ( IsTelephonyFeatureSupported( KTelephonyLVFlagUssdTone ) )

   909             {

   910             _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.PlayTone" );

   911             PlayUssdTone();

   912             }

   913 

   914         // Launch the new message query

   915         if ( !IsActive() )

   916             {

   917             iLaunchGMQ = ETrue;

   918             iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );

   919             SetActive();

   920             }

   921         AsyncProcessMoAcks();

   922         }

   923     _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Editor" );

   924     if( aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTRequest && UssdAppTaskExistsL() )

   925         {

   926         iEmptyEditor = ETrue;

   927         }

   928     _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.End" );

   929     }

   930 

   931 // -----------------------------------------------------------------------------

   932 // CPhSrvUssdManager::RestartReplyTimerL

   933 //

   934 //

   935 //

   936 // -----------------------------------------------------------------------------

   937 //

   938 void CPhSrvUssdManager::RestartReplyTimerL()

   939     {

   940     if ( iUssdReplyTimer )

   941         {

   942         _DPRINT( 4, "PhSrv.RestartReplyTimerL.Stop" );

   943         iUssdReplyTimer->Stop();

   944         }

   945 

   946     if ( !iUssdReplyTimer )

   947         {

   948         _DPRINT( 4, "PhSrv.RestartReplyTimerL.New" );

   949         iUssdReplyTimer = CPhSrvUssdReplyTimer::NewL( *this );

   950         }

   951     

   952     _DPRINT( 4, "PhSrv.RestartReplyTimerL.Start" );

   953     iUssdReplyTimer->Start();

   954     }

   955 

   956 // -----------------------------------------------------------------------------

   957 // CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL

   958 //

   959 //

   960 //

   961 // -----------------------------------------------------------------------------

   962 //

   963 void CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL(

   964 const RMobilePhone::TMobilePhoneSendSSRequestV3 & aReturnResult,

   965 TInt aError )

   966 	{

   967  	_DDPRINT( 4, "PhSrv.UssdNotifyNWRelease ##### ", aError ); // debug print

   968     _DPRINT_FLAGS();

   969  	TBool showNotes = ShowNotesL();

   970  	iNetworkReleased = ETrue;

   971  	iSendingAck = EFalse;

   972     iSendRelease = EFalse;

   973  	iAcksToBeSent = 0;

   974  	

   975  	if ( iHavePendingSatMessagePointer )

   976  		{

   977  		iReturnResult = aReturnResult;

   978  		if ( !iSatCanceled )

   979  			{

   980  			CompleteSatL(&iReceivedMessage, aError );

   981 			_DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.CompleteSat" );       // debug print

   982  			}

   983  		}

   984  	if ( iUssdReplyTimer && iUssdReplyTimer->IsTimerActive() )

   985     	{

   986     	_DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.Timer.Stop" );

   987     	iUssdReplyTimer->Stop();

   988     	Cancel();

   989     	CheckArray();

   990     	}

   991     if ( showNotes && iShowDone )

   992         {

   993         ShowDoneNoteL();

   994         }

   995     if ( iUssdSendHandler && iSendingAck ) 

   996         {

   997         // if we are sending ack, it can be canceled.

   998         iUssdSendHandler->Cancel();

   999         }

  1000     

  1001     iSatCanceled = EFalse;

  1002     _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.iSatCanceled.EFalse" );

  1003     iShowDone = EFalse;

  1004     _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.Ending" );

  1005     _DPRINT_FLAGS();

  1006     _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.End" );

  1007 	}

  1008 

  1009 // -----------------------------------------------------------------------------

  1010 // CPhSrvUssdManager::ShowDoneNoteL

  1011 //

  1012 // -----------------------------------------------------------------------------

  1013 //

  1014 void CPhSrvUssdManager::ShowDoneNoteL()

  1015     {

  1016     _DDPRINT( 4, "PhSrv.ShowDoneNoteL.iShowDone", iShowDone );

  1017     // Show global confirmation note "Done"

  1018     HBufC* noteText = iResourceManager.ReadResourceLC( R_PHSRV_TEXT_DONE );

  1019     CAknGlobalNote* note = CAknGlobalNote::NewLC();

  1020     note->ShowNoteL( EAknGlobalConfirmationNote, *noteText );

  1021     CleanupStack::PopAndDestroy( note );

  1022     CleanupStack::PopAndDestroy( noteText );

  1023     iShowDone = EFalse;

  1024     }

  1025 

  1026 // -----------------------------------------------------------------------------

  1027 // CPhSrvUssdManager::ShowErrorNoteL

  1028 //

  1029 // -----------------------------------------------------------------------------

  1030 //

  1031 void CPhSrvUssdManager::ShowErrorNoteL( TInt aError )

  1032     {

  1033     _DDPRINT( 4, "PhSrv.ShowErrorNoteL.Start ", aError );

  1034     if ( aError == KErrCancel )

  1035         {

  1036         _DPRINT( 4, "PhSrv.ShowErrorNoteL.Return" );

  1037         return;

  1038         }

  1039 

  1040     CTextResolver* textResolver = CTextResolver::NewLC();

  1041 

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

  1043 

  1044     CAknGlobalNote* note = CAknGlobalNote::NewLC();

  1045     note->ShowNoteL( EAknGlobalErrorNote, *buffer );

  1046 

  1047     CleanupStack::PopAndDestroy( 3 ); // note, buffer, textResolver

  1048     _DPRINT( 4, "PhSrv.ShowErrorNoteL.End" );

  1049     return;

  1050     }

  1051 

  1052 

  1053 // -----------------------------------------------------------------------------

  1054 // CPhSrvUssdManager::DecodeL

  1055 //

  1056 // -----------------------------------------------------------------------------

  1057 //

  1058 void CPhSrvUssdManager::DecodeL(

  1059     const TDesC8& aSrc,

  1060     TDes& aDes ,

  1061     TUint8 aDcs )

  1062     {

  1063     _DPRINT( 4, "PhSrv.DecodeL.Start" );

  1064     aDes.Zero();

  1065     CCnvCharacterSetConverter* charConv = CCnvCharacterSetConverter::NewLC();

  1066 

  1067     iDCS = KPhCltDcsUnknown; // default

  1068 

  1069     // Check DCS

  1070     TSmsDataCodingScheme::TSmsAlphabet alphabet =

  1071         TSmsDataCodingScheme::ESmsAlphabet7Bit; // default

  1072     TUint cutChars = 0;

  1073     TUint startBit = 0;

  1074 

  1075     // Codes from GSM 03.38

  1076     if ( aDcs == KPhSrvUssdDcsAlphabetDefaultPrecededLanguage )

  1077         {

  1078         FindFirstCarriageReturnL( aSrc , cutChars , startBit );

  1079         }

  1080     else if ( aDcs == KPhSrvUssdDcsAlphabetUCS2PrecededLanguage )

  1081         {

  1082         alphabet = TSmsDataCodingScheme::ESmsAlphabetUCS2;

  1083         cutChars = KPhSrvUssdDcsAlphabetUCS2PrecededLanguageSkipChars;

  1084         }

  1085     else if ( (aDcs&KPhSrvUssdDcsGeneralInformationMask)  ==

  1086             KPhSrvUssdDcsGeneralInformation ) // General data coding information

  1087         {

  1088         //Is text compressed?

  1089         if ( aDcs & KPhSrvUssdDcsGeneralInformationCompressed )

  1090             {

  1091             _DPRINT( 4, "PhSrv.DecodeL.KErrNotSupported" );

  1092             User::Leave( KErrNotSupported );

  1093             }

  1094         // Is SIM specific message

  1095         else if ( ( aDcs & KPhSrvUssdDcsGeneralInformationSimMask )

  1096                    == KPhSrvUssdDcsGeneralInformationSim )

  1097             {

  1098             _DPRINT( 4, "PhSrv.DecodeL.KErrAbort" );

  1099             User::Leave( KErrAbort ); // Do not show any messages

  1100             }

  1101         // 8 bit data?

  1102         else if ( ( aDcs&KPhSrvUssdDcsGeneralInformationAlphabetMask ) ==

  1103                    KPhSrvUssdDcsGeneralInformationAlphabet8Bit )

  1104             {

  1105             alphabet = TSmsDataCodingScheme::ESmsAlphabet8Bit;

  1106             }

  1107         // UCS2 bit data?

  1108         else if ( ( aDcs&KPhSrvUssdDcsGeneralInformationAlphabetMask ) ==

  1109                    KPhSrvUssdDcsGeneralInformationAlphabetUCS2 )

  1110             {

  1111             alphabet = TSmsDataCodingScheme::ESmsAlphabetUCS2;

  1112             }

  1113         }

  1114     // Data coding/message handling

  1115     else if ( ( aDcs & KPhSrvUssdDcsMessageHandlingAlphabetMask )

  1116                == KPhSrvUssdDcsMessageHandlingAlphabet8Bit )

  1117         {

  1118         alphabet = TSmsDataCodingScheme::ESmsAlphabet8Bit;

  1119         }

  1120 

  1121     TPhSrvUssdAlphabetPacker* packer =

  1122         new ( ELeave ) TPhSrvUssdAlphabetPacker( alphabet , EFalse, startBit );

  1123     CleanupStack::PushL( packer );

  1124 

  1125     if ( alphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit )

  1126         {

  1127         TInt numberOfElem = ( ( aSrc.Length() - cutChars ) * 8 - startBit ) / 7;

  1128         packer->UnpackAndConvertL(

  1129             *charConv ,

  1130             iFsSession ,

  1131             aSrc.Right( aSrc.Length() - cutChars ),

  1132             aDes ,

  1133             numberOfElem );

  1134